@cantoo/fontkit 2.0.5 → 2.0.7

package/src/aat/AATLookupTable.js

@@ -1,15 +1,27 @@
 import { cache } from '../decorators';
 import { range } from '../utils';
 
+/** @typedef {import('../../types/fontkit').AATLookupTableData} AATLookupTableData */
+/** @typedef {import('../../types/fontkit').AATUnboundedArray<number>} AATNumberArray */
+/** @typedef {import('../../types/fontkit').AATLookupSegmentSingle} AATLookupSegmentSingle */
+
 export default class AATLookupTable {
+  /**
+   * @param {AATLookupTableData} table
+   */
   constructor(table) {
+    /** @type {AATLookupTableData} */
     this.table = table;
   }
 
+  /**
+   * @param {number} glyph
+   * @returns {number | null | undefined}
+   */
   lookup(glyph) {
     switch (this.table.version) {
       case 0: // simple array format
-        return this.table.values.getItem(glyph);
+        return /** @type {AATNumberArray} */ (this.table.values).getItem(glyph);
 
       case 2: // segment format
       case 4: {
@@ -67,15 +79,20 @@ export default class AATLookupTable {
       }
 
       case 8: // lookup trimmed
-        return this.table.values[glyph - this.table.firstGlyph];
+        return /** @type {number[]} */ (this.table.values)[glyph - this.table.firstGlyph];
 
       default:
         throw new Error(`Unknown lookup table format: ${this.table.version}`);
     }
   }
 
+  /**
+   * @param {number} classValue
+   * @returns {number[]}
+   */
   @cache
   glyphsForValue(classValue) {
+    /** @type {number[]} */
     let res = [];
 
     switch (this.table.version) {
@@ -107,8 +124,9 @@ export default class AATLookupTable {
       }
 
       case 8: { // lookup trimmed
-        for (let i = 0; i < this.table.values.length; i++) {
-          if (this.table.values[i] === classValue) {
+        let values = /** @type {number[]} */ (this.table.values);
+        for (let i = 0; i < values.length; i++) {
+          if (values[i] === classValue) {
             res.push(this.table.firstGlyph + i);
           }
         }

package/src/aat/AATMorxProcessor.js

@@ -2,6 +2,14 @@ import AATStateMachine from './AATStateMachine';
 import AATLookupTable from './AATLookupTable';
 import { cache } from '../decorators';
 
+/** @typedef {import('../../types/fontkit').LayoutFont} LayoutFont */
+/** @typedef {import('../../types/fontkit').LayoutGlyph} LayoutGlyph */
+/** @typedef {import('../../types/fontkit').MorxTable} MorxTable */
+/** @typedef {import('../../types/fontkit').MorxSubtable} MorxSubtable */
+/** @typedef {import('../../types/fontkit').AATStateEntry} AATStateEntry */
+/** @typedef {import('../../types/fontkit').AATFeatureSettings} AATFeatureSettings */
+/** @typedef {import('../../types/fontkit').FeatureValue} FeatureValue */
+
 // indic replacement flags
 const MARK_FIRST = 0x8000;
 const MARK_LAST = 0x2000;
@@ -31,20 +39,49 @@ const MARKED_INSERT_BEFORE = 0x0400;
 const CURRENT_INSERT_COUNT = 0x03E0;
 const MARKED_INSERT_COUNT = 0x001F;
 
+/**
+ * @typedef {[number, number]} GlyphRange
+ */
+
 export default class AATMorxProcessor {
+  /**
+   * @param {LayoutFont} font
+   */
   constructor(font) {
     this.processIndicRearragement = this.processIndicRearragement.bind(this);
     this.processContextualSubstitution = this.processContextualSubstitution.bind(this);
     this.processLigature = this.processLigature.bind(this);
     this.processNoncontextualSubstitutions = this.processNoncontextualSubstitutions.bind(this);
     this.processGlyphInsertion = this.processGlyphInsertion.bind(this);
+    /** @type {LayoutFont} */
     this.font = font;
-    this.morx = font.morx;
+    /** @type {MorxTable} */
+    this.morx = /** @type {MorxTable} */ (font.morx);
+    /** @type {Record<number, number[][]> | null} */
     this.inputCache = null;
+    /** @type {MorxSubtable | undefined} */
+    this.subtable = undefined;
+    /** @type {LayoutGlyph[]} */
+    this.glyphs = [];
+    /** @type {number[]} */
+    this.ligatureStack = [];
+    /** @type {number | null} */
+    this.markedGlyph = null;
+    /** @type {number | null} */
+    this.firstGlyph = null;
+    /** @type {number | null} */
+    this.lastGlyph = null;
+    /** @type {number | null} */
+    this.markedIndex = null;
   }
 
-  // Processes an array of glyphs and applies the specified features
-  // Features should be in the form of {featureType:{featureSetting:boolean}}
+  /**
+   * Processes an array of glyphs and applies the specified features.
+   * Features should be in the form of {featureType:{featureSetting:boolean}}
+   * @param {LayoutGlyph[]} glyphs
+   * @param {AATFeatureSettings | Record<number, Record<number, FeatureValue>>} [features]
+   * @returns {LayoutGlyph[]}
+   */
   process(glyphs, features = {}) {
     for (let chain of this.morx.chains) {
       let flags = chain.defaultFlags;
@@ -83,6 +120,11 @@ export default class AATMorxProcessor {
     return glyphs;
   }
 
+  /**
+   * @param {MorxSubtable} subtable
+   * @param {LayoutGlyph[]} glyphs
+   * @returns {LayoutGlyph[] | void}
+   */
   processSubtable(subtable, glyphs) {
     this.subtable = subtable;
     this.glyphs = glyphs;
@@ -104,28 +146,38 @@ export default class AATMorxProcessor {
     return stateMachine.process(this.glyphs, reverse, process);
   }
 
+  /**
+   * @param {MorxSubtable} subtable
+   * @returns {AATStateMachine}
+   */
   @cache
   getStateMachine(subtable) {
-    return new AATStateMachine(subtable.table.stateTable);
+    return new AATStateMachine(/** @type {import('../../types/fontkit').AATStateTable} */ (subtable.table.stateTable));
   }
 
+  /**
+   * @returns {(glyph: LayoutGlyph | null, entry: AATStateEntry, index: number) => void}
+   */
   getProcessor() {
-    switch (this.subtable.type) {
+    switch (/** @type {MorxSubtable} */ (this.subtable).type) {
       case 0:
         return this.processIndicRearragement;
       case 1:
         return this.processContextualSubstitution;
       case 2:
         return this.processLigature;
-      case 4:
-        return this.processNoncontextualSubstitutions;
       case 5:
         return this.processGlyphInsertion;
       default:
-        throw new Error(`Invalid morx subtable type: ${this.subtable.type}`);
+        throw new Error(`Invalid morx subtable type: ${/** @type {MorxSubtable} */ (this.subtable).type}`);
     }
   }
 
+  /**
+   * @param {LayoutGlyph | null} glyph
+   * @param {AATStateEntry} entry
+   * @param {number} index
+   */
   processIndicRearragement(glyph, entry, index) {
     if (entry.flags & MARK_FIRST) {
       this.firstGlyph = index;
@@ -138,25 +190,37 @@ export default class AATMorxProcessor {
     reorderGlyphs(this.glyphs, entry.flags & VERB, this.firstGlyph, this.lastGlyph);
   }
 
+  /**
+   * @param {LayoutGlyph | null} glyph
+   * @param {AATStateEntry} entry
+   * @param {number} index
+   */
   processContextualSubstitution(glyph, entry, index) {
-    let subsitutions = this.subtable.table.substitutionTable.items;
+    let subtable = /** @type {MorxSubtable} */ (this.subtable);
+    let subsitutions = subtable.table.substitutionTable.items;
     if (entry.markIndex !== 0xffff) {
-      let lookup = subsitutions.getItem(entry.markIndex);
+      let lookup = subsitutions.getItem(/** @type {number} */ (entry.markIndex));
       let lookupTable = new AATLookupTable(lookup);
-      glyph = this.glyphs[this.markedGlyph];
+      glyph = this.glyphs[/** @type {number} */ (this.markedGlyph)];
       let gid = lookupTable.lookup(glyph.id);
       if (gid) {
-        this.glyphs[this.markedGlyph] = this.font.getGlyph(gid, glyph.codePoints);
+        let substituted = this.font.getGlyph(gid, glyph.codePoints);
+        if (substituted) {
+          this.glyphs[/** @type {number} */ (this.markedGlyph)] = substituted;
+        }
       }
     }
 
     if (entry.currentIndex !== 0xffff) {
-      let lookup = subsitutions.getItem(entry.currentIndex);
+      let lookup = subsitutions.getItem(/** @type {number} */ (entry.currentIndex));
       let lookupTable = new AATLookupTable(lookup);
       glyph = this.glyphs[index];
       let gid = lookupTable.lookup(glyph.id);
       if (gid) {
-        this.glyphs[index] = this.font.getGlyph(gid, glyph.codePoints);
+        let substituted = this.font.getGlyph(gid, glyph.codePoints);
+        if (substituted) {
+          this.glyphs[index] = substituted;
+        }
       }
     }
 
@@ -165,43 +229,57 @@ export default class AATMorxProcessor {
     }
   }
 
+  /**
+   * @param {LayoutGlyph | null} glyph
+   * @param {AATStateEntry} entry
+   * @param {number} index
+   */
   processLigature(glyph, entry, index) {
     if (entry.flags & SET_COMPONENT) {
       this.ligatureStack.push(index);
     }
 
     if (entry.flags & PERFORM_ACTION) {
-      let actions = this.subtable.table.ligatureActions;
-      let components = this.subtable.table.components;
-      let ligatureList = this.subtable.table.ligatureList;
+      let subtable = /** @type {MorxSubtable} */ (this.subtable);
+      let actions = subtable.table.ligatureActions;
+      let components = subtable.table.components;
+      let ligatureList = subtable.table.ligatureList;
 
-      let actionIndex = entry.action;
+      let actionIndex = /** @type {number} */ (entry.action);
       let last = false;
       let ligatureIndex = 0;
+      /** @type {number[]} */
       let codePoints = [];
+      /** @type {number[]} */
       let ligatureGlyphs = [];
 
       while (!last) {
         let componentGlyph = this.ligatureStack.pop();
-        codePoints.unshift(...this.glyphs[componentGlyph].codePoints);
+        codePoints.unshift(...this.glyphs[/** @type {number} */ (componentGlyph)].codePoints);
 
         let action = actions.getItem(actionIndex++);
         last = !!(action & LAST_MASK);
         let store = !!(action & STORE_MASK);
         let offset = (action & OFFSET_MASK) << 2 >> 2; // sign extend 30 to 32 bits
-        offset += this.glyphs[componentGlyph].id;
+        offset += this.glyphs[/** @type {number} */ (componentGlyph)].id;
 
         let component = components.getItem(offset);
         ligatureIndex += component;
 
         if (last || store) {
           let ligatureEntry = ligatureList.getItem(ligatureIndex);
-          this.glyphs[componentGlyph] = this.font.getGlyph(ligatureEntry, codePoints);
-          ligatureGlyphs.push(componentGlyph);
+          let ligature = this.font.getGlyph(ligatureEntry, codePoints);
+          if (ligature) {
+            this.glyphs[/** @type {number} */ (componentGlyph)] = ligature;
+          }
+          ligatureGlyphs.push(/** @type {number} */ (componentGlyph));
           ligatureIndex = 0;
           codePoints = [];
         } else {
-          this.glyphs[componentGlyph] = this.font.getGlyph(0xffff);
+          let deleted = this.font.getGlyph(0xffff);
+          if (deleted) {
+            this.glyphs[/** @type {number} */ (componentGlyph)] = deleted;
+          }
         }
       }
 
@@ -210,25 +288,44 @@ export default class AATMorxProcessor {
     }
   }
 
+  /**
+   * @param {MorxSubtable} subtable
+   * @param {LayoutGlyph[]} glyphs
+   * @param {number} [index]
+   */
   processNoncontextualSubstitutions(subtable, glyphs, index) {
-    let lookupTable = new AATLookupTable(subtable.table.lookupTable);
+    let lookupTable = new AATLookupTable(/** @type {import('../../types/fontkit').AATLookupTableData} */ (subtable.table.lookupTable));
 
     for (index = 0; index < glyphs.length; index++) {
       let glyph = glyphs[index];
       if (glyph.id !== 0xffff) {
         let gid = lookupTable.lookup(glyph.id);
         if (gid) { // 0 means do nothing
-          glyphs[index] = this.font.getGlyph(gid, glyph.codePoints);
+          let substituted = this.font.getGlyph(gid, glyph.codePoints);
+          if (substituted) {
+            glyphs[index] = substituted;
+          }
         }
       }
     }
   }
 
+  /**
+   * @param {number} glyphIndex
+   * @param {number} insertionActionIndex
+   * @param {number} count
+   * @param {boolean} isBefore
+   */
   _insertGlyphs(glyphIndex, insertionActionIndex, count, isBefore) {
+    /** @type {LayoutGlyph[]} */
     let insertions = [];
+    let subtable = /** @type {MorxSubtable} */ (this.subtable);
     while (count--) {
-      let gid = this.subtable.table.insertionActions.getItem(insertionActionIndex++);
-      insertions.push(this.font.getGlyph(gid));
+      let gid = subtable.table.insertionActions.getItem(insertionActionIndex++);
+      let inserted = this.font.getGlyph(gid);
+      if (inserted) {
+        insertions.push(inserted);
+      }
     }
 
     if (!isBefore) {
@@ -238,6 +335,11 @@ export default class AATMorxProcessor {
     this.glyphs.splice(glyphIndex, 0, ...insertions);
   }
 
+  /**
+   * @param {LayoutGlyph | null} glyph
+   * @param {AATStateEntry} entry
+   * @param {number} index
+   */
   processGlyphInsertion(glyph, entry, index) {
     if (entry.flags & SET_MARK) {
       this.markedIndex = index;
@@ -246,17 +348,21 @@ export default class AATMorxProcessor {
     if (entry.markedInsertIndex !== 0xffff) {
       let count = (entry.flags & MARKED_INSERT_COUNT) >>> 5;
       let isBefore = !!(entry.flags & MARKED_INSERT_BEFORE);
-      this._insertGlyphs(this.markedIndex, entry.markedInsertIndex, count, isBefore);
+      this._insertGlyphs(/** @type {number} */ (this.markedIndex), /** @type {number} */ (entry.markedInsertIndex), count, isBefore);
     }
 
     if (entry.currentInsertIndex !== 0xffff) {
       let count = (entry.flags & CURRENT_INSERT_COUNT) >>> 5;
       let isBefore = !!(entry.flags & CURRENT_INSERT_BEFORE);
-      this._insertGlyphs(index, entry.currentInsertIndex, count, isBefore);
+      this._insertGlyphs(index, /** @type {number} */ (entry.currentInsertIndex), count, isBefore);
     }
   }
 
+  /**
+   * @returns {Array<[number, number]>}
+   */
   getSupportedFeatures() {
+    /** @type {Array<[number, number]>} */
     let features = [];
     for (let chain of this.morx.chains) {
       for (let feature of chain.features) {
@@ -267,12 +373,16 @@ export default class AATMorxProcessor {
     return features;
   }
 
+  /**
+   * @param {number} gid
+   * @returns {number[][]}
+   */
   generateInputs(gid) {
     if (!this.inputCache) {
       this.generateInputCache();
     }
 
-    return this.inputCache[gid] || [];
+    return /** @type {Record<number, number[][]>} */ (this.inputCache)[gid] || [];
   }
 
   generateInputCache() {
@@ -289,6 +399,9 @@ export default class AATMorxProcessor {
     }
   }
 
+  /**
+   * @param {MorxSubtable} subtable
+   */
   generateInputsForSubtable(subtable) {
     // Currently, only supporting ligature subtables.
     if (subtable.type !== 2) {
@@ -306,7 +419,9 @@ export default class AATMorxProcessor {
     let stateMachine = this.getStateMachine(subtable);
     let process = this.getProcessor();
 
+    /** @type {LayoutGlyph[]} */
     let input = [];
+    /** @type {Array<{ glyphs: LayoutGlyph[], ligatureStack: number[] }>} */
     let stack = [];
     this.glyphs = [];
 
@@ -320,8 +435,11 @@ export default class AATMorxProcessor {
 
         // Add glyph to input and glyphs to process.
         let g = this.font.getGlyph(glyph);
+        if (!g) {
+          return;
+        }
         input.push(g);
-        glyphs.push(input[input.length - 1]);
+        glyphs.push(g);
 
         // Process ligature substitution
         process(glyphs[glyphs.length - 1], entry, glyphs.length - 1);
@@ -338,26 +456,35 @@ export default class AATMorxProcessor {
 
         if (count === 1) {
           let result = input.map(g => g.id);
-          let cache = this.inputCache[found];
+          let cacheMap = /** @type {Record<number, number[][]>} */ (this.inputCache);
+          let cache = cacheMap[found];
           if (cache) {
             cache.push(result);
           } else {
-            this.inputCache[found] = [result];
+            cacheMap[found] = [result];
           }
         }
       },
 
       exit: () => {
-        ({ glyphs: this.glyphs, ligatureStack: this.ligatureStack } = stack.pop());
+        ({ glyphs: this.glyphs, ligatureStack: this.ligatureStack } = /** @type {{ glyphs: LayoutGlyph[], ligatureStack: number[] }} */ (stack.pop()));
         input.pop();
       }
     });
   }
 }
 
-// swaps the glyphs in rangeA with those in rangeB
-// reverse the glyphs inside those ranges if specified
-// ranges are in [offset, length] format
+/**
+ * swaps the glyphs in rangeA with those in rangeB
+ * reverse the glyphs inside those ranges if specified
+ * ranges are in [offset, length] format
+ * @param {LayoutGlyph[]} glyphs
+ * @param {GlyphRange} rangeA
+ * @param {GlyphRange} rangeB
+ * @param {boolean} [reverseA]
+ * @param {boolean} [reverseB]
+ * @returns {LayoutGlyph[]}
+ */
 function swap(glyphs, rangeA, rangeB, reverseA = false, reverseB = false) {
   let end = glyphs.splice(rangeB[0] - (rangeB[1] - 1), rangeB[1]);
   if (reverseB) {
@@ -373,55 +500,65 @@ function swap(glyphs, rangeA, rangeB, reverseA = false, reverseB = false) {
   return glyphs;
 }
 
+/**
+ * @param {LayoutGlyph[]} glyphs
+ * @param {number} verb
+ * @param {number | null} firstGlyph
+ * @param {number | null} lastGlyph
+ * @returns {LayoutGlyph[]}
+ */
 function reorderGlyphs(glyphs, verb, firstGlyph, lastGlyph) {
+  let first = /** @type {number} */ (firstGlyph);
+  let last = /** @type {number} */ (lastGlyph);
+
   switch (verb) {
     case 0: // no change
       return glyphs;
 
     case 1: // Ax => xA
-      return swap(glyphs, [firstGlyph, 1], [lastGlyph, 0]);
+      return swap(glyphs, [first, 1], [last, 0]);
 
     case 2: // xD => Dx
-      return swap(glyphs, [firstGlyph, 0], [lastGlyph, 1]);
+      return swap(glyphs, [first, 0], [last, 1]);
 
     case 3: // AxD => DxA
-      return swap(glyphs, [firstGlyph, 1], [lastGlyph, 1]);
+      return swap(glyphs, [first, 1], [last, 1]);
 
     case 4: // ABx => xAB
-      return swap(glyphs, [firstGlyph, 2], [lastGlyph, 0]);
+      return swap(glyphs, [first, 2], [last, 0]);
 
     case 5: // ABx => xBA
-      return swap(glyphs, [firstGlyph, 2], [lastGlyph, 0], true, false);
+      return swap(glyphs, [first, 2], [last, 0], true, false);
 
     case 6: // xCD => CDx
-      return swap(glyphs, [firstGlyph, 0], [lastGlyph, 2]);
+      return swap(glyphs, [first, 0], [last, 2]);
 
     case 7: // xCD => DCx
-      return swap(glyphs, [firstGlyph, 0], [lastGlyph, 2], false, true);
+      return swap(glyphs, [first, 0], [last, 2], false, true);
 
     case 8: // AxCD => CDxA
-      return swap(glyphs, [firstGlyph, 1], [lastGlyph, 2]);
+      return swap(glyphs, [first, 1], [last, 2]);
 
     case 9: // AxCD => DCxA
-      return swap(glyphs, [firstGlyph, 1], [lastGlyph, 2], false, true);
+      return swap(glyphs, [first, 1], [last, 2], false, true);
 
     case 10: // ABxD => DxAB
-      return swap(glyphs, [firstGlyph, 2], [lastGlyph, 1]);
+      return swap(glyphs, [first, 2], [last, 1]);
 
     case 11: // ABxD => DxBA
-      return swap(glyphs, [firstGlyph, 2], [lastGlyph, 1], true, false);
+      return swap(glyphs, [first, 2], [last, 1], true, false);
 
     case 12: // ABxCD => CDxAB
-      return swap(glyphs, [firstGlyph, 2], [lastGlyph, 2]);
+      return swap(glyphs, [first, 2], [last, 2]);
 
     case 13: // ABxCD => CDxBA
-      return swap(glyphs, [firstGlyph, 2], [lastGlyph, 2], true, false);
+      return swap(glyphs, [first, 2], [last, 2], true, false);
 
     case 14: // ABxCD => DCxAB
-      return swap(glyphs, [firstGlyph, 2], [lastGlyph, 2], false, true);
+      return swap(glyphs, [first, 2], [last, 2], false, true);
 
     case 15: // ABxCD => DCxBA
-      return swap(glyphs, [firstGlyph, 2], [lastGlyph, 2], true, true);
+      return swap(glyphs, [first, 2], [last, 2], true, true);
 
     default:
       throw new Error(`Unknown verb: ${verb}`);

package/src/aat/AATStateMachine.js

@@ -1,5 +1,9 @@
 import AATLookupTable from './AATLookupTable';
 
+/** @typedef {import('../../types/fontkit').AATStateTable} AATStateTable */
+/** @typedef {import('../../types/fontkit').AATStateEntry} AATStateEntry */
+/** @typedef {import('../../types/fontkit').LayoutGlyph} LayoutGlyph */
+
 const START_OF_TEXT_STATE = 0;
 const _START_OF_LINE_STATE = 1;
 
@@ -10,18 +14,43 @@ const _END_OF_LINE_CLASS = 3;
 
 const DONT_ADVANCE = 0x4000;
 
+/**
+ * @callback AATProcessEntry
+ * @param {LayoutGlyph | null} glyph
+ * @param {AATStateEntry} entry
+ * @param {number} index
+ */
+
+/**
+ * @typedef {object} AATTraverseOpts
+ * @property {(glyph: number, entry: AATStateEntry) => void} [enter]
+ * @property {(glyph: number, entry: AATStateEntry) => void} [exit]
+ */
+
 export default class AATStateMachine {
+  /**
+   * @param {AATStateTable} stateTable
+   */
   constructor(stateTable) {
+    /** @type {AATStateTable} */
     this.stateTable = stateTable;
+    /** @type {AATLookupTable} */
     this.lookupTable = new AATLookupTable(stateTable.classTable);
   }
 
+  /**
+   * @param {LayoutGlyph[]} glyphs
+   * @param {boolean} reverse
+   * @param {AATProcessEntry} processEntry
+   * @returns {LayoutGlyph[]}
+   */
   process(glyphs, reverse, processEntry) {
     let currentState = START_OF_TEXT_STATE; // START_OF_LINE_STATE is used for kashida glyph insertions sometimes I think?
     let index = reverse ? glyphs.length - 1 : 0;
     let dir = reverse ? -1 : 1;
 
     while ((dir === 1 && index <= glyphs.length) || (dir === -1 && index >= -1)) {
+      /** @type {LayoutGlyph | null} */
       let glyph = null;
       let classCode;
       let shouldAdvance = true;
@@ -61,6 +90,9 @@ export default class AATStateMachine {
   /**
    * Performs a depth-first traversal of the glyph strings
    * represented by the state machine.
+   * @param {AATTraverseOpts} opts
+   * @param {number} [state]
+   * @param {Set<number>} [visited]
    */
   traverse(opts, state = 0, visited = new Set()) {
     if (visited.has(state)) {

package/src/base.js

@@ -1,12 +1,26 @@
 import { DecodeStream } from 'restructure';
 
+/** @typedef {import('../types/fontkit').FontFormat} FontFormat */
+/** @typedef {import('../types/fontkit').OpenedFont} OpenedFont */
+
 export let logErrors = false;
 
+/** @type {FontFormat[]} */
 let formats = [];
+
+/**
+ * @param {FontFormat} format
+ * @returns {void}
+ */
 export function registerFormat(format) {
   formats.push(format);
 };
 
+/**
+ * @param {ArrayBufferView} buffer
+ * @param {string | Uint8Array} [postscriptName]
+ * @returns {OpenedFont | null | undefined}
+ */
 export function create(buffer, postscriptName) {
   for (let i = 0; i < formats.length; i++) {
     let format = formats[i];
@@ -24,6 +38,11 @@ export function create(buffer, postscriptName) {
 };
 
 export let defaultLanguage = 'en';
+
+/**
+ * @param {string} [lang]
+ * @returns {void}
+ */
 export function setDefaultLanguage(lang = 'en') {
   defaultLanguage = lang;
 };

package/src/cff/CFFCharsets.js

@@ -1,3 +1,4 @@
+/** @type {string[]} */
 export let ISOAdobeCharset = [
   '.notdef', 'space', 'exclam', 'quotedbl', 'numbersign', 'dollar',
   'percent', 'ampersand', 'quoteright', 'parenleft', 'parenright',
@@ -35,6 +36,7 @@ export let ISOAdobeCharset = [
   'ugrave', 'yacute', 'ydieresis', 'zcaron'
 ];
 
+/** @type {string[]} */
 export let ExpertCharset = [
   '.notdef', 'space', 'exclamsmall', 'Hungarumlautsmall', 'dollaroldstyle',
   'dollarsuperior', 'ampersandsmall', 'Acutesmall', 'parenleftsuperior',
@@ -75,6 +77,7 @@ export let ExpertCharset = [
   'Ydieresissmall'
 ];
 
+/** @type {string[]} */
 export let ExpertSubsetCharset = [
   '.notdef', 'space', 'dollaroldstyle', 'dollarsuperior',
   'parenleftsuperior', 'parenrightsuperior', 'twodotenleader',