How to use the mapnik.register_default_fonts function in mapnik

opts.grainstore.mapnik_version = mapnik.versions.mapnik;
    }

    // Be nice and warn if configured mapnik version is != instaled mapnik version
    if (mapnik.versions.mapnik != opts.grainstore.mapnik_version) {
        console.warn('WARNING: detected mapnik version (' + mapnik.versions.mapnik + ')' +
            ' != configured mapnik version (' + opts.grainstore.mapnik_version + ')');
    }

    // Set carto renderer configuration for MMLStore
    if ( ! opts.grainstore.carto_env ) opts.grainstore.carto_env = {};
    var cenv = opts.grainstore.carto_env;
    if ( ! cenv.validation_data ) cenv.validation_data = {};
    if ( ! cenv.validation_data.fonts ) {
      mapnik.register_system_fonts();
      mapnik.register_default_fonts();
      var available_fonts = _.keys(mapnik.fontFiles());
      cenv.validation_data.fonts = available_fonts;
    }

    opts.redis = opts.redis || {};
    var redisPool = (opts.redis && opts.redis.pool)
        ? opts.redis.pool
        : new RedisPool(_.extend(opts.redis, {name: 'windshaft:server'}));

    // initialize core mml_store
    var mml_store_opts = { pool: redisPool }; 
    // force GC off, we'll purge localized resources ourselves
    // NOTE: this is not needed anymore with grainstore-0.18.0
    opts.grainstore.gc_prob = 0;
    var mml_store  = new grainstore.MMLStore(mml_store_opts, opts.grainstore);

'host': process.env.PGHOST,
    'dbname': process.env.PGDATABASE,
    'user': process.env.PGUSER,
    'password': process.env.PGPASSWORD,
    'port': process.env.PGPORT,
    'extent': '-20005048.4188,-9039211.13765,19907487.2779,17096598.5401',
    'srid': 3857,
    'type': 'postgis'
};

// register datasource adapters for mapnik database connection
if (mapnik.register_default_input_plugins) {
    mapnik.register_default_input_plugins();
}
// register fonts for text rendering
mapnik.register_default_fonts();


class DatasourceRenderer implements TileRenderer {
    constructor(private getTableDefinitionFn: (tileset: string, dataParams: any) => DataConfig) {}

    async getTile({tileset, z, x, y, scale}: TileParams, dataParams: any): Promise {
        const bbox = getBbox(z, x, y);

        const tileSize = TILE_SIZE * scale;
        let map = new mapnik.Map(tileSize, tileSize, PROJ4_STRING);
        map.bufferSize = TILE_BUFFER_SIZE;
        const layer = new mapnik.Layer('tile', PROJ4_STRING);

        const dataSourceConfig = this.getTableDefinitionFn(tileset, dataParams);

        const conf = Object.assign(dataSourceConfig, DATASOURCE_CONFIG);

this._autoLoadFonts = uri.query.autoLoadFonts;
    this._base = uri.query.base;
    uri.query.metatile = +uri.query.metatile;
    uri.query.resolution = +uri.query.resolution;
    uri.query.bufferSize = +uri.query.bufferSize;
    uri.query.tileSize = +uri.query.tileSize;
    this._uri = uri;

    // Public API to announce how we're metatiling.
    this.metatile = uri.query.metatile;
    this.bufferSize = uri.query.bufferSize;

    // This defaults to true. To disable font auto-loading
    // Set ?autoLoadFonts=false in the mapnik URL to disable
    if (this._autoLoadFonts) {
        if (mapnik.register_default_fonts) mapnik.register_default_fonts();
        if (mapnik.register_system_fonts) mapnik.register_system_fonts();
    }

    // Initialize this map. This wraps `localize()` and calls `create()`
    // afterwards to actually create a new Mapnik map object.
    Step(function() {
        source._loadXML(this);
    }, function(err, xml) {
        if (err) return error(err);
        // https://github.com/mapbox/tilelive-mapnik/issues/25
        // there seems to be no value to assinging xml to a property
        //source._xml = xml;
        source._createMetatileCache();
        source._createPool(xml, this);
    }, function(err) {
        if (err) return error(err);

g.geometry_geom
        FROM
            geometries as g,
            buildings as b
        WHERE
            g.geometry_id = b.geometry_id
            AND b.planning_in_conservation_area = true
    ) as conservation_area`
}

// register datasource adapters for mapnik database connection
if (mapnik.register_default_input_plugins) {
    mapnik.register_default_input_plugins();
}
// register fonts for text rendering
mapnik.register_default_fonts();

const mercator = new SphericalMercator({
    size: TILE_SIZE
});

function getBbox(z, x, y) {
    return mercator.bbox(x, y, z, false, '900913');
}

function getXYZ(bbox, z) {
    return mercator.xyz(bbox, z, false, '900913')
}

function renderTile(tileset, z, x, y, geometryId, cb) {
    const bbox = getBbox(z, x, y)

import * as mapnik from "mapnik";
import * as fs from "fs";
import * as path from "path";

mapnik.register_default_fonts();
mapnik.register_default_input_plugins();

const map: mapnik.Map = new mapnik.Map(256, 256);
map.load('./test/stylesheet.xml', function xx(err: Error, map: mapnik.Map) {
  if (err) throw err;
  map.zoomAll();
  const im: mapnik.Image = new mapnik.Image(256, 256);
  map.render(im, function xxx(err: Error, im: mapnik.Image) {
    if (err) throw err;
    im.encode('png', function xxxx(err: Error, buffer: Buffer) {
      if (err) throw err;
      fs.writeFile('map.png', buffer, function xxxxx(err: Error | null) {
        if (err) throw err;
        console.log('saved map image to map.png');
      });
    });

"use strict"

const fs = require('fs');
const path = require('path');
const d3 = require('d3-queue');


var mapnik = require('mapnik');

mapnik.register_default_input_plugins();
mapnik.register_default_fonts()

//console.log(mapnik.fonts());

const find = (dir) =>
  fs.readdirSync(dir)
    .reduce((files, file) =>
      fs.statSync(path.join(dir, file)).isDirectory() ?
        files.concat(find(path.join(dir, file))) :
        files.concat(path.join(dir, file)),
      []);

function makemappng(basefile, routefile, callback) {

var stylesheet = `

var _ = require('underscore');
var mapnik = require('mapnik');
var RedisPool = require('redis-mpool');

var windshaft = require('../../lib/windshaft');
var DummyMapConfigProvider = require('../../lib/windshaft/models/providers/dummy_mapconfig_provider');

var redisClient = require('redis').createClient(global.environment.redis.port);

mapnik.register_system_fonts();
mapnik.register_default_fonts();
var cartoEnv = {
    validation_data: {
        fonts: _.keys(mapnik.fontFiles())
    }
};

var rendererOptions = global.environment.renderer;
var grainstoreOptions = {
    carto_env: cartoEnv,
    datasource: global.environment.postgres,
    cachedir: global.environment.millstone.cache_basedir,
    mapnik_version: global.environment.mapnik_version || mapnik.versions.mapnik
};
var rendererFactoryOptions = {
    mapnik: {
        grainstore: grainstoreOptions,