harfbuzzjs 0.4.14 → 0.5.0

package/hbjs.js

@@ -3,6 +3,7 @@ function hbjs(Module) {
 
   var exports = Module.wasmExports;
   var utf8Decoder = new TextDecoder("utf8");
+  var utf8Encoder = new TextEncoder("utf8");
   let addFunction = Module.addFunction;
   let removeFunction = Module.removeFunction;
 
@@ -15,24 +16,28 @@ function hbjs(Module) {
   var GSUB_PHASE = 1;
   var GPOS_PHASE = 2;
 
+  const STATIC_ARRAY_SIZE = 128
+
   function hb_tag(s) {
     return (
       (s.charCodeAt(0) & 0xFF) << 24 |
       (s.charCodeAt(1) & 0xFF) << 16 |
-      (s.charCodeAt(2) & 0xFF) <<  8 |
-      (s.charCodeAt(3) & 0xFF) <<  0
+      (s.charCodeAt(2) & 0xFF) << 8 |
+      (s.charCodeAt(3) & 0xFF) << 0
     );
   }
 
-  var HB_BUFFER_SERIALIZE_FORMAT_JSON	= hb_tag('JSON');
-  var HB_BUFFER_SERIALIZE_FLAG_NO_GLYPH_NAMES	= 4;
+  var HB_BUFFER_SERIALIZE_FORMAT_JSON = hb_tag('JSON');
+  var HB_BUFFER_SERIALIZE_FLAG_NO_GLYPH_NAMES = 4;
+
+  const HB_OT_NAME_ID_INVALID = 0xFFFF;
 
   function _hb_untag(tag) {
     return [
       String.fromCharCode((tag >> 24) & 0xFF),
       String.fromCharCode((tag >> 16) & 0xFF),
-      String.fromCharCode((tag >>  8) & 0xFF),
-      String.fromCharCode((tag >>  0) & 0xFF)
+      String.fromCharCode((tag >> 8) & 0xFF),
+      String.fromCharCode((tag >> 0) & 0xFF)
     ].join('');
   }
 
@@ -46,6 +51,19 @@ function hbjs(Module) {
     return 0x0;
   }
 
+  function _language_to_string(language) {
+    var ptr = exports.hb_language_to_string(language);
+    var str = utf8Decoder.decode(Module.HEAPU8.subarray(ptr, Module.HEAPU8.indexOf(0, ptr)));
+    return str;
+  }
+
+  function _language_from_string(str) {
+    var languageStr = createAsciiString(str);
+    var languagePtr = exports.hb_language_from_string(languageStr.ptr, -1);
+    languageStr.free();
+    return languagePtr;
+  }
+
   /**
   * Create an object representing a Harfbuzz blob.
   * @param {string} blob A blob of binary data (usually the contents of a font file).
@@ -94,18 +112,18 @@ function hbjs(Module) {
        * Return the binary contents of an OpenType table.
        * @param {string} table Table name
        */
-      reference_table: function(table) {
+      reference_table: function (table) {
         var blob = exports.hb_face_reference_table(ptr, hb_tag(table));
         var length = exports.hb_blob_get_length(blob);
         if (!length) { return; }
         var blobptr = exports.hb_blob_get_data(blob, null);
-        var table_string = Module.HEAPU8.subarray(blobptr, blobptr+length);
+        var table_string = Module.HEAPU8.subarray(blobptr, blobptr + length);
         return table_string;
       },
       /**
        * Return variation axis infos
        */
-      getAxisInfos: function() {
+      getAxisInfos: function () {
         var axis = exports.malloc(64 * 32);
         var c = exports.malloc(4);
         Module.HEAPU32[c / 4] = 64;
@@ -125,13 +143,180 @@ function hbjs(Module) {
       /**
        * Return unicodes the face supports
        */
-      collectUnicodes: function() {
+      collectUnicodes: function () {
         var unicodeSetPtr = exports.hb_set_create();
         exports.hb_face_collect_unicodes(ptr, unicodeSetPtr);
         var result = typedArrayFromSet(unicodeSetPtr);
         exports.hb_set_destroy(unicodeSetPtr);
         return result;
       },
+      /**
+       * Return all scripts enumerated in the specified face's
+       * GSUB table or GPOS table.
+       * @param {string} table: The table to query, either "GSUB" or "GPOS".
+       **/
+      getTableScriptTags: function (table) {
+        var tableTag = hb_tag(table);
+        var startOffset = 0;
+        var scriptCount = STATIC_ARRAY_SIZE;
+        var scriptCountPtr = Module.stackAlloc(4);
+        var scriptTagsPtr = Module.stackAlloc(STATIC_ARRAY_SIZE * 4);
+        var tags = [];
+        while (scriptCount == STATIC_ARRAY_SIZE) {
+          Module.HEAPU32[scriptCountPtr / 4] = scriptCount;
+          exports.hb_ot_layout_table_get_script_tags(ptr, tableTag, startOffset,
+            scriptCountPtr, scriptTagsPtr);
+          scriptCount = Module.HEAPU32[scriptCountPtr / 4];
+          var scriptTags = Module.HEAPU32.subarray(scriptTagsPtr / 4,
+            scriptTagsPtr / 4 + scriptCount);
+          tags.push(...Array.from(scriptTags).map(_hb_untag));
+          startOffset += scriptCount;
+        }
+        return tags;
+      },
+      /**
+       * Return all features enumerated in the specified face's
+       * GSUB table or GPOS table.
+       * @param {string} table: The table to query, either "GSUB" or "GPOS".
+       **/
+      getTableFeatureTags: function (table) {
+        var tableTag = hb_tag(table);
+        var startOffset = 0;
+        var featureCount = STATIC_ARRAY_SIZE;
+        var featureCountPtr = Module.stackAlloc(4);
+        var featureTagsPtr = Module.stackAlloc(STATIC_ARRAY_SIZE * 4);
+        var tags = [];
+        while (featureCount == STATIC_ARRAY_SIZE) {
+          Module.HEAPU32[featureCountPtr / 4] = featureCount;
+          exports.hb_ot_layout_table_get_feature_tags(ptr, tableTag, startOffset,
+            featureCountPtr, featureTagsPtr);
+          featureCount = Module.HEAPU32[featureCountPtr / 4];
+          var scriptTags = Module.HEAPU32.subarray(featureTagsPtr / 4,
+            featureTagsPtr / 4 + featureCount);
+          tags.push(...Array.from(scriptTags).map(_hb_untag));
+          startOffset += featureCount;
+        }
+        return tags;
+      },
+      /**
+       * Return language tags in the given face's GSUB or GPOS table, underneath
+       * the specified script index.
+       * @param {string} table: The table to query, either "GSUB" or "GPOS".
+       * @param {number} scriptIndex: The index of the script to query.
+       **/
+      getScriptLanguageTags: function (table, scriptIndex) {
+        var tableTag = hb_tag(table);
+        var startOffset = 0;
+        var languageCount = STATIC_ARRAY_SIZE;
+        var languageCountPtr = Module.stackAlloc(4);
+        var languageTagsPtr = Module.stackAlloc(STATIC_ARRAY_SIZE * 4);
+        var tags = [];
+        while (languageCount == STATIC_ARRAY_SIZE) {
+          Module.HEAPU32[languageCountPtr / 4] = languageCount;
+          exports.hb_ot_layout_script_get_language_tags(ptr, tableTag, scriptIndex, startOffset,
+            languageCountPtr, languageTagsPtr);
+          languageCount = Module.HEAPU32[languageCountPtr / 4];
+          var languageTags = Module.HEAPU32.subarray(languageTagsPtr / 4,
+            languageTagsPtr / 4 + languageCount);
+          tags.push(...Array.from(languageTags).map(_hb_untag));
+          startOffset += languageCount;
+        }
+        return tags;
+      },
+      /**
+       * Return all features in the specified face's GSUB table or GPOS table,
+       * underneath the specified script and language.
+       * @param {string} table: The table to query, either "GSUB" or "GPOS".
+       * @param {number} scriptIndex: The index of the script to query.
+       * @param {number} languageIndex: The index of the language to query.
+       **/
+      getLanguageFeatureTags: function (table, scriptIndex, languageIndex) {
+        var tableTag = hb_tag(table);
+        var startOffset = 0;
+        var featureCount = STATIC_ARRAY_SIZE;
+        var featureCountPtr = Module.stackAlloc(4);
+        var featureTagsPtr = Module.stackAlloc(STATIC_ARRAY_SIZE * 4);
+        var tags = [];
+        while (featureCount == STATIC_ARRAY_SIZE) {
+          Module.HEAPU32[featureCountPtr / 4] = featureCount;
+          exports.hb_ot_layout_language_get_feature_tags(ptr, tableTag, scriptIndex, languageIndex, startOffset,
+            featureCountPtr, featureTagsPtr);
+          featureCount = Module.HEAPU32[featureCountPtr / 4];
+          var featureTags = Module.HEAPU32.subarray(featureTagsPtr / 4,
+            featureTagsPtr / 4 + featureCount);
+          tags.push(...Array.from(featureTags).map(_hb_untag));
+          startOffset += featureCount;
+        }
+        return tags;
+      },
+      /**
+       * Return all names in the specified face's name table.
+       **/
+      listNames: function () {
+        var numEntriesPtr = Module.stackAlloc(4);
+        var entriesPtr = exports.hb_ot_name_list_names(ptr, numEntriesPtr);
+        var numEntries = Module.HEAPU32[numEntriesPtr / 4];
+        var entries = [];
+        for (var i = 0; i < numEntries; i++) {
+          // FIXME: this depends on the struct memory layout.
+          // A more robust way would involve ading helper C functions to access
+          // the struct and use them here.
+          entries.push({
+            nameId: Module.HEAPU32[(entriesPtr / 4) + (i * 3)],
+            language: _language_to_string(Module.HEAPU32[(entriesPtr / 4) + (i * 3) + 2])
+          });
+        }
+        return entries;
+      },
+      /**
+       * Get the name of the specified face.
+       * @param {number} nameId The ID of the name to get.
+       * @param {string} language The language of the name to get.
+       **/
+      getName: function (nameId, language) {
+        var languagePtr = _language_from_string(language);
+        var nameLen = exports.hb_ot_name_get_utf16(ptr, nameId, languagePtr, 0, 0) + 1;
+        var textSizePtr = Module.stackAlloc(4);
+        var textPtr = exports.malloc(nameLen * 2);
+        Module.HEAPU32[textSizePtr / 4] = nameLen;
+        exports.hb_ot_name_get_utf16(ptr, nameId, languagePtr, textSizePtr, textPtr);
+        var name = String.fromCharCode.apply(null, Module.HEAPU16.subarray(textPtr / 2, textPtr / 2 + nameLen - 1));
+        exports.free(textPtr);
+        return name;
+      },
+      /**
+       * Get the name IDs of the specified feature.
+       * @param {string} table The table to query, either "GSUB" or "GPOS".
+       * @param {number} featureIndex The index of the feature to query.
+       **/
+      getFeatureNameIds: function (table, featureIndex) {
+        var tableTag = hb_tag(table);
+        var labelIdPtr = Module.stackAlloc(4);
+        var tooltipIdPtr = Module.stackAlloc(4);
+        var sampleIdPtr = Module.stackAlloc(4);
+        var numNamedParametersPtr = Module.stackAlloc(4);
+        var firstParameterIdPtr = Module.stackAlloc(4);
+
+        var found = exports.hb_ot_layout_feature_get_name_ids(ptr, tableTag, featureIndex,
+          labelIdPtr, tooltipIdPtr, sampleIdPtr, numNamedParametersPtr, firstParameterIdPtr);
+
+        if (found) {
+          let uiLabelNameId = Module.HEAPU32[labelIdPtr / 4];
+          let uiTooltipTextNameId = Module.HEAPU32[tooltipIdPtr / 4];
+          let sampleTextNameId = Module.HEAPU32[sampleIdPtr / 4];
+          let numNamedParameters = Module.HEAPU32[numNamedParametersPtr / 4];
+          let firstParameterId = Module.HEAPU32[firstParameterIdPtr / 4];
+          let paramUiLabelNameIds = Array(numNamedParameters).fill().map((_, i) => firstParameterId + i);
+          return {
+            uiLabelNameId: uiLabelNameId == HB_OT_NAME_ID_INVALID ? null : uiLabelNameId,
+            uiTooltipTextNameId: uiTooltipTextNameId == HB_OT_NAME_ID_INVALID ? null : uiTooltipTextNameId,
+            sampleTextNameId: sampleTextNameId == HB_OT_NAME_ID_INVALID ? null : sampleTextNameId,
+            paramUiLabelNameIds: paramUiLabelNameIds
+          };
+        }
+
+        return null;
+      },
       /**
        * Free the object.
        */
@@ -149,9 +334,10 @@ function hbjs(Module) {
   /**
   * Create an object representing a Harfbuzz font.
   * @param {object} blob An object returned from `createFace`.
+  * @param {number} ptr Optional pointer to an existing font.
   **/
-  function createFont(face) {
-    var ptr = exports.hb_font_create(face.ptr);
+  function createFont(face, ptr) {
+    var ptr = ptr ? exports.hb_font_reference(ptr) : exports.hb_font_create(face.ptr);
     var drawFuncsPtr = null;
     var moveToPtr = null;
     var lineToPtr = null;
@@ -216,8 +402,110 @@ function hbjs(Module) {
 
     return {
       ptr: ptr,
+      /**
+       * Create a sub font.
+       * @returns {object} Object representing the sub font.
+       **/
+      subFont: function () {
+        return createFont(null, exports.hb_font_create_sub_font(ptr));
+      },
+      /**
+       * Return font horizontal extents.
+       * @returns {object} Object with ascender, descender, and lineGap properties.
+       **/
+      hExtents: function () {
+        var extentsPtr = Module.stackAlloc(12);
+        exports.hb_font_get_h_extents(ptr, extentsPtr);
+        return {
+          ascender: Module.HEAP32[extentsPtr / 4],
+          descender: Module.HEAP32[extentsPtr / 4 + 1],
+          lineGap: Module.HEAP32[extentsPtr / 4 + 2],
+        };
+      },
+      /**
+       * Return font vertical extents.
+       * @returns {object} Object with ascender, descender, and lineGap properties.
+       **/
+      vExtents: function () {
+        var extentsPtr = Module.stackAlloc(12);
+        exports.hb_font_get_v_extents(ptr, extentsPtr);
+        return {
+          ascender: Module.HEAP32[extentsPtr / 4],
+          descender: Module.HEAP32[extentsPtr / 4 + 1],
+          lineGap: Module.HEAP32[extentsPtr / 4 + 2],
+        };
+      },
       glyphName: glyphName,
       glyphToPath: glyphToPath,
+      /**
+       * Return glyph horizontal advance.
+       * @param {number} glyphId ID of the requested glyph in the font.
+       **/
+      glyphHAdvance: function (glyphId) {
+        return exports.hb_font_get_glyph_h_advance(ptr, glyphId);
+      },
+      /**
+       * Return glyph vertical advance.
+       * @param {number} glyphId ID of the requested glyph in the font.
+       **/
+      glyphVAdvance: function (glyphId) {
+        return exports.hb_font_get_glyph_v_advance(ptr, glyphId);
+      },
+      /**
+       * Return glyph horizontal origin.
+       * @param {number} glyphId ID of the requested glyph in the font.
+       **/
+      glyphHOrigin: function (glyphId) {
+        let xPtr = Module.stackAlloc(4);
+        let yPtr = Module.stackAlloc(4);
+        if (exports.hb_font_get_glyph_h_origin(ptr, glyphId, xPtr, yPtr)) {
+          return [Module.HEAP32[xPtr / 4], Module.HEAP32[yPtr / 4]];
+        }
+        return null;
+      },
+      /**
+       * Return glyph vertical origin.
+       * @param {number} glyphId ID of the requested glyph in the font.
+       **/
+      glyphVOrigin: function (glyphId) {
+        let xPtr = Module.stackAlloc(4);
+        let yPtr = Module.stackAlloc(4);
+        if (exports.hb_font_get_glyph_v_origin(ptr, glyphId, xPtr, yPtr)) {
+          return [Module.HEAP32[xPtr / 4], Module.HEAP32[yPtr / 4]];
+        }
+        return null;
+      },
+      /**
+       * Return glyph extents.
+       * @param {number} glyphId ID of the requested glyph in the font.
+       **/
+      glyphExtents: function (glyphId) {
+        var extentsPtr = Module.stackAlloc(16);
+        if (exports.hb_font_get_glyph_extents(ptr, glyphId, extentsPtr)) {
+          return {
+            xBearing: Module.HEAP32[extentsPtr / 4],
+            yBearing: Module.HEAP32[extentsPtr / 4 + 1],
+            width: Module.HEAP32[extentsPtr / 4 + 2],
+            height: Module.HEAP32[extentsPtr / 4 + 3]
+          };
+        }
+        return null;
+      },
+      /**
+       * Return glyph ID from name.
+       * @param {string} name Name of the requested glyph in the font.
+       **/
+      glyphFromName: function (name) {
+        var glyphId = null;
+        var glyphIdPtr = Module.stackAlloc(4);
+        var namePtr = exports.malloc(name.length + 1);
+        utf8Encoder.encodeInto(name, Module.HEAPU8.subarray(namePtr, namePtr + name.length));
+        if (exports.hb_font_get_glyph_from_name(ptr, namePtr, name.length, glyphIdPtr)) {
+          glyphId = Module.HEAPU32[glyphIdPtr / 4];
+        }
+        exports.free(namePtr);
+        return glyphId;
+      },
       /**
       * Return a glyph as a JSON path string
       * based on format described on https://svgwg.org/specs/paths/#InterfaceSVGPathSegment
@@ -254,6 +542,13 @@ function hbjs(Module) {
         exports.free(vars);
       },
       /**
+      * Set the font's font functions.
+      * @param {object} fontFuncs The font functions.
+      **/
+      setFuncs: function (fontFuncs) {
+        exports.hb_font_set_funcs(ptr, fontFuncs.ptr);
+      },
+      /**
       * Free the object.
       */
       destroy: function () {
@@ -271,6 +566,304 @@ function hbjs(Module) {
     };
   }
 
+  /**
+  * Create a object representing a HarfBuzz font functions.
+  **/
+  function createFontFuncs() {
+    var ptr = exports.hb_font_funcs_create();
+    return {
+      ptr: ptr,
+      /**
+      * Set the font's glyph extents function.
+      * @param {function} func The function to set.
+      *
+      * The function takes the following arguments:
+      * @param {object} font The font.
+      * @param {number} glyph The glyph ID.
+      *
+      * The function should return an object with the following properties, or null on failure:
+      * @param {number} xBearing The x bearing of the glyph.
+      * @param {number} yBearing The y bearing of the glyph.
+      * @param {number} width The width of the glyph.
+      * @param {number} height The height of the glyph.
+      **/
+      setGlyphExtentsFunc: function (func) {
+        let funcPtr = addFunction(function (fontPtr, font_data, glyph, extentsPtr, user_data) {
+          let font = createFont(null, fontPtr);
+          let extents = func(font, glyph);
+          font.destroy();
+          if (extents) {
+            Module.HEAP32[extentsPtr / 4] = extents.xBearing;
+            Module.HEAP32[extentsPtr / 4 + 1] = extents.yBearing;
+            Module.HEAP32[extentsPtr / 4 + 2] = extents.width;
+            Module.HEAP32[extentsPtr / 4 + 3] = extents.height;
+            return 1;
+          }
+          return 0;
+        }, 'ippipp');
+        exports.hb_font_funcs_set_glyph_extents_func(ptr, funcPtr, 0, 0);
+      },
+      /**
+      * Set the font's glyph from name function.
+      * @param {function} func The function to set.
+      *
+      * The function takes the following arguments:
+      * @param {object} font The font.
+      * @param {string} name The glyph name.
+      *
+      * The function should return an object with the following properties, or null on failure:
+      * @param {number} glyph The glyph ID.
+      **/
+      setGlyphFromNameFunc: function (func) {
+        let funcPtr = addFunction(function (fontPtr, font_data, namePtr, len, glyphPtr, user_data) {
+          let font = createFont(null, fontPtr);
+          let name = utf8Decoder.decode(Module.HEAPU8.subarray(namePtr, namePtr + len));
+          let glyph = func(font, name);
+          font.destroy();
+          if (glyph) {
+            Module.HEAPU32[glyphPtr / 4] = glyph;
+            return 1;
+          }
+          return 0;
+        }, 'ipppipp');
+        exports.hb_font_funcs_set_glyph_from_name_func(ptr, funcPtr, 0, 0);
+      },
+      /**
+      * Set the font's glyph horizontal advance function.
+      * @param {function} func The function to set.
+      *
+      * The function takes the following arguments:
+      * @param {object} font The font.
+      * @param {number} glyph The glyph ID.
+      *
+      * The function should return the horizontal advance of the glyph.
+      **/
+      setGlyphHAdvanceFunc: function (func) {
+        let funcPtr = addFunction(function (fontPtr, font_data, glyph, user_data) {
+          let font = createFont(null, fontPtr);
+          let advance = func(font, glyph);
+          font.destroy();
+          return advance;
+        }, 'ippip');
+        exports.hb_font_funcs_set_glyph_h_advance_func(ptr, funcPtr, 0, 0);
+      },
+      /**
+      * Set the font's glyph vertical advance function.
+      * @param {function} func The function to set.
+      *
+      * The function takes the following arguments:
+      * @param {object} font The font.
+      * @param {number} glyph The glyph ID.
+      *
+      * The function should return the vertical advance of the glyph.
+      **/
+      setGlyphVAdvanceFunc: function (func) {
+        let funcPtr = addFunction(function (fontPtr, font_data, glyph, user_data) {
+          let font = createFont(null, fontPtr);
+          let advance = func(font, glyph);
+          font.destroy();
+          return advance;
+        }, 'ippip');
+        exports.hb_font_funcs_set_glyph_v_advance_func(ptr, funcPtr, 0, 0);
+      },
+      /**
+      * Set the font's glyph horizontal origin function.
+      * @param {function} func The function to set.
+      *
+      * The function takes the following arguments:
+      * @param {object} font The font.
+      * @param {number} glyph The glyph ID.
+      *
+      * The function should return the x and y horizontal origin of the glyph, or null on failure.
+      **/
+      setGlyphHOriginFunc: function (func) {
+        let funcPtr = addFunction(function (fontPtr, font_data, glyph, xPtr, yPtr, user_data) {
+          let font = createFont(null, fontPtr);
+          let origin = func(font, glyph);
+          font.destroy();
+          if (origin) {
+            Module.HEAP32[xPtr / 4] = origin[0];
+            Module.HEAP32[yPtr / 4] = origin[1];
+            return 1;
+          }
+          return 0;
+        }, 'ippippp');
+        exports.hb_font_funcs_set_glyph_h_origin_func(ptr, funcPtr, 0, 0);
+      },
+      /**
+      * Set the font's glyph vertical origin function.
+      * @param {function} func The function to set.
+      *
+      * The function takes the following arguments:
+      * @param {object} font The font.
+      * @param {number} glyph The glyph ID.
+      *
+      * The function should return the x and y vertical origin of the glyph, or null on failure.
+      **/
+      setGlyphVOriginFunc: function (func) {
+        let funcPtr = addFunction(function (fontPtr, font_data, glyph, xPtr, yPtr, user_data) {
+          let font = createFont(null, fontPtr);
+          let origin = func(font, glyph);
+          font.destroy();
+          if (origin) {
+            Module.HEAP32[xPtr / 4] = origin[0];
+            Module.HEAP32[yPtr / 4] = origin[1];
+            return 1;
+          }
+          return 0;
+        }, 'ippippp');
+        exports.hb_font_funcs_set_glyph_v_origin_func(ptr, funcPtr, 0, 0);
+      },
+      /**
+      * Set the font's glyph horizontal kerning function.
+      * @param {function} func The function to set.
+      *
+      * The function takes the following arguments:
+      * @param {object} font The font.
+      * @param {number} firstGlyph The first glyph ID.
+      * @param {number} secondGlyph The second glyph ID.
+      *
+      * The function should return the horizontal kerning of the glyphs.
+      **/
+      setGlyphHKerningFunc: function (func) {
+        let funcPtr = addFunction(function (fontPtr, font_data, firstGlyph, secondGlyph, user_data) {
+          let font = createFont(null, fontPtr);
+          let kerning = func(font, firstGlyph, secondGlyph);
+          font.destroy();
+          return kerning;
+        }, 'ippiip');
+        exports.hb_font_funcs_set_glyph_h_kerning_func(ptr, funcPtr, 0, 0);
+      },
+      /**
+      * Set the font's glyph name function.
+      * @param {function} func The function to set.
+      *
+      * The function takes the following arguments:
+      * @param {object} font The font.
+      * @param {number} glyph The glyph ID.
+      *
+      * The function should return the name of the glyph, or null on failure.
+      **/
+      setGlyphNameFunc: function (func) {
+        let funcPtr = addFunction(function (fontPtr, font_data, glyph, namePtr, size, user_data) {
+          let font = createFont(null, fontPtr);
+          let name = func(font, glyph);
+          font.destroy();
+          if (name) {
+            utf8Encoder.encodeInto(name, Module.HEAPU8.subarray(namePtr, namePtr + size));
+            return 1;
+          }
+          return 0;
+        }, 'ippipip');
+        exports.hb_font_funcs_set_glyph_name_func(ptr, funcPtr, 0, 0);
+      },
+      /**
+      * Set the font's nominal glyph function.
+      * @param {function} func The function to set.
+      *
+      * The function takes the following arguments:
+      * @param {object} font The font.
+      * @param {number} unicode The unicode.
+      *
+      * The function should return the nominal glyph of the unicode, or null on failure.
+      **/
+      setNominalGlyphFunc: function (func) {
+        let funcPtr = addFunction(function (fontPtr, font_data, unicode, glyphPtr, user_data) {
+          let font = createFont(null, fontPtr);
+          let glyph = func(font, unicode);
+          font.destroy();
+          if (glyph) {
+            Module.HEAPU32[glyphPtr / 4] = glyph;
+            return 1;
+          }
+          return 0;
+        }, 'ippipp');
+        exports.hb_font_funcs_set_nominal_glyph_func(ptr, funcPtr, 0, 0);
+      },
+      /**
+      * Set the font's variation glyph function.
+      * @param {function} func The function to set.
+      *
+      * The function takes the following arguments:
+      * @param {object} font The font.
+      * @param {number} unicode The unicode.
+      * @param {number} variationSelector The variation selector.
+      *
+      * The function should return the variation glyph of the unicode, or null on failure.
+      **/
+      setVariationGlyphFunc: function (func) {
+        let funcPtr = addFunction(function (fontPtr, font_data, unicode, variationSelector, glyphPtr, user_data) {
+          let font = createFont(null, fontPtr);
+          let glyph = func(font, unicode, variationSelector);
+          font.destroy();
+          if (glyph) {
+            Module.HEAPU32[glyphPtr / 4] = glyph;
+            return 1;
+          }
+          return 0;
+        }, 'ippiipp');
+        exports.hb_font_funcs_set_variation_glyph_func(ptr, funcPtr, 0, 0);
+      },
+      /**
+      * Set the font's horizontal extents function.
+      * @param {function} func The function to set.
+      *
+      * The function takes the following arguments:
+      * @param {object} font The font.
+      *
+      * The function should return an object with the following properties, or null on failure:
+      * @param {number} ascender The ascender of the font.
+      * @param {number} descender The descender of the font.
+      * @param {number} lineGap The line gap of the font.
+      **/
+      setFontHExtentsFunc: function (func) {
+        let funcPtr = addFunction(function (fontPtr, font_data, extentsPtr, user_data) {
+          let font = createFont(null, fontPtr);
+          let extents = func(font);
+          font.destroy();
+          if (extents) {
+            Module.HEAP32[extentsPtr / 4] = extents.ascender;
+            Module.HEAP32[extentsPtr / 4 + 1] = extents.descender;
+            Module.HEAP32[extentsPtr / 4 + 2] = extents.lineGap;
+            return 1;
+          }
+          return 0;
+        }, 'ipppp');
+        exports.hb_font_funcs_set_font_h_extents_func(ptr, funcPtr, 0, 0);
+      },
+      /**
+      * Set the font's vertical extents function.
+      * @param {function} func The function to set.
+      *
+      * The function takes the following arguments:
+      * @param {object} font The font.
+      *
+      * The function should return an object with the following properties, or null on failure:
+      * @param {number} ascender The ascender of the font.
+      * @param {number} descender The descender of the font.
+      * @param {number} lineGap The line gap of the font.
+      **/
+      setFontVExtentsFunc: function (func) {
+        let funcPtr = addFunction(function (fontPtr, font_data, extentsPtr, user_data) {
+          let font = createFont(null, fontPtr);
+          let extents = func(font);
+          font.destroy();
+          if (extents) {
+            Module.HEAP32[extentsPtr / 4] = extents.ascender;
+            Module.HEAP32[extentsPtr / 4 + 1] = extents.descender;
+            Module.HEAP32[extentsPtr / 4 + 2] = extents.lineGap;
+            return 1;
+          }
+          return 0;
+        }, 'ipppp');
+        exports.hb_font_funcs_set_font_v_extents_func(ptr, funcPtr, 0, 0);
+      },
+      destroy: function () {
+        exports.hb_font_funcs_destroy(ptr);
+      }
+    };
+  }
+
   /**
   * Use when you know the input range should be ASCII.
   * Faster than encoding to UTF-8
@@ -353,7 +946,7 @@ function hbjs(Module) {
           flagValue |= _buffer_flag(s);
         })
 
-        exports.hb_buffer_set_flags(ptr,flagValue);
+        exports.hb_buffer_set_flags(ptr, flagValue);
       },
       /**
       * Set buffer language explicitly.
@@ -361,7 +954,7 @@ function hbjs(Module) {
       */
       setLanguage: function (language) {
         var str = createAsciiString(language);
-        exports.hb_buffer_set_language(ptr, exports.hb_language_from_string(str.ptr,-1));
+        exports.hb_buffer_set_language(ptr, exports.hb_language_from_string(str.ptr, -1));
         str.free();
       },
       /**
@@ -370,7 +963,7 @@ function hbjs(Module) {
       */
       setScript: function (script) {
         var str = createAsciiString(script);
-        exports.hb_buffer_set_script(ptr, exports.hb_script_from_string(str.ptr,-1));
+        exports.hb_buffer_set_script(ptr, exports.hb_script_from_string(str.ptr, -1));
         str.free();
       },
 
@@ -548,6 +1141,7 @@ function hbjs(Module) {
     createBlob: createBlob,
     createFace: createFace,
     createFont: createFont,
+    createFontFuncs: createFontFuncs,
     createBuffer: createBuffer,
     shape: shape,
     shapeWithTrace: shapeWithTrace,
@@ -559,4 +1153,4 @@ function hbjs(Module) {
 // Should be replaced with something more reliable
 try {
   module.exports = hbjs;
-} catch (e) {}
+} catch (e) { }