harfbuzzjs 0.4.15 → 0.6.0

package/package.json

@@ -1,37 +1,38 @@
 {
-  "name": "harfbuzzjs",
-  "version": "0.4.15",
-  "description": "Minimal version of HarfBuzz for JavaScript use",
-  "main": "index.js",
-  "scripts": {
-    "test": "mocha test/index.js"
-  },
-  "keywords": [
-    "harfbuzz",
-    "opentype",
-    "truetype",
-    "ttf",
-    "otf",
-    "graphics",
-    "complex scripts",
-    "typography",
-    "font rendering",
-    "font",
-    "fonts",
-    "emoji"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/harfbuzz/harfbuzzjs.git"
-  },
-  "author": "Ebrahim Byagowi <ebrahim@gnu.org>",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/harfbuzz/harfbuzzjs/issues"
-  },
-  "homepage": "https://github.com/harfbuzz/harfbuzzjs#readme",
-  "devDependencies": {
-    "chai": "^4.3.7",
-    "mocha": "^10.2.0"
-  }
-}
+	"name": "harfbuzzjs",
+	"version": "0.6.0",
+	"description": "Minimal version of HarfBuzz for JavaScript use",
+	"main": "index.js",
+	"scripts": {
+		"prepare": "make",
+		"test": "make test"
+	},
+	"keywords": [
+		"harfbuzz",
+		"opentype",
+		"truetype",
+		"ttf",
+		"otf",
+		"graphics",
+		"complex scripts",
+		"typography",
+		"font rendering",
+		"font",
+		"fonts",
+		"emoji"
+	],
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/harfbuzz/harfbuzzjs.git"
+	},
+	"author": "Ebrahim Byagowi <ebrahim@gnu.org>",
+	"license": "MIT",
+	"bugs": {
+		"url": "https://github.com/harfbuzz/harfbuzzjs/issues"
+	},
+	"homepage": "https://github.com/harfbuzz/harfbuzzjs#readme",
+	"devDependencies": {
+		"chai": "^4.3.7",
+		"mocha": "^10.2.0"
+	}
+}

package/test/index.js

@@ -2,7 +2,7 @@ const fs = require('fs');
 const path = require('path');
 const { expect } = require('chai');
 let hb;
