@cantoo/fontkit 2.0.5 → 2.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cantoo/fontkit",
-  "version": "2.0.5",
+  "version": "2.0.7",
   "description": "An advanced font engine for Node and the browser",
   "keywords": [
     "opentype",
@@ -18,9 +18,12 @@
     "trie:indic": "node src/opentype/shapers/gen-indic.js",
     "tries": "npm run trie:data && npm run trie:use && npm run trie:indic",
     "build:packages": "node scripts/build-unicode-packages.js",
-    "build": "npm run build:packages && tsup",
+    "build:types": "node scripts/build-types.js",
+    "build:umd": "node scripts/build-umd.js",
+    "build": "npm run build:packages && tsup && npm run build:umd && npm run build:types",
     "prebuild": "node --input-type=module -e \"import fs from 'node:fs'; if (!fs.existsSync('src/opentype/shapers/data.trie')) { console.error('Missing trie files. Run: npm run tries'); process.exit(1); }\"",
     "lint": "eslint .",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
     "test": "vitest run",
     "test:watch": "vitest",
     "coverage": "vitest run --coverage",
@@ -32,15 +35,27 @@
   "node-module": "dist/module.mjs",
   "browser": "dist/browser.cjs",
   "module": "dist/browser-module.mjs",
+  "unpkg": "dist/fontkit.umd.js",
+  "jsdelivr": "dist/fontkit.umd.js",
+  "types": "dist/index.d.ts",
   "source": "src/index.js",
   "exports": {
     ".": {
+      "types": "./dist/index.d.ts",
       "node": {
+        "types": "./dist/index.d.ts",
         "import": "./dist/module.mjs",
         "require": "./dist/main.cjs"
       },
-      "import": "./dist/browser-module.mjs",
-      "require": "./dist/browser.cjs"
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/browser-module.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/browser.cjs"
+      },
+      "default": "./dist/browser-module.mjs"
     },
     "./unicode-trie": {
       "import": "./src/packages/unicode-trie/dist/index.mjs",
@@ -58,7 +73,8 @@
   },
   "files": [
     "src",
-    "dist"
+    "dist",
+    "types"
   ],
   "author": "Devon Govett <devongovett@gmail.com>",
   "license": "MIT",
@@ -83,6 +99,7 @@
     "@babel/plugin-proposal-decorators": "^8.0.2",
     "@eslint/js": "^10.0.1",
     "@stylistic/eslint-plugin": "^5.10.0",
+    "@types/node": "^26.5.0",
     "@vitest/coverage-v8": "^5.0.0",
     "codepoints": "^1.3.0",
     "esbuild": "^0.28.2",

package/src/CmapProcessor.js

@@ -3,9 +3,19 @@ import { getEncoding, getEncodingMapping } from './encodings';
 import { cache } from './decorators';
 import { range } from './utils';
 
+/** @typedef {import('../types/fontkit').CmapTable} CmapTable */
+/** @typedef {import('../types/fontkit').CmapSubtable} CmapSubtable */
+/** @typedef {import('../types/fontkit').CmapSubtable14} CmapSubtable14 */
+/** @typedef {import('../types/fontkit').CmapGroup} CmapGroup */
+/** @typedef {import('../types/fontkit').CmapVarSelector} CmapVarSelector */
+
 export default class CmapProcessor {
+  /**
+   * @param {CmapTable} cmapTable
+   */
   constructor(cmapTable) {
     // Attempt to find a Unicode cmap first
+    /** @type {Map<number, number> | null} */
     this.encoding = null;
     this.cmap = this.findSubtable(cmapTable, [
       // 32-bit subtables
@@ -24,7 +34,14 @@ export default class CmapProcessor {
     // If not unicode cmap was found, take the first table with a supported encoding.
     if (!this.cmap) {
       for (let cmap of cmapTable.tables) {
-        let encoding = getEncoding(cmap.platformID, cmap.encodingID, cmap.table.language - 1);
+        let language
+          = 'language' in cmap.table && typeof cmap.table.language === 'number'
+            ? cmap.table.language - 1
+            : 0;
+        let encoding = getEncoding(cmap.platformID, cmap.encodingID, language);
+        if (!encoding) {
+          continue;
+        }
         let mapping = getEncodingMapping(encoding);
         if (mapping) {
           this.cmap = cmap.table;
@@ -37,12 +54,16 @@ export default class CmapProcessor {
       throw new Error('Could not find a supported cmap table');
     }
 
-    this.uvs = this.findSubtable(cmapTable, [[0, 5]]);
-    if (this.uvs && this.uvs.version !== 14) {
-      this.uvs = null;
-    }
+    let uvs = this.findSubtable(cmapTable, [[0, 5]]);
+    /** @type {CmapSubtable14 | null} */
+    this.uvs = uvs && uvs.version === 14 ? /** @type {CmapSubtable14} */ (uvs) : null;
   }
 
+  /**
+   * @param {CmapTable} cmapTable
+   * @param {Array<[number, number]>} pairs
+   * @returns {CmapSubtable | null}
+   */
   findSubtable(cmapTable, pairs) {
     for (let [platformID, encodingID] of pairs) {
       for (let cmap of cmapTable.tables) {
@@ -55,6 +76,11 @@ export default class CmapProcessor {
     return null;
   }
 
+  /**
+   * @param {number} codepoint
+   * @param {number} [variationSelector]
+   * @returns {number}
+   */
   lookup(codepoint, variationSelector) {
     // If there is no Unicode cmap in this font, we need to re-encode
     // the codepoint in the encoding that the cmap supports.
@@ -80,21 +106,21 @@ export default class CmapProcessor {
         while (min <= max) {
           let mid = (min + max) >> 1;
 
-          if (codepoint < cmap.startCode.get(mid)) {
+          if (codepoint < /** @type {number} */ (cmap.startCode.get(mid))) {
             max = mid - 1;
-          } else if (codepoint > cmap.endCode.get(mid)) {
+          } else if (codepoint > /** @type {number} */ (cmap.endCode.get(mid))) {
             min = mid + 1;
           } else {
-            let rangeOffset = cmap.idRangeOffset.get(mid);
+            let rangeOffset = /** @type {number} */ (cmap.idRangeOffset.get(mid));
             let gid;
 
             if (rangeOffset === 0) {
-              gid = codepoint + cmap.idDelta.get(mid);
+              gid = codepoint + /** @type {number} */ (cmap.idDelta.get(mid));
             } else {
-              let index = rangeOffset / 2 + (codepoint - cmap.startCode.get(mid)) - (cmap.segCount - mid);
+              let index = rangeOffset / 2 + (codepoint - /** @type {number} */ (cmap.startCode.get(mid))) - (cmap.segCount - mid);
               gid = cmap.glyphIndexArray.get(index) || 0;
               if (gid !== 0) {
-                gid += cmap.idDelta.get(mid);
+                gid += /** @type {number} */ (cmap.idDelta.get(mid));
               }
             }
 
@@ -118,7 +144,7 @@ export default class CmapProcessor {
         let max = cmap.nGroups - 1;
         while (min <= max) {
           let mid = (min + max) >> 1;
-          let group = cmap.groups.get(mid);
+          let group = /** @type {CmapGroup} */ (cmap.groups.get(mid));
 
           if (codepoint < group.startCharCode) {
             max = mid - 1;
@@ -140,10 +166,15 @@ export default class CmapProcessor {
         throw new Error('TODO: cmap format 14');
 
       default:
-        throw new Error(`Unknown cmap format ${cmap.version}`);
+        throw new Error(`Unknown cmap format ${/** @type {{ version: number }} */ (cmap).version}`);
     }
   }
 
+  /**
+   * @param {number} codepoint
+   * @param {number} variationSelector
+   * @returns {number}
+   */
   getVariationSelector(codepoint, variationSelector) {
     if (!this.uvs) {
       return 0;
@@ -155,7 +186,8 @@ export default class CmapProcessor {
       return 0;
     }
 
-    let { defaultUVS, nonDefaultUVS } = selectors[i];
+    let sel = /** @type {CmapVarSelector} */ (selectors[i]);
+    let { defaultUVS, nonDefaultUVS } = sel;
 
     // Default UVS: fall back to the base character's normal cmap glyph.
     if (defaultUVS && binarySearch(defaultUVS, x =>
@@ -168,6 +200,9 @@ export default class CmapProcessor {
     return ni !== -1 ? nonDefaultUVS[ni].glyphID : 0;
   }
 
+  /**
+   * @returns {number[]}
+   */
   @cache
   getCharacterSet() {
     let cmap = this.cmap;
@@ -180,7 +215,7 @@ export default class CmapProcessor {
         let endCodes = cmap.endCode.toArray();
         for (let i = 0; i < endCodes.length; i++) {
           let tail = endCodes[i] + 1;
-          let start = cmap.startCode.get(i);
+          let start = /** @type {number} */ (cmap.startCode.get(i));
           res.push(...range(start, tail));
         }
 
@@ -208,10 +243,14 @@ export default class CmapProcessor {
         throw new Error('TODO: cmap format 14');
 
       default:
-        throw new Error(`Unknown cmap format ${cmap.version}`);
+        throw new Error(`Unknown cmap format ${/** @type {{ version: number }} */ (cmap).version}`);
     }
   }
 
+  /**
+   * @param {number} gid
+   * @returns {number[]}
+   */
   @cache
   codePointsForGlyph(gid) {
     let cmap = this.cmap;
@@ -230,10 +269,10 @@ export default class CmapProcessor {
       case 4: {
         let res = [];
         for (let i = 0; i < cmap.segCount; i++) {
-          let end = cmap.endCode.get(i);
-          let start = cmap.startCode.get(i);
-          let rangeOffset = cmap.idRangeOffset.get(i);
-          let delta = cmap.idDelta.get(i);
+          let end = /** @type {number} */ (cmap.endCode.get(i));
+          let start = /** @type {number} */ (cmap.startCode.get(i));
+          let rangeOffset = /** @type {number} */ (cmap.idRangeOffset.get(i));
+          let delta = /** @type {number} */ (cmap.idDelta.get(i));
 
           for (var c = start; c <= end; c++) {
             let g;

package/src/DFont.js

@@ -1,6 +1,68 @@
 import * as r from 'restructure';
 import TTFFont from './TTFFont';
 
+/** @typedef {import('restructure').DecodeStream} DecodeStream */
+/** @typedef {import('restructure').StructValue} StructValue */
+/** @typedef {import('restructure').BinaryBuffer} BinaryBuffer */
+/** @typedef {import('../types/fontkit').NameString} NameString */
+
+/**
+ * @param {NameString | null | undefined} a
+ * @param {string | Uint8Array} b
+ * @returns {boolean}
+ */
+function postscriptNamesEqual(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (a instanceof Uint8Array && b instanceof Uint8Array) {
+    return a.length === b.length && a.every((v, i) => b[i] === v);
+  }
+  return false;
+}
+
+/**
+ * @typedef {StructValue & {
+ *   id: number,
+ *   nameOffset: number,
+ *   attr: number,
+ *   dataOffset: number,
+ *   handle: number,
+ *   name?: string | null
+ * }} DFontRef
+ */
+
+/**
+ * @typedef {StructValue & {
+ *   name: string,
+ *   maxTypeIndex: number,
+ *   refList: DFontRef[]
+ * }} DFontType
+ */
+
+/**
+ * @typedef {StructValue & {
+ *   length: number,
+ *   types: DFontType[]
+ * }} DFontTypeList
+ */
+
+/**
+ * @typedef {StructValue & {
+ *   typeList: DFontTypeList,
+ *   nameListOffset: number
+ * }} DFontMap
+ */
+
+/**
+ * @typedef {StructValue & {
+ *   dataOffset: number,
+ *   map: DFontMap,
+ *   dataLength: number,
+ *   mapLength: number
+ * }} DFontHeaderValue
+ */
+
 let DFontName = new r.String(r.uint8);
 
 let Ref = new r.Struct({
@@ -14,12 +76,16 @@ let Ref = new r.Struct({
 let Type = new r.Struct({
   name: new r.String(4),
   maxTypeIndex: r.uint16,
-  refList: new r.Pointer(r.uint16, new r.Array(Ref, t => t.maxTypeIndex + 1), { type: 'parent' })
+  refList: new r.Pointer(
+    r.uint16,
+    new r.Array(Ref, t => /** @type {DFontType} */ (t).maxTypeIndex + 1),
+    { type: 'parent' }
+  )
 });
 
 let TypeList = new r.Struct({
   length: r.uint16,
-  types: new r.Array(Type, t => t.length + 1)
+  types: new r.Array(Type, t => /** @type {DFontTypeList} */ (t).length + 1)
 });
 
 let DFontMap = new r.Struct({
@@ -36,13 +102,27 @@ let DFontHeader = new r.Struct({
 });
 
 export default class DFont {
+  /** @type {string} */
   type = 'DFont';
 
+  /** @type {DecodeStream} */
+  stream;
+  /** @type {DFontHeaderValue} */
+  header;
+  /** @type {DFontType | undefined} */
+  sfnt;
+
+  /**
+   * @param {BinaryBuffer | Uint8Array} buffer
+   * @returns {boolean}
+   */
   static probe(buffer) {
     let stream = new r.DecodeStream(buffer);
 
     try {
-      var header = DFontHeader.decode(stream);
+      var header = /** @type {DFontHeaderValue} */ (
+        /** @type {unknown} */ (DFontHeader.decode(stream))
+      );
     } catch (e) {
       return false;
     }
@@ -56,9 +136,14 @@ export default class DFont {
     return false;
   }
 
+  /**
+   * @param {DecodeStream} stream
+   */
   constructor(stream) {
     this.stream = stream;
-    this.header = DFontHeader.decode(this.stream);
+    this.header = /** @type {DFontHeaderValue} */ (
+      /** @type {unknown} */ (DFontHeader.decode(this.stream))
+    );
 
     for (let type of this.header.map.typeList.types) {
       for (let ref of type.refList) {
@@ -76,6 +161,10 @@ export default class DFont {
     }
   }
 
+  /**
+   * @param {string | Uint8Array} name
+   * @returns {TTFFont | null}
+   */
   getFont(name) {
     if (!this.sfnt) {
       return null;
@@ -83,16 +172,14 @@ export default class DFont {
 
     for (let ref of this.sfnt.refList) {
       let pos = this.header.dataOffset + ref.dataOffset + 4;
-      let stream = new r.DecodeStream(this.stream.buffer.slice(pos));
+      let buf = this.stream.buffer;
+      let bytes
+        = buf instanceof Uint8Array
+          ? buf
+          : new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+      let stream = new r.DecodeStream(bytes.subarray(pos));
       let font = new TTFFont(stream);
-      if (
-        font.postscriptName === name
-        || (
-          font.postscriptName instanceof Uint8Array
-          && name instanceof Uint8Array
-          && font.postscriptName.every((v, i) => name[i] === v)
-        )
-      ) {
+      if (postscriptNamesEqual(font.postscriptName, name)) {
         return font;
       }
     }
@@ -100,11 +187,24 @@ export default class DFont {
     return null;
   }
 
+  /**
+   * @type {TTFFont[]}
+   */
   get fonts() {
+    /** @type {TTFFont[]} */
     let fonts = [];
+    if (!this.sfnt) {
+      return fonts;
+    }
+
     for (let ref of this.sfnt.refList) {
       let pos = this.header.dataOffset + ref.dataOffset + 4;
-      let stream = new r.DecodeStream(this.stream.buffer.slice(pos));
+      let buf = this.stream.buffer;
+      let bytes
+        = buf instanceof Uint8Array
+          ? buf
+          : new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+      let stream = new r.DecodeStream(bytes.subarray(pos));
       fonts.push(new TTFFont(stream));
     }