@cantoo/fontkit 2.0.5 → 2.0.7

package/src/tables/name.js

@@ -1,23 +1,81 @@
 import * as r from 'restructure';
 import { getEncoding, LANGUAGES } from '../encodings';
 
+/** @typedef {import('restructure').StructValue} StructValue */
+
+/**
+ * @typedef {{
+ *   platformID: number,
+ *   encodingID: number,
+ *   languageID: number,
+ *   nameID: number,
+ *   length: number,
+ *   string: string
+ * }} NameRecordValue
+ */
+
+/**
+ * @typedef {Record<string, string | unknown>} LangStringMap
+ */
+
+/**
+ * @typedef {{
+ *   fontFeatures: Record<number, LangStringMap>,
+ *   reservedNameID?: Record<number, LangStringMap>,
+ *   [key: string]: LangStringMap | Record<number, LangStringMap> | undefined
+ * }} NameRecordsMap
+ */
+
+/**
+ * @typedef {StructValue & {
+ *   version: number,
+ *   count: number,
+ *   stringOffset: number,
+ *   records: NameRecordValue[] | NameRecordsMap,
+ *   langTags?: Array<{ tag: string }>
+ * }} NameTableValue
+ */
+
 let NameRecord = new r.Struct({
   platformID: r.uint16,
   encodingID: r.uint16,
   languageID: r.uint16,
   nameID: r.uint16,
   length: r.uint16,
-  string: new r.Pointer(r.uint16,
-    new r.String('length', t => getEncoding(t.platformID, t.encodingID, t.languageID)),
-    { type: 'parent', relativeTo: ctx => ctx.parent.stringOffset, allowNull: false }
+  string: new r.Pointer(
+    r.uint16,
+    new r.String(
+      'length',
+      /** @param {StructValue} t @returns {string} */
+      t => getEncoding(
+        /** @type {number} */ (t.platformID),
+        /** @type {number} */ (t.encodingID),
+        /** @type {number} */ (t.languageID)
+      ) || 'utf16be'
+    ),
+    {
+      type: 'parent',
+      /** @param {StructValue} ctx @returns {number} */
+      relativeTo: ctx => /** @type {number} */ (/** @type {StructValue} */ (ctx.parent).stringOffset),
+      allowNull: false
+    }
   )
 });
 
 let LangTagRecord = new r.Struct({
   length: r.uint16,
-  tag: new r.Pointer(r.uint16, new r.String('length', 'utf16be'), { type: 'parent', relativeTo: ctx => ctx.stringOffset })
+  tag: new r.Pointer(
+    r.uint16,
+    new r.String('length', 'utf16be'),
+    {
+      type: 'parent',
+      /** @param {StructValue} ctx @returns {number} */
+      relativeTo: ctx => /** @type {number} */ (ctx.stringOffset)
+    }
+  )
 });
 
+/** @type {import('restructure').VersionedStruct} */
 var NameTable = new r.VersionedStruct(r.uint16, {
   0: {
     count: r.uint16,
@@ -64,6 +122,12 @@ const NAMES = [
   'variationsPostScriptNamePrefix'
 ];
 
+/**
+ * @param {NameRecordValue[]} out
+ * @param {number} nameID
+ * @param {unknown} string
+ * @returns {void}
+ */
 function pushEnRecord(out, nameID, string) {
   if (typeof string !== 'string') return;
 
@@ -78,13 +142,17 @@ function pushEnRecord(out, nameID, string) {
 }
 
 NameTable.process = function (_stream) {
+  let self = /** @type {NameTableValue} */ (this);
+  /** @type {NameRecordsMap} */
   let records = { fontFeatures: {} };
 
-  for (let record of this.records) {
-    let language = LANGUAGES[record.platformID][record.languageID];
+  for (let record of /** @type {NameRecordValue[]} */ (self.records)) {
+    let platformMap = LANGUAGES[record.platformID] || {};
+    /** @type {string | undefined} */
+    let language = platformMap[record.languageID];
 
-    if (language == null && this.langTags != null && record.languageID >= 0x8000) {
-      language = this.langTags[record.languageID - 0x8000].tag;
+    if (language == null && self.langTags != null && record.languageID >= 0x8000) {
+      language = self.langTags[record.languageID - 0x8000].tag;
     }
 
     if (language == null) {
@@ -109,49 +177,62 @@ NameTable.process = function (_stream) {
     }
   }
 
-  this.records = records;
+  self.records = records;
 };
 
 NameTable.preEncode = function () {
-  if (Array.isArray(this.records)) return;
-  this.version = 0;
+  let self = /** @type {NameTableValue} */ (this);
+  if (Array.isArray(self.records)) return;
+  self.version = 0;
 
+  /** @type {NameRecordValue[]} */
   let records = [];
-  for (let key in this.records) {
-    let val = this.records[key];
+  /** @type {NameRecordsMap} */
+  let map = self.records;
+  for (let key of Object.keys(map)) {
+    let val = map[key];
 
     if (key === 'fontFeatures') {
       // Mirrors of IDs < 256 are encoded via named/reserved keys above.
-      for (let id in val) {
-        if (+id >= 256) pushEnRecord(records, +id, val[id].en);
+      let features = /** @type {Record<number, LangStringMap>} */ (val);
+      for (let id of Object.keys(features)) {
+        if (+id >= 256) {
+          let langs = features[+id];
+          pushEnRecord(records, +id, langs && langs.en);
+        }
       }
       continue;
     }
 
     if (key === 'reservedNameID') {
-      for (let id in val) pushEnRecord(records, +id, val[id].en);
+      let reserved = /** @type {Record<number, LangStringMap>} */ (val);
+      for (let id of Object.keys(reserved)) {
+        let langs = reserved[+id];
+        pushEnRecord(records, +id, langs && langs.en);
+      }
       continue;
     }
 
     let nameID = NAMES.indexOf(key);
     if (nameID < 0) continue;
 
-    pushEnRecord(records, nameID, val.en);
+    let langs = /** @type {LangStringMap} */ (val);
+    pushEnRecord(records, nameID, langs.en);
 
     // Match historical behaviour: also write PostScript name for Mac platform.
-    if (key === 'postscriptName' && typeof val.en === 'string') {
+    if (key === 'postscriptName' && typeof langs.en === 'string') {
       records.push({
         platformID: 1,
         encodingID: 0,
         languageID: 0,
         nameID,
-        length: val.en.length,
-        string: val.en
+        length: langs.en.length,
+        string: langs.en
       });
     }
   }
 
-  this.records = records;
-  this.count = records.length;
-  this.stringOffset = NameTable.size(this, null, false);
+  self.records = records;
+  self.count = records.length;
+  self.stringOffset = NameTable.size(self, null, false);
 };

package/src/tables/opbd.js

@@ -8,8 +8,9 @@ let OpticalBounds = new r.Struct({
   bottom: r.int16
 });
 
+/** @type {import('restructure').Struct} */
 export default new r.Struct({
   version: r.fixed32,
   format: r.uint16,
-  lookupTable: new LookupTable(OpticalBounds)
+  lookupTable: LookupTable(OpticalBounds)
 });

package/src/tables/opentype.js

@@ -1,5 +1,8 @@
 import * as r from 'restructure';
 
+/** @typedef {import('restructure').BaseType} BaseType */
+/** @typedef {import('restructure').StructValue} StructValue */
+
 // ########################
 // Scripts and Languages #
 // ########################
@@ -27,6 +30,7 @@ let ScriptRecord = new r.Struct({
   script: new r.Pointer(r.uint16, Script, { type: 'parent' })
 });
 
+/** @type {import('restructure').ArrayT} */
 export let ScriptList = new r.Array(ScriptRecord, r.uint16);
 
 // #######################
@@ -38,6 +42,7 @@ let FeatureParams = new r.Struct({
   nameID: r.uint16 // OT spec: UI Name ID or uiLabelNameId
 });
 
+/** @type {import('restructure').Struct} */
 export let Feature = new r.Struct({
   featureParams: new r.Pointer(r.uint16, FeatureParams),
   lookupCount: r.uint16,
@@ -49,6 +54,7 @@ let FeatureRecord = new r.Struct({
   feature: new r.Pointer(r.uint16, Feature, { type: 'parent' })
 });
 
+/** @type {import('restructure').ArrayT} */
 export let FeatureList = new r.Array(FeatureRecord, r.uint16);
 
 let LookupFlags = new r.Struct({
@@ -59,13 +65,25 @@ let LookupFlags = new r.Struct({
   ])
 });
 
+/**
+ * @param {BaseType} SubTable
+ * @returns {import('restructure').LazyArray}
+ */
 export function LookupList(SubTable) {
   let Lookup = new r.Struct({
     lookupType: r.uint16,
     flags: LookupFlags,
     subTableCount: r.uint16,
     subTables: new r.Array(new r.Pointer(r.uint16, SubTable), 'subTableCount'),
-    markFilteringSet: new r.Optional(r.uint16, t => t.flags.flags.useMarkFilteringSet)
+    markFilteringSet: new r.Optional(
+      r.uint16,
+      /** @param {StructValue} t @returns {boolean} */
+      (t) => {
+        let flags = /** @type {StructValue} */ (t.flags);
+        let bits = /** @type {Record<string, boolean>} */ (flags.flags);
+        return !!bits.useMarkFilteringSet;
+      }
+    )
   });
 
   return new r.LazyArray(new r.Pointer(r.uint16, Lookup), r.uint16);
@@ -81,6 +99,7 @@ let RangeRecord = new r.Struct({
   startCoverageIndex: r.uint16
 });
 
+/** @type {import('restructure').VersionedStruct} */
 export let Coverage = new r.VersionedStruct(r.uint16, {
   1: {
     glyphCount: r.uint16,
@@ -102,6 +121,7 @@ let ClassRangeRecord = new r.Struct({
   class: r.uint16
 });
 
+/** @type {import('restructure').VersionedStruct} */
 export let ClassDef = new r.VersionedStruct(r.uint16, {
   1: { // Class array
     startGlyph: r.uint16,
@@ -118,6 +138,7 @@ export let ClassDef = new r.VersionedStruct(r.uint16, {
 // Device Table #
 // ###############
 
+/** @type {import('restructure').Struct} */
 export let Device = new r.Struct({
   a: r.uint16, // startSize for hinting Device, outerIndex for VariationIndex
   b: r.uint16, // endSize for Device, innerIndex for VariationIndex
@@ -136,7 +157,11 @@ let LookupRecord = new r.Struct({
 let Rule = new r.Struct({
   glyphCount: r.uint16,
   lookupCount: r.uint16,
-  input: new r.Array(r.uint16, t => t.glyphCount - 1),
+  input: new r.Array(
+    r.uint16,
+    /** @param {StructValue} t @returns {number} */
+    t => /** @type {number} */ (t.glyphCount) - 1
+  ),
   lookupRecords: new r.Array(LookupRecord, 'lookupCount')
 });
 
@@ -145,12 +170,17 @@ let RuleSet = new r.Array(new r.Pointer(r.uint16, Rule), r.uint16);
 let ClassRule = new r.Struct({
   glyphCount: r.uint16,
   lookupCount: r.uint16,
-  classes: new r.Array(r.uint16, t => t.glyphCount - 1),
+  classes: new r.Array(
+    r.uint16,
+    /** @param {StructValue} t @returns {number} */
+    t => /** @type {number} */ (t.glyphCount) - 1
+  ),
   lookupRecords: new r.Array(LookupRecord, 'lookupCount')
 });
 
 let ClassSet = new r.Array(new r.Pointer(r.uint16, ClassRule), r.uint16);
 
+/** @type {import('restructure').VersionedStruct} */
 export let Context = new r.VersionedStruct(r.uint16, {
   1: { // Simple context
     coverage: new r.Pointer(r.uint16, Coverage),
@@ -179,7 +209,11 @@ let ChainRule = new r.Struct({
   backtrackGlyphCount: r.uint16,
   backtrack: new r.Array(r.uint16, 'backtrackGlyphCount'),
   inputGlyphCount: r.uint16,
-  input: new r.Array(r.uint16, t => t.inputGlyphCount - 1),
+  input: new r.Array(
+    r.uint16,
+    /** @param {StructValue} t @returns {number} */
+    t => /** @type {number} */ (t.inputGlyphCount) - 1
+  ),
   lookaheadGlyphCount: r.uint16,
   lookahead: new r.Array(r.uint16, 'lookaheadGlyphCount'),
   lookupCount: r.uint16,
@@ -188,6 +222,7 @@ let ChainRule = new r.Struct({
 
 let ChainRuleSet = new r.Array(new r.Pointer(r.uint16, ChainRule), r.uint16);
 
+/** @type {import('restructure').VersionedStruct} */
 export let ChainingContext = new r.VersionedStruct(r.uint16, {
   1: { // Simple context glyph substitution
     coverage: new r.Pointer(r.uint16, Coverage),

package/src/tables/post.js

@@ -1,6 +1,9 @@
 import * as r from 'restructure';
 
+/** @typedef {import('restructure').StructValue} StructValue */
+
 // PostScript information
+/** @type {import('restructure').VersionedStruct} */
 export default new r.VersionedStruct(r.fixed32, {
   header: { // these fields exist at the top of all versions
     italicAngle: r.fixed32, // Italic angle in counter-clockwise degrees from the vertical.
@@ -29,6 +32,10 @@ export default new r.VersionedStruct(r.fixed32, {
   3: {}, // version 3 has no additional fields
 
   4: {
-    map: new r.Array(r.uint32, t => t.parent.maxp.numGlyphs)
+    map: new r.Array(
+      r.uint32,
+      /** @param {StructValue} t @returns {number} */
+      t => /** @type {number} */ (/** @type {StructValue} */ (/** @type {StructValue} */ (t.parent).maxp).numGlyphs)
+    )
   }
 });

package/src/tables/prep.js

@@ -1,6 +1,7 @@
 import * as r from 'restructure';
 
 // Set of instructions executed whenever the point size or font transformation change
+/** @type {import('restructure').Struct} */
 export default new r.Struct({
   controlValueProgram: new r.Array(r.uint8)
 });

package/src/tables/sbix.js

@@ -1,14 +1,25 @@
 import * as r from 'restructure';
 
+/** @typedef {import('restructure').StructValue} StructValue */
+
 let ImageTable = new r.Struct({
   ppem: r.uint16,
   resolution: r.uint16,
-  imageOffsets: new r.Array(new r.Pointer(r.uint32, 'void'), t => t.parent.parent.maxp.numGlyphs + 1)
+  imageOffsets: new r.Array(
+    new r.Pointer(r.uint32, 'void'),
+    /** @param {StructValue} t @returns {number} */
+    (t) => {
+      let parent = /** @type {StructValue} */ (t.parent);
+      let grand = /** @type {StructValue} */ (parent.parent);
+      return /** @type {number} */ (/** @type {StructValue} */ (grand.maxp).numGlyphs) + 1;
+    }
+  )
 });
 
 // This is the Apple sbix table, used by the "Apple Color Emoji" font.
 // It includes several image tables with images for each bitmap glyph
 // of several different sizes.
+/** @type {import('restructure').Struct} */
 export default new r.Struct({
   version: r.uint16,
   flags: new r.Bitfield(r.uint16, ['renderOutlines']),

package/src/tables/variations.js

@@ -1,6 +1,8 @@
 import { Feature } from './opentype';
 import * as r from 'restructure';
 
+/** @typedef {import('restructure').StructValue} StructValue */
+
 /** *****************
  * Variation Store *
  *******************/
@@ -19,9 +21,25 @@ let VariationRegionList = new r.Struct({
 });
 
 let DeltaSet = new r.Struct({
-  shortDeltas: new r.Array(r.int16, t => t.parent.shortDeltaCount),
-  regionDeltas: new r.Array(r.int8, t => t.parent.regionIndexCount - t.parent.shortDeltaCount),
-  deltas: t => t.shortDeltas.concat(t.regionDeltas)
+  shortDeltas: new r.Array(
+    r.int16,
+    /** @param {StructValue} t @returns {number} */
+    t => /** @type {number} */ (/** @type {StructValue} */ (t.parent).shortDeltaCount)
+  ),
+  regionDeltas: new r.Array(
+    r.int8,
+    /** @param {StructValue} t @returns {number} */
+    (t) => {
+      let parent = /** @type {StructValue} */ (t.parent);
+      return /** @type {number} */ (parent.regionIndexCount)
+        - /** @type {number} */ (parent.shortDeltaCount);
+    }
+  ),
+  /**
+   * @param {StructValue} t
+   * @returns {number[]}
+   */
+  deltas: t => /** @type {number[]} */ (t.shortDeltas).concat(/** @type {number[]} */ (t.regionDeltas))
 });
 
 let ItemVariationData = new r.Struct({
@@ -32,6 +50,7 @@ let ItemVariationData = new r.Struct({
   deltaSets: new r.Array(DeltaSet, 'itemCount')
 });
 
+/** @type {import('restructure').Struct} */
 export let ItemVariationStore = new r.Struct({
   format: r.uint16,
   variationRegionList: new r.Pointer(r.uint32, VariationRegionList),
@@ -72,6 +91,7 @@ let FeatureVariationRecord = new r.Struct({
   featureTableSubstitution: new r.Pointer(r.uint32, FeatureTableSubstitution, { type: 'parent' })
 });
 
+/** @type {import('restructure').Struct} */
 export let FeatureVariations = new r.Struct({
   majorVersion: r.uint16,
   minorVersion: r.uint16,

package/src/tables/vhea.js

@@ -1,6 +1,7 @@
 import * as r from 'restructure';
 
 // Vertical Header Table
+/** @type {import('restructure').Struct} */
 export default new r.Struct({
   version: r.fixed32, // Version number of the Vertical Header Table
   ascent: r.int16, // The vertical typographic ascender for this font

package/src/tables/vmtx.js

@@ -1,12 +1,28 @@
 import * as r from 'restructure';
 
+/** @typedef {import('restructure').StructValue} StructValue */
+
 let VmtxEntry = new r.Struct({
   advance: r.uint16, // The advance height of the glyph
   bearing: r.int16 // The top sidebearing of the glyph
 });
 
 // Vertical Metrics Table
+/** @type {import('restructure').Struct} */
 export default new r.Struct({
-  metrics: new r.LazyArray(VmtxEntry, t => t.parent.vhea.numberOfMetrics),
-  bearings: new r.LazyArray(r.int16, t => t.parent.maxp.numGlyphs - t.parent.vhea.numberOfMetrics)
+  metrics: new r.LazyArray(
+    VmtxEntry,
+    /** @param {StructValue} t @returns {number} */
+    t => /** @type {number} */ (/** @type {StructValue} */ (/** @type {StructValue} */ (t.parent).vhea).numberOfMetrics)
+  ),
+  bearings: new r.LazyArray(
+    r.int16,
+    /** @param {StructValue} t @returns {number} */
+    (t) => {
+      let parent = /** @type {StructValue} */ (t.parent);
+      let maxp = /** @type {StructValue} */ (parent.maxp);
+      let vhea = /** @type {StructValue} */ (parent.vhea);
+      return /** @type {number} */ (maxp.numGlyphs) - /** @type {number} */ (vhea.numberOfMetrics);
+    }
+  )
 });

package/src/utils.js

@@ -1,3 +1,9 @@
+/**
+ * @template T
+ * @param {T[]} arr
+ * @param {(item: T) => number} cmp
+ * @returns {number}
+ */
 export function binarySearch(arr, cmp) {
   let min = 0;
   let max = arr.length - 1;
@@ -17,6 +23,11 @@ export function binarySearch(arr, cmp) {
   return -1;
 }
 
+/**
+ * @param {number} index
+ * @param {number} end
+ * @returns {number[]}
+ */
 export function range(index, end) {
   let range = [];
   while (index < end) {
@@ -34,6 +45,10 @@ for (let i = 0; i < CHARS.length; i++) {
   LOOKUP[CHARS.charCodeAt(i)] = i;
 }
 
+/**
+ * @param {string} base64
+ * @returns {Uint8Array}
+ */
 export function decodeBase64(base64) {
   let bufferLength = base64.length * 0.75;
 

package/types/assets.d.ts

@@ -0,0 +1,13 @@
+/**
+ * `.trie` assets are loaded as base64 strings (see tsup `loader: { '.trie': 'base64' }`
+ * and vitest `trie-base64` plugin), then passed to `decodeBase64`.
+ */
+declare module '*.trie' {
+  const data: string;
+  export default data;
+}
+
+declare module '*.json' {
+  const value: unknown;
+  export default value;
+}

package/types/deps.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Minimal Node Buffer surface used by unicode-trie / unicode-properties.
+ * Avoids pulling the full `@types/node` lib into checkJs.
+ */
+interface Buffer extends Uint8Array {
+  readUInt32LE(offset?: number): number;
+  readUInt32BE(offset?: number): number;
+  writeUInt32LE(value: number, offset?: number): number;
+  writeUInt32BE(value: number, offset?: number): number;
+  slice(start?: number, end?: number): Buffer;
+}
+
+declare const Buffer: {
+  alloc(size: number, fill?: string | number | Uint8Array, encoding?: string): Buffer;
+  from(arrayBuffer: ArrayBufferLike, byteOffset?: number, length?: number): Buffer;
+  from(data: Uint8Array | readonly number[]): Buffer;
+  from(str: string, encoding?: string): Buffer;
+  isBuffer(obj: unknown): obj is Buffer;
+};
+
+declare module 'brotli/decompress.js' {
+  /**
+   * Decompress a brotli-compressed buffer.
+   * @param buffer Compressed input
+   * @param outputSize Expected decompressed size
+   */
+  export default function decompress(buffer: Uint8Array, outputSize?: number): Uint8Array | null;
+}
+
+declare module 'clone' {
+  /**
+   * Deep-clone a value.
+   */
+  export default function cloneDeep<T>(value: T): T;
+}
+
+declare module 'dfa' {
+  /**
+   * Compiled DFA payload (from `dfa/compile`). Matches runtime `node_modules/dfa`:
+   * `{ stateTable, accepting, tags }` — not a named `{ start, states }` graph.
+   *
+   * Callers may pass a wider object that also carries app data (e.g. USE
+   * `categories` / `decompositions`); only these three fields are read.
+   */
+  export interface StateMachineDefinition {
+    stateTable: number[][];
+    accepting: boolean[];
+    tags: string[][];
+  }
+
+  /** Match yield: `[startIndex, endIndex, tags]` (inclusive end). */
+  export type StateMachineMatch = [start: number, end: number, tags: string[]];
+
+  export default class StateMachine {
+    stateTable: number[][];
+    accepting: boolean[];
+    tags: string[][];
+    constructor(definition: StateMachineDefinition);
+    /**
+     * Iterable matches over an indexed sequence (`length` + numeric index).
+     * Strings and number arrays both work at runtime.
+     * Indic/USE pass numeric category arrays; other callers may pass strings.
+     */
+    match(input: ArrayLike<string | number>): Iterable<StateMachineMatch>;
+    apply(
+      input: ArrayLike<string | number>,
+      actions: Record<
+        string,
+        (start: number, end: number, slice: ArrayLike<string | number>) => void
+      >
+    ): void;
+  }
+}
+
+declare module 'fast-deep-equal' {
+  export default function equal(a: unknown, b: unknown): boolean;
+}
+
+declare module 'fflate' {
+  export function inflateSync(data: Uint8Array, opts?: { out?: Uint8Array }): Uint8Array;
+  export function unzlibSync(data: Uint8Array, opts?: { out?: Uint8Array }): Uint8Array;
+  export function deflateSync(data: Uint8Array, opts?: { level?: number }): Uint8Array;
+}