-let blob, face, font, buffer;
+let blob, face, font, buffer, fontFuncs;
 
 before(async function () {
   hb = await require('..');
@@ -13,7 +13,8 @@ afterEach(function () {
   if (face) face.destroy();
   if (font) font.destroy();
   if (buffer) buffer.destroy();
-  blob = face = font = buffer = undefined;
+  if (fontFuncs) fontFuncs.destroy();
+  blob = face = font = buffer = fontFuncs = undefined;
 });
 
 describe('Face', function () {
@@ -45,9 +46,177 @@ describe('Face', function () {
     face = hb.createFace(blob);
     expect(Object.keys(face.getAxisInfos())).to.have.lengthOf(0);
   });
+
+  it('getTableScriptTags returns tags for a font', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    expect(face.getTableScriptTags('GSUB')).to.deep.equal(['DFLT', 'cyrl', 'dev2', 'deva', 'grek', 'latn']);
+    expect(face.getTableScriptTags('GPOS')).to.deep.equal(['DFLT', 'cyrl', 'dev2', 'deva', 'grek', 'latn']);
+  });
+
+  it('getTableFeatureTags returns tags for a font', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    expect(face.getTableFeatureTags('GSUB')).to.deep.equal([
+      'aalt', 'abvs', 'akhn', 'blwf', 'blwf', 'blws', 'c2sc', 'case', 'ccmp', 'ccmp',
+      'ccmp', 'ccmp', 'cjct', 'cjct', 'dnom', 'frac', 'half', 'half', 'half', 'half',
+      'haln', 'liga', 'lnum', 'locl', 'locl', 'locl', 'locl', 'locl', 'locl', 'locl',
+      'locl', 'locl', 'locl', 'locl', 'locl', 'nukt', 'numr', 'onum', 'ordn', 'pnum',
+      'pres', 'pres', 'psts', 'rkrf', 'rphf', 'rtlm', 'salt', 'sinf', 'smcp', 'ss03',
+      'ss04', 'ss06', 'ss07', 'subs', 'sups', 'tnum', 'vatu', 'zero'
+    ]);
+    expect(face.getTableFeatureTags('GPOS')).to.deep.equal(['abvm', 'blwm', 'dist', 'kern', 'mark', 'mkmk']);
+  });
+
+  it('getScriptLanguageTags returns tags for a font', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    expect(face.getScriptLanguageTags('GSUB', 1)).to.deep.equal(['MKD ', 'SRB ']);
+    expect(face.getScriptLanguageTags('GPOS', 5)).to.deep.equal([]);
+  });
+
+  it('getScriptLanguageTags returns tags for GPOS table', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSansDevanagari-Regular.otf')));
+    face = hb.createFace(blob);
+    expect(face.getScriptLanguageTags('GPOS', 1)).to.deep.equal(['MAR ', 'NEP ', 'SAN ', 'SAT ']);
+  });
+
+  it('getLanguageFeatureTags returns tags for a font', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    expect(face.getLanguageFeatureTags('GSUB', 1, 1)).to.deep.equal(['aalt', 'c2sc', 'case', 'ccmp', 'dnom', 'frac',
+      'liga', 'lnum', 'locl', 'numr', 'onum', 'ordn', 'pnum', 'rtlm', 'sinf', 'smcp', 'ss03', 'ss06', 'ss07', 'subs',
+      'sups', 'tnum', 'zero']);
+    expect(face.getLanguageFeatureTags('GPOS', 5, 5)).to.deep.equal([]);
+  });
+
+  it('getTableScriptTags, getScriptLanguageTags, and getLanguageFeatureTags all together', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSansArabic-Variable.ttf')));
+    face = hb.createFace(blob);
+    let result = {};
+    face.getTableScriptTags('GSUB').forEach((script, scriptIndex) => {
+      result[script] = { 'dflt': face.getLanguageFeatureTags('GSUB', scriptIndex, 0xFFFF) };
+      face.getScriptLanguageTags('GSUB', scriptIndex).forEach((language, languageIndex) => {
+        result[script][language] = face.getLanguageFeatureTags('GSUB', scriptIndex, languageIndex);
+      });
+    });
+    expect(result).to.deep.equal({
+      'DFLT': {
+        'dflt': ['aalt', 'ccmp', 'dlig', 'fina', 'init', 'isol', 'medi']
+      },
+      'arab': {
+        'dflt': ['aalt', 'ccmp', 'dlig', 'fina', 'init', 'isol', 'medi', 'rlig'],
+        'URD ': ['aalt', 'ccmp', 'dlig', 'fina', 'init', 'isol', 'locl', 'medi']
+      }
+    });
+  });
+
+  it('listNames fetches all names', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    let names = face.listNames();
+    expect(names.length).to.equal(38);
+    expect(names[0]).to.deep.equal({ nameId: 0, language: 'en' });
+    expect(names[37]).to.deep.equal({ nameId: 278, language: 'en' });
+  })
+
+  it('getName fetches a name', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    expect(face.getName(1, 'en')).to.equal('Noto Sans');
+    expect(face.getName(256, 'en')).to.equal('florin symbol');
+  })
+
+  it('getFeatureNameIds returns valid name Ids for ssNN features', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    expect(face.getFeatureNameIds("GSUB",
+      face.getTableFeatureTags("GSUB").indexOf("ss03"))).to.deep.equal({
+        uiLabelNameId: 256,
+        uiTooltipTextNameId: null,
+        sampleTextNameId: null,
+        paramUiLabelNameIds: []
+      });
+  })
+
+  it('getFeatureNameIds with getName', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    expect(face.getName(face.getFeatureNameIds("GSUB",
+      face.getTableFeatureTags("GSUB").indexOf("ss03")).uiLabelNameId, 'en')).to.equal('florin symbol');
+  })
+
+  it('getFeatureNameIds not found', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    expect(face.getFeatureNameIds("GSUB",
+      face.getTableFeatureTags("GSUB").indexOf("salt"))).to.equal(null);
+  })
+
+  it('getFeatureNameIds returns valid name Ids for cvNN features', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, '../harfbuzz/test/api/fonts/cv01.otf')));
+    face = hb.createFace(blob);
+    expect(face.getFeatureNameIds("GSUB",
+      face.getTableFeatureTags("GSUB").indexOf("cv01"))).to.deep.equal({
+        uiLabelNameId: 256,
+        uiTooltipTextNameId: 257,
+        sampleTextNameId: 258,
+        paramUiLabelNameIds: [259, 260]
+      });
+  })
 });
 
 describe('Font', function () {
+  it('subFont creates a sub font', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    let subFont = font.subFont();
+    expect(subFont.ptr).to.not.equal(font.ptr);
+    subFont.destroy();
+  });
+
+  it('subFont font funcs fallback to parent', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    let subFont = font.subFont();
+    expect(subFont.ptr).to.not.equal(font.ptr);
+
+    fontFuncs = hb.createFontFuncs();
+    fontFuncs.setGlyphNameFunc(function (font_, glyph) {
+      expect(font_.ptr).to.equal(subFont.ptr);
+      return null;
+    });
+    subFont.setFuncs(fontFuncs);
+
+    expect(subFont.glyphName(20)).to.equal("gid20");
+    expect(subFont.glyphHAdvance(20)).to.equal(font.glyphHAdvance(20));
+    subFont.destroy();
+  });
+
+  it('hExtents returns extents for the font', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    expect(font.hExtents()).to.deep.equal({
+      ascender: 1069,
+      descender: -293,
+      lineGap: 0
+    });
+  });
+
+  it('vExtents returns extents for the font', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    expect(font.vExtents()).to.deep.equal({
+      ascender: 0,
+      descender: 0,
+      lineGap: 0
+    });
+  });
+
   it('glyphName returns names for glyph ids', function () {
     blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
     face = hb.createFace(blob);
@@ -68,6 +237,54 @@ describe('Font', function () {
     expect(glyphs[0].ax).to.equal(561 * 2);
   });
 
+  it('glyphExtents returns extents for glyph ids', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    expect(font.glyphExtents(20)).to.deep.equal({
+      xBearing: 89,
+      yBearing: 714,
+      width: 266,
+      height: -714
+    });
+  });
+
+  it('glyphHAdvance returns advances for glyph ids', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    expect(font.glyphHAdvance(20)).to.equal(572);
+  });
+
+  it('glyphVAdvance returns advances for glyph ids', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    expect(font.glyphVAdvance(20)).to.equal(-1000);
+  });
+
+  it('glyphHOrigin returns origins for glyph ids', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    expect(font.glyphHOrigin(20)).to.deep.equal([0, 0]);
+  });
+
+  it('glyphVOrigin returns origins for glyph ids', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    expect(font.glyphVOrigin(20)).to.equal(null);
+  });
+
+  it('glyphFromName returns ids for glyph names', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    expect(font.glyphFromName('one')).to.equal(20);
+    expect(font.glyphFromName('NonExistentGlyph')).to.equal(null);
+  });
+
   it('setVariations affects advances', function () {
     blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSansArabic-Variable.ttf')));
     face = hb.createFace(blob);
@@ -111,6 +328,206 @@ describe('Font', function () {
   });
 });
 
+describe('FontFuncs', function () {
+  it('setGlyphExtentsFunc', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    fontFuncs = hb.createFontFuncs();
+    fontFuncs.setGlyphExtentsFunc(function (font_, glyph) {
+      expect(font_.ptr).to.equal(font.ptr);
+      return {
+        xBearing: glyph,
+        yBearing: 0,
+        width: 100 * glyph,
+        height: 100
+      };
+    });
+    font.setFuncs(fontFuncs);
+    expect(font.glyphExtents(0)).to.deep.equal({
+      xBearing: 0,
+      yBearing: 0,
+      width: 0,
+      height: 100
+    });
+    expect(font.glyphExtents(20)).to.deep.equal({
+      xBearing: 20,
+      yBearing: 0,
+      width: 2000,
+      height: 100
+    });
+  });
+
+  it('setGlyphFromNameFunc', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    fontFuncs = hb.createFontFuncs();
+    fontFuncs.setGlyphFromNameFunc(function (font_, name) {
+      expect(font_.ptr).to.equal(font.ptr);
+      return name == 'one' ? 20 : null;
+    });
+    font.setFuncs(fontFuncs);
+    expect(font.glyphFromName('one')).to.equal(20);
+    expect(font.glyphFromName('two')).to.equal(null);
+  });
+
+  it('setGlyphHAdvanceFunc', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    fontFuncs = hb.createFontFuncs();
+    fontFuncs.setGlyphHAdvanceFunc(function (font_, glyph) {
+      expect(font_.ptr).to.equal(font.ptr);
+      return glyph == 20 ? 100 : 200;
+    });
+    font.setFuncs(fontFuncs);
+    expect(font.glyphHAdvance(20)).to.equal(100);
+    expect(font.glyphHAdvance(21)).to.equal(200);
+  });
+
+  it('setGlyphVAdvanceFunc', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    fontFuncs = hb.createFontFuncs();
+    fontFuncs.setGlyphVAdvanceFunc(function (font_, glyph) {
+      expect(font_.ptr).to.equal(font.ptr);
+      return glyph == 20 ? 100 : 200;
+    });
+    font.setFuncs(fontFuncs);
+    expect(font.glyphVAdvance(20)).to.equal(100);
+    expect(font.glyphVAdvance(21)).to.equal(200);
+  });
+
+  it('setGlyphHOriginFunc', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    fontFuncs = hb.createFontFuncs();
+    fontFuncs.setGlyphHOriginFunc(function (font_, glyph) {
+      expect(font_.ptr).to.equal(font.ptr);
+      return glyph == 20 ? [100, 200] : [300, 400];
+    });
+    font.setFuncs(fontFuncs);
+    expect(font.glyphHOrigin(20)).to.deep.equal([100, 200]);
+    expect(font.glyphHOrigin(21)).to.deep.equal([300, 400]);
+  });
+
+  it('setGlyphVOriginFunc', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    fontFuncs = hb.createFontFuncs();
+    fontFuncs.setGlyphVOriginFunc(function (font_, glyph) {
+      expect(font_.ptr).to.equal(font.ptr);
+      return glyph == 20 ? [100, 200] : [300, 400];
+    });
+    font.setFuncs(fontFuncs);
+    expect(font.glyphVOrigin(20)).to.deep.equal([100, 200]);
+    expect(font.glyphVOrigin(21)).to.deep.equal([300, 400]);
+  });
+
+  it('setGlyphNameFunc', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    fontFuncs = hb.createFontFuncs();
+    fontFuncs.setGlyphNameFunc(function (font_, glyph) {
+      expect(font_.ptr).to.equal(font.ptr);
+      return glyph == 20 ? 'one' : null;
+    });
+    font.setFuncs(fontFuncs);
+    expect(font.glyphName(20)).to.equal('one');
+    expect(font.glyphName(21)).to.equal('gid21');
+  });
+
+  it('setNominalGlyphFunc', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    fontFuncs = hb.createFontFuncs();
+    fontFuncs.setNominalGlyphFunc(function (font_, unicode) {
+      expect(font_.ptr).to.equal(font.ptr);
+      return unicode == 49 ? 21 : 22;
+    });
+    font.setFuncs(fontFuncs);
+    buffer = hb.createBuffer();
+    buffer.addText('12');
+    buffer.guessSegmentProperties();
+    hb.shape(font, buffer)
+    const glyphs = buffer.json();
+    expect(glyphs[0].g).to.equal(21);
+    expect(glyphs[1].g).to.equal(22);
+  });
+
+  it('setVariationGlyphFunc', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    fontFuncs = hb.createFontFuncs();
+    fontFuncs.setNominalGlyphFunc(function (font_, unicode) {
+      expect(font_.ptr).to.equal(font.ptr);
+      return unicode == 49 ? 21 : 22;
+    });
+    fontFuncs.setVariationGlyphFunc(function (font_, unicode, variationSelector) {
+      expect(font_.ptr).to.equal(font.ptr);
+      return unicode == 49 ? 23 : null;
+    });
+    font.setFuncs(fontFuncs);
+    buffer = hb.createBuffer();
+    buffer.addText('11\uFE002\uFE00');
+    buffer.guessSegmentProperties();
+    hb.shape(font, buffer)
+    const glyphs = buffer.json();
+    expect(glyphs[0].g).to.equal(21);
+    expect(glyphs[1].g).to.equal(23);
+    expect(glyphs[2].g).to.equal(22);
+  });
+
+  it('setFontHExtentsFunc', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    fontFuncs = hb.createFontFuncs();
+    fontFuncs.setFontHExtentsFunc(function (font_) {
+      expect(font_.ptr).to.equal(font.ptr);
+      return {
+        ascender: 100,
+        descender: 200,
+        lineGap: 300,
+      };
+    });
+    font.setFuncs(fontFuncs);
+    expect(font.hExtents()).to.deep.equal({
+      ascender: 100,
+      descender: 200,
+      lineGap: 300,
+    });
+  });
+
+  it('setFontVExtentsFunc', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    fontFuncs = hb.createFontFuncs();
+    fontFuncs.setFontVExtentsFunc(function (font_) {
+      expect(font_.ptr).to.equal(font.ptr);
+      return {
+        ascender: 100,
+        descender: 200,
+        lineGap: 300,
+      };
+    });
+    font.setFuncs(fontFuncs);
+    expect(font.vExtents()).to.deep.equal({
+      ascender: 100,
+      descender: 200,
+      lineGap: 300,
+    });
+  });
+});
+
 describe('Buffer', function () {
   it('setDirection controls direction of glyphs', function () {
     blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
@@ -169,6 +586,20 @@ describe('shape', function () {
     expect(glyphs[2]).to.deep.equal({ cl: 2, g: 70, ax: 480, ay: 0, dx: 0, dy: 0, flags: 0 } /* c */);
   });
 
+  it('shape Latin string code points', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    buffer = hb.createBuffer();
+    buffer.addCodePoints([...'abc'].map(c => c.codePointAt(0)));
+    buffer.guessSegmentProperties();
+    hb.shape(font, buffer)
+    const glyphs = buffer.json();
+    expect(glyphs[0]).to.deep.equal({ cl: 0, g: 68, ax: 561, ay: 0, dx: 0, dy: 0, flags: 0 } /* a */);
+    expect(glyphs[1]).to.deep.equal({ cl: 1, g: 69, ax: 615, ay: 0, dx: 0, dy: 0, flags: 0 } /* b */);
+    expect(glyphs[2]).to.deep.equal({ cl: 2, g: 70, ax: 480, ay: 0, dx: 0, dy: 0, flags: 0 } /* c */);
+  });
+
   it('shape Arabic string', function () {
     blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSansArabic-Variable.ttf')));
     face = hb.createFace(blob);
@@ -184,6 +615,32 @@ describe('shape', function () {
     expect(glyphs[3]).to.deep.equal({ cl: 0, g: 50, ax: 235, ay: 0, dx: 0, dy: 0, flags: 0 } /* أ */);
   });
 
+  it('shape Arabic string item', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSansArabic-Variable.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    buffer = hb.createBuffer();
+    buffer.addText('أبجد', 1, 2);
+    buffer.guessSegmentProperties();
+    hb.shape(font, buffer)
+    const glyphs = buffer.json();
+    expect(glyphs[0]).to.deep.equal({ cl: 2, g: 529, ax: 637, ay: 0, dx: 0, dy: 0, flags: 1 } /* ج */);
+    expect(glyphs[1]).to.deep.equal({ cl: 1, g: 101, ax: 269, ay: 0, dx: 0, dy: 0, flags: 0 } /* ب */);
+  });
+
+  it('shape Arabic code points item', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSansArabic-Variable.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    buffer = hb.createBuffer();
+    buffer.addCodePoints([...'أبجد'].map(c => c.codePointAt(0)), 1, 2);
+    buffer.guessSegmentProperties();
+    hb.shape(font, buffer)
+    const glyphs = buffer.json();
+    expect(glyphs[0]).to.deep.equal({ cl: 2, g: 529, ax: 637, ay: 0, dx: 0, dy: 0, flags: 1 } /* ج */);
+    expect(glyphs[1]).to.deep.equal({ cl: 1, g: 101, ax: 269, ay: 0, dx: 0, dy: 0, flags: 0 } /* ب */);
+  });
+
   it('shape with tracing', function () {
     blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
     face = hb.createFace(blob);

package/build-subset.sh

@@ -1,20 +0,0 @@
-#!/bin/bash
-set -e
-
-em++ \
-	-std=c++11 \
-	-fno-exceptions \
-	-fno-rtti \
-	-fno-threadsafe-statics \
-	-fvisibility-inlines-hidden \
-	-Oz \
-	-I. \
-	-DHB_TINY \
-	-DHB_USE_INTERNAL_QSORT \
-	-DHB_CONFIG_OVERRIDE_H=\"config-override-subset.h\" \
-	-DHB_EXPERIMENTAL_API \
-	--no-entry \
-	-s EXPORTED_FUNCTIONS=@hb-subset.symbols \
-	-s INITIAL_MEMORY=65MB \
-	-o hb-subset.wasm \
-	harfbuzz/src/harfbuzz-subset.cc

package/build.sh

@@ -1,27 +0,0 @@
-#!/bin/bash
-set -e
-
-em++ \
-	-std=c++11 \
-	-fno-exceptions \
-	-fno-rtti \
-	-fno-threadsafe-statics \
-	-fvisibility-inlines-hidden \
-	-flto \
-	-Oz \
-	-I. \
-	-DHB_TINY \
-	-DHB_USE_INTERNAL_QSORT \
-	-DHB_CONFIG_OVERRIDE_H=\"config-override.h\" \
-	-DHB_EXPERIMENTAL_API \
-	--no-entry \
-	-s MODULARIZE \
-	-s EXPORT_NAME=createHarfBuzz \
-	-s EXPORTED_FUNCTIONS=@hb.symbols \
-	-s EXPORTED_RUNTIME_METHODS='["addFunction", "removeFunction", "wasmMemory", "wasmExports", "HEAP8", "HEAPU8", "HEAP32", "HEAPU32", "HEAPF32"]' \
-	-s INITIAL_MEMORY=256KB \
-	-s ALLOW_MEMORY_GROWTH \
-	-s ALLOW_TABLE_GROWTH \
-	-lexports.js \
-	-o hb.js \
-	harfbuzz/src/harfbuzz.cc