@cantoo/fontkit 2.0.4 → 2.0.6

package/src/tables/GDEF.js

@@ -1,12 +1,12 @@
 import * as r from 'restructure';
-import {Coverage, ClassDef, Device} from './opentype';
-import {ItemVariationStore} from './variations';
+import { Coverage, ClassDef, Device } from './opentype';
+import { ItemVariationStore } from './variations';
 
 let AttachPoint = new r.Array(r.uint16, r.uint16);
 let AttachList = new r.Struct({
-  coverage:       new r.Pointer(r.uint16, Coverage),
-  glyphCount:     r.uint16,
-  attachPoints:   new r.Array(new r.Pointer(r.uint16, AttachPoint), 'glyphCount')
+  coverage: new r.Pointer(r.uint16, Coverage),
+  glyphCount: r.uint16,
+  attachPoints: new r.Array(new r.Pointer(r.uint16, AttachPoint), 'glyphCount')
 });
 
 let CaretValue = new r.VersionedStruct(r.uint16, {
@@ -19,39 +19,40 @@ let CaretValue = new r.VersionedStruct(r.uint16, {
   },
 
   3: { // Design units plus Device table
-    coordinate:     r.int16,
-    deviceTable:    new r.Pointer(r.uint16, Device)
+    coordinate: r.int16,
+    deviceTable: new r.Pointer(r.uint16, Device)
   }
 });
 
 let LigGlyph = new r.Array(new r.Pointer(r.uint16, CaretValue), r.uint16);
 
 let LigCaretList = new r.Struct({
-  coverage:       new r.Pointer(r.uint16, Coverage),
-  ligGlyphCount:  r.uint16,
-  ligGlyphs:      new r.Array(new r.Pointer(r.uint16, LigGlyph), 'ligGlyphCount')
+  coverage: new r.Pointer(r.uint16, Coverage),
+  ligGlyphCount: r.uint16,
+  ligGlyphs: new r.Array(new r.Pointer(r.uint16, LigGlyph), 'ligGlyphCount')
 });
 
 let MarkGlyphSetsDef = new r.Struct({
   markSetTableFormat: r.uint16,
-  markSetCount:       r.uint16,
-  coverage:           new r.Array(new r.Pointer(r.uint32, Coverage), 'markSetCount')
+  markSetCount: r.uint16,
+  coverage: new r.Array(new r.Pointer(r.uint32, Coverage), 'markSetCount')
 });
 
+/** @type {import('restructure').VersionedStruct} */
 export default new r.VersionedStruct(r.uint32, {
   header: {
-    glyphClassDef:      new r.Pointer(r.uint16, ClassDef),
-    attachList:         new r.Pointer(r.uint16, AttachList),
-    ligCaretList:       new r.Pointer(r.uint16, LigCaretList),
+    glyphClassDef: new r.Pointer(r.uint16, ClassDef),
+    attachList: new r.Pointer(r.uint16, AttachList),
+    ligCaretList: new r.Pointer(r.uint16, LigCaretList),
     markAttachClassDef: new r.Pointer(r.uint16, ClassDef)
   },
 
   0x00010000: {},
   0x00010002: {
-    markGlyphSetsDef:   new r.Pointer(r.uint16, MarkGlyphSetsDef)
+    markGlyphSetsDef: new r.Pointer(r.uint16, MarkGlyphSetsDef)
   },
   0x00010003: {
-    markGlyphSetsDef:   new r.Pointer(r.uint16, MarkGlyphSetsDef),
+    markGlyphSetsDef: new r.Pointer(r.uint16, MarkGlyphSetsDef),
     itemVariationStore: new r.Pointer(r.uint32, ItemVariationStore)
   }
 });

package/src/tables/GPOS.js

@@ -1,6 +1,12 @@
 import * as r from 'restructure';
-import {ScriptList, FeatureList, LookupList, Coverage, ClassDef, Device, Context, ChainingContext} from './opentype';
-import {FeatureVariations} from './variations';
+import { ScriptList, FeatureList, LookupList, Coverage, ClassDef, Device, Context, ChainingContext } from './opentype';
+import { FeatureVariations } from './variations';
+
+/** @typedef {import('restructure').BaseType} BaseType */
+/** @typedef {import('restructure').DecodeStream} DecodeStream */
+/** @typedef {import('restructure').Struct} Struct */
+/** @typedef {import('restructure').StructValue} StructValue */
+/** @typedef {import('restructure').Pointer} Pointer */
 
 let ValueFormat = new r.Bitfield(r.uint16, [
   'xPlacement', 'yPlacement',
@@ -9,36 +15,67 @@ let ValueFormat = new r.Bitfield(r.uint16, [
   'xAdvDevice', 'yAdvDevice'
 ]);
 
+/** @type {Record<string, BaseType>} */
 let types = {
   xPlacement: r.int16,
   yPlacement: r.int16,
-  xAdvance:   r.int16,
-  yAdvance:   r.int16,
-  xPlaDevice: new r.Pointer(r.uint16, Device, { type: 'global', relativeTo: ctx => ctx.rel }),
-  yPlaDevice: new r.Pointer(r.uint16, Device, { type: 'global', relativeTo: ctx => ctx.rel }),
-  xAdvDevice: new r.Pointer(r.uint16, Device, { type: 'global', relativeTo: ctx => ctx.rel }),
-  yAdvDevice: new r.Pointer(r.uint16, Device, { type: 'global', relativeTo: ctx => ctx.rel })
+  xAdvance: r.int16,
+  yAdvance: r.int16,
+  xPlaDevice: new r.Pointer(r.uint16, Device, {
+    type: 'global',
+    /** @param {StructValue} ctx @returns {number} */
+    relativeTo: ctx => /** @type {number} */ (ctx.rel)
+  }),
+  yPlaDevice: new r.Pointer(r.uint16, Device, {
+    type: 'global',
+    /** @param {StructValue} ctx @returns {number} */
+    relativeTo: ctx => /** @type {number} */ (ctx.rel)
+  }),
+  xAdvDevice: new r.Pointer(r.uint16, Device, {
+    type: 'global',
+    /** @param {StructValue} ctx @returns {number} */
+    relativeTo: ctx => /** @type {number} */ (ctx.rel)
+  }),
+  yAdvDevice: new r.Pointer(r.uint16, Device, {
+    type: 'global',
+    /** @param {StructValue} ctx @returns {number} */
+    relativeTo: ctx => /** @type {number} */ (ctx.rel)
+  })
 };
 
+/**
+ * Dynamic GPOS value record whose fields depend on a ValueFormat bitfield.
+ * @implements {BaseType}
+ */
 class ValueRecord {
+  /**
+   * @param {string} [key]
+   */
   constructor(key = 'valueFormat') {
+    /** @type {string} */
     this.key = key;
   }
 
+  /**
+   * @param {StructValue | null | undefined} parent
+   * @returns {Struct | undefined}
+   */
   buildStruct(parent) {
     let struct = parent;
-    while (!struct[this.key] && struct.parent) {
+    while (struct && !struct[this.key] && struct.parent) {
       struct = struct.parent;
     }
 
-    if (!struct[this.key]) return;
+    if (!struct || !struct[this.key]) return;
 
+    /** @type {Record<string, BaseType | ((this: StructValue, parent: StructValue) => unknown)>} */
     let fields = {};
-    fields.rel = () => struct._startOffset;
+    let start = struct;
+    fields.rel = () => start._startOffset;
 
-    let format = struct[this.key];
-    for (let key in format) {
-      if (format[key]) {
+    let format = /** @type {Record<string, boolean>} */ (struct[this.key]);
+    for (let key of Object.keys(format)) {
+      if (format[key] && types[key]) {
         fields[key] = types[key];
       }
     }
@@ -46,21 +83,34 @@ class ValueRecord {
     return new r.Struct(fields);
   }
 
+  /**
+   * @param {unknown} val
+   * @param {StructValue | null | undefined} ctx
+   * @returns {number}
+   */
   size(val, ctx) {
-    return this.buildStruct(ctx).size(val, ctx);
+    let s = this.buildStruct(ctx);
+    return s ? s.size(/** @type {StructValue} */ (val), ctx) : 0;
   }
 
+  /**
+   * @param {DecodeStream} stream
+   * @param {StructValue | null | undefined} parent
+   * @returns {StructValue | undefined}
+   */
   decode(stream, parent) {
-    let res = this.buildStruct(parent).decode(stream, parent);
+    let s = this.buildStruct(parent);
+    if (!s) return;
+    let res = s.decode(stream, parent);
     delete res.rel;
     return res;
   }
 }
 
 let PairValueRecord = new r.Struct({
-  secondGlyph:    r.uint16,
-  value1:         new ValueRecord('valueFormat1'),
-  value2:         new ValueRecord('valueFormat2')
+  secondGlyph: r.uint16,
+  value1: new ValueRecord('valueFormat1'),
+  value2: new ValueRecord('valueFormat2')
 });
 
 let PairSet = new r.Array(PairValueRecord, r.uint16);
@@ -72,131 +122,144 @@ let Class2Record = new r.Struct({
 
 let Anchor = new r.VersionedStruct(r.uint16, {
   1: { // Design units only
-    xCoordinate:    r.int16,
-    yCoordinate:    r.int16
+    xCoordinate: r.int16,
+    yCoordinate: r.int16
   },
 
   2: { // Design units plus contour point
-    xCoordinate:    r.int16,
-    yCoordinate:    r.int16,
-    anchorPoint:    r.uint16
+    xCoordinate: r.int16,
+    yCoordinate: r.int16,
+    anchorPoint: r.uint16
   },
 
   3: { // Design units plus Device tables
-    xCoordinate:    r.int16,
-    yCoordinate:    r.int16,
-    xDeviceTable:   new r.Pointer(r.uint16, Device),
-    yDeviceTable:   new r.Pointer(r.uint16, Device)
+    xCoordinate: r.int16,
+    yCoordinate: r.int16,
+    xDeviceTable: new r.Pointer(r.uint16, Device),
+    yDeviceTable: new r.Pointer(r.uint16, Device)
   }
 });
 
 let EntryExitRecord = new r.Struct({
-  entryAnchor:    new r.Pointer(r.uint16, Anchor, {type: 'parent'}),
-  exitAnchor:     new r.Pointer(r.uint16, Anchor, {type: 'parent'})
+  entryAnchor: new r.Pointer(r.uint16, Anchor, { type: 'parent' }),
+  exitAnchor: new r.Pointer(r.uint16, Anchor, { type: 'parent' })
 });
 
 let MarkRecord = new r.Struct({
-  class:      r.uint16,
-  markAnchor: new r.Pointer(r.uint16, Anchor, {type: 'parent'})
+  class: r.uint16,
+  markAnchor: new r.Pointer(r.uint16, Anchor, { type: 'parent' })
 });
 
 let MarkArray = new r.Array(MarkRecord, r.uint16);
 
-let BaseRecord  = new r.Array(new r.Pointer(r.uint16, Anchor), t => t.parent.classCount);
-let BaseArray   = new r.Array(BaseRecord, r.uint16);
-
-let ComponentRecord = new r.Array(new r.Pointer(r.uint16, Anchor), t => t.parent.parent.classCount);
-let LigatureAttach  = new r.Array(ComponentRecord, r.uint16);
-let LigatureArray   = new r.Array(new r.Pointer(r.uint16, LigatureAttach), r.uint16);
-
+let BaseRecord = new r.Array(
+  new r.Pointer(r.uint16, Anchor),
+  /** @param {StructValue} t @returns {number} */
+  t => /** @type {number} */ (/** @type {StructValue} */ (t.parent).classCount)
+);
+let BaseArray = new r.Array(BaseRecord, r.uint16);
+
+let ComponentRecord = new r.Array(
+  new r.Pointer(r.uint16, Anchor),
+  /** @param {StructValue} t @returns {number} */
+  t => /** @type {number} */ (
+    /** @type {StructValue} */ (/** @type {StructValue} */ (t.parent).parent).classCount
+  )
+);
+let LigatureAttach = new r.Array(ComponentRecord, r.uint16);
+let LigatureArray = new r.Array(new r.Pointer(r.uint16, LigatureAttach), r.uint16);
+
+/** @type {import('restructure').VersionedStruct} */
 let GPOSLookup = new r.VersionedStruct('lookupType', {
   1: new r.VersionedStruct(r.uint16, { // Single Adjustment
     1: { // Single positioning value
-      coverage:       new r.Pointer(r.uint16, Coverage),
-      valueFormat:    ValueFormat,
-      value:          new ValueRecord()
+      coverage: new r.Pointer(r.uint16, Coverage),
+      valueFormat: ValueFormat,
+      value: new ValueRecord()
     },
     2: {
-      coverage:       new r.Pointer(r.uint16, Coverage),
-      valueFormat:    ValueFormat,
-      valueCount:     r.uint16,
-      values:         new r.LazyArray(new ValueRecord(), 'valueCount')
+      coverage: new r.Pointer(r.uint16, Coverage),
+      valueFormat: ValueFormat,
+      valueCount: r.uint16,
+      values: new r.LazyArray(new ValueRecord(), 'valueCount')
     }
   }),
 
   2: new r.VersionedStruct(r.uint16, { // Pair Adjustment Positioning
     1: { // Adjustments for glyph pairs
-      coverage:       new r.Pointer(r.uint16, Coverage),
-      valueFormat1:   ValueFormat,
-      valueFormat2:   ValueFormat,
-      pairSetCount:   r.uint16,
-      pairSets:       new r.LazyArray(new r.Pointer(r.uint16, PairSet), 'pairSetCount')
+      coverage: new r.Pointer(r.uint16, Coverage),
+      valueFormat1: ValueFormat,
+      valueFormat2: ValueFormat,
+      pairSetCount: r.uint16,
+      pairSets: new r.LazyArray(new r.Pointer(r.uint16, PairSet), 'pairSetCount')
     },
 
     2: { // Class pair adjustment
-      coverage:       new r.Pointer(r.uint16, Coverage),
-      valueFormat1:   ValueFormat,
-      valueFormat2:   ValueFormat,
-      classDef1:      new r.Pointer(r.uint16, ClassDef),
-      classDef2:      new r.Pointer(r.uint16, ClassDef),
-      class1Count:    r.uint16,
-      class2Count:    r.uint16,
-      classRecords:   new r.LazyArray(new r.LazyArray(Class2Record, 'class2Count'), 'class1Count')
+      coverage: new r.Pointer(r.uint16, Coverage),
+      valueFormat1: ValueFormat,
+      valueFormat2: ValueFormat,
+      classDef1: new r.Pointer(r.uint16, ClassDef),
+      classDef2: new r.Pointer(r.uint16, ClassDef),
+      class1Count: r.uint16,
+      class2Count: r.uint16,
+      classRecords: new r.LazyArray(new r.LazyArray(Class2Record, 'class2Count'), 'class1Count')
     }
   }),
 
   3: { // Cursive Attachment Positioning
-    format:             r.uint16,
-    coverage:           new r.Pointer(r.uint16, Coverage),
-    entryExitCount:     r.uint16,
-    entryExitRecords:   new r.Array(EntryExitRecord, 'entryExitCount')
+    format: r.uint16,
+    coverage: new r.Pointer(r.uint16, Coverage),
+    entryExitCount: r.uint16,
+    entryExitRecords: new r.Array(EntryExitRecord, 'entryExitCount')
   },
 
   4: { // MarkToBase Attachment Positioning
-    format:             r.uint16,
-    markCoverage:       new r.Pointer(r.uint16, Coverage),
-    baseCoverage:       new r.Pointer(r.uint16, Coverage),
-    classCount:         r.uint16,
-    markArray:          new r.Pointer(r.uint16, MarkArray),
-    baseArray:          new r.Pointer(r.uint16, BaseArray)
+    format: r.uint16,
+    markCoverage: new r.Pointer(r.uint16, Coverage),
+    baseCoverage: new r.Pointer(r.uint16, Coverage),
+    classCount: r.uint16,
+    markArray: new r.Pointer(r.uint16, MarkArray),
+    baseArray: new r.Pointer(r.uint16, BaseArray)
   },
 
   5: { // MarkToLigature Attachment Positioning
-    format:             r.uint16,
-    markCoverage:       new r.Pointer(r.uint16, Coverage),
-    ligatureCoverage:   new r.Pointer(r.uint16, Coverage),
-    classCount:         r.uint16,
-    markArray:          new r.Pointer(r.uint16, MarkArray),
-    ligatureArray:      new r.Pointer(r.uint16, LigatureArray)
+    format: r.uint16,
+    markCoverage: new r.Pointer(r.uint16, Coverage),
+    ligatureCoverage: new r.Pointer(r.uint16, Coverage),
+    classCount: r.uint16,
+    markArray: new r.Pointer(r.uint16, MarkArray),
+    ligatureArray: new r.Pointer(r.uint16, LigatureArray)
   },
 
   6: { // MarkToMark Attachment Positioning
-    format:             r.uint16,
-    mark1Coverage:      new r.Pointer(r.uint16, Coverage),
-    mark2Coverage:      new r.Pointer(r.uint16, Coverage),
-    classCount:         r.uint16,
-    mark1Array:         new r.Pointer(r.uint16, MarkArray),
-    mark2Array:         new r.Pointer(r.uint16, BaseArray)
+    format: r.uint16,
+    mark1Coverage: new r.Pointer(r.uint16, Coverage),
+    mark2Coverage: new r.Pointer(r.uint16, Coverage),
+    classCount: r.uint16,
+    mark1Array: new r.Pointer(r.uint16, MarkArray),
+    mark2Array: new r.Pointer(r.uint16, BaseArray)
   },
 
-  7: Context,          // Contextual positioning
-  8: ChainingContext,  // Chaining contextual positioning
+  7: Context, // Contextual positioning
+  8: ChainingContext, // Chaining contextual positioning
 
   9: { // Extension Positioning
-    posFormat:   r.uint16,
-    lookupType:  r.uint16,   // cannot also be 9
-    extension:   new r.Pointer(r.uint32, null)
+    posFormat: r.uint16,
+    lookupType: r.uint16, // cannot also be 9
+    extension: new r.Pointer(r.uint32, null)
   }
 });
 
 // Fix circular reference
-GPOSLookup.versions[9].extension.type = GPOSLookup;
+let gposExt = /** @type {Record<string, BaseType>} */ (GPOSLookup.versions[9]);
+/** @type {Pointer} */ (gposExt.extension).type = GPOSLookup;
 
+/** @type {import('restructure').VersionedStruct} */
 export default new r.VersionedStruct(r.uint32, {
   header: {
-    scriptList:     new r.Pointer(r.uint16, ScriptList),
-    featureList:    new r.Pointer(r.uint16, FeatureList),
-    lookupList:     new r.Pointer(r.uint16, new LookupList(GPOSLookup))
+    scriptList: new r.Pointer(r.uint16, ScriptList),
+    featureList: new r.Pointer(r.uint16, FeatureList),
+    lookupList: new r.Pointer(r.uint16, LookupList(GPOSLookup))
   },
 
   0x00010000: {},

package/src/tables/GSUB.js

@@ -1,81 +1,92 @@
 import * as r from 'restructure';
-import {ScriptList, FeatureList, LookupList, Coverage, Context, ChainingContext} from './opentype';
-import {FeatureVariations} from './variations';
+import { ScriptList, FeatureList, LookupList, Coverage, Context, ChainingContext } from './opentype';
+import { FeatureVariations } from './variations';
+
+/** @typedef {import('restructure').BaseType} BaseType */
+/** @typedef {import('restructure').Pointer} Pointer */
+/** @typedef {import('restructure').StructValue} StructValue */
 
 let Sequence = new r.Array(r.uint16, r.uint16);
 let AlternateSet = Sequence;
 
 let Ligature = new r.Struct({
-  glyph:      r.uint16,
-  compCount:  r.uint16,
-  components: new r.Array(r.uint16, t => t.compCount - 1)
+  glyph: r.uint16,
+  compCount: r.uint16,
+  components: new r.Array(
+    r.uint16,
+    /** @param {StructValue} t @returns {number} */
+    t => /** @type {number} */ (t.compCount) - 1
+  )
 });
 
 let LigatureSet = new r.Array(new r.Pointer(r.uint16, Ligature), r.uint16);
 
+/** @type {import('restructure').VersionedStruct} */
 let GSUBLookup = new r.VersionedStruct('lookupType', {
-  1: new r.VersionedStruct(r.uint16, {// Single Substitution
+  1: new r.VersionedStruct(r.uint16, { // Single Substitution
     1: {
-      coverage:       new r.Pointer(r.uint16, Coverage),
-      deltaGlyphID:   r.int16
+      coverage: new r.Pointer(r.uint16, Coverage),
+      deltaGlyphID: r.int16
     },
     2: {
-      coverage:       new r.Pointer(r.uint16, Coverage),
-      glyphCount:     r.uint16,
-      substitute:     new r.LazyArray(r.uint16, 'glyphCount')
+      coverage: new r.Pointer(r.uint16, Coverage),
+      glyphCount: r.uint16,
+      substitute: new r.LazyArray(r.uint16, 'glyphCount')
     }
   }),
 
   2: { // Multiple Substitution
-    substFormat:    r.uint16,
-    coverage:       new r.Pointer(r.uint16, Coverage),
-    count:          r.uint16,
-    sequences:      new r.LazyArray(new r.Pointer(r.uint16, Sequence), 'count')
+    substFormat: r.uint16,
+    coverage: new r.Pointer(r.uint16, Coverage),
+    count: r.uint16,
+    sequences: new r.LazyArray(new r.Pointer(r.uint16, Sequence), 'count')
   },
 
   3: { // Alternate Substitution
-    substFormat:    r.uint16,
-    coverage:       new r.Pointer(r.uint16, Coverage),
-    count:          r.uint16,
-    alternateSet:   new r.LazyArray(new r.Pointer(r.uint16, AlternateSet), 'count')
+    substFormat: r.uint16,
+    coverage: new r.Pointer(r.uint16, Coverage),
+    count: r.uint16,
+    alternateSet: new r.LazyArray(new r.Pointer(r.uint16, AlternateSet), 'count')
   },
 
   4: { // Ligature Substitution
-    substFormat:    r.uint16,
-    coverage:       new r.Pointer(r.uint16, Coverage),
-    count:          r.uint16,
-    ligatureSets:   new r.LazyArray(new r.Pointer(r.uint16, LigatureSet), 'count')
+    substFormat: r.uint16,
+    coverage: new r.Pointer(r.uint16, Coverage),
+    count: r.uint16,
+    ligatureSets: new r.LazyArray(new r.Pointer(r.uint16, LigatureSet), 'count')
   },
 
-  5: Context,         // Contextual Substitution
+  5: Context, // Contextual Substitution
   6: ChainingContext, // Chaining Contextual Substitution
 
   7: { // Extension Substitution
-    substFormat:   r.uint16,
-    lookupType:    r.uint16,   // cannot also be 7
-    extension:     new r.Pointer(r.uint32, null)
+    substFormat: r.uint16,
+    lookupType: r.uint16, // cannot also be 7
+    extension: new r.Pointer(r.uint32, null)
   },
 
   8: { // Reverse Chaining Contextual Single Substitution
-    substFormat:            r.uint16,
-    coverage:               new r.Pointer(r.uint16, Coverage),
-    backtrackGlyphCount:    r.uint16,
-    backtrackCoverage:      new r.Array(new r.Pointer(r.uint16, Coverage), 'backtrackGlyphCount'),
-    lookaheadGlyphCount:    r.uint16,
-    lookaheadCoverage:      new r.Array(new r.Pointer(r.uint16, Coverage), 'lookaheadGlyphCount'),
-    glyphCount:             r.uint16,
-    substitute:             new r.LazyArray(r.uint16, 'glyphCount')
+    substFormat: r.uint16,
+    coverage: new r.Pointer(r.uint16, Coverage),
+    backtrackGlyphCount: r.uint16,
+    backtrackCoverage: new r.Array(new r.Pointer(r.uint16, Coverage), 'backtrackGlyphCount'),
+    lookaheadGlyphCount: r.uint16,
+    lookaheadCoverage: new r.Array(new r.Pointer(r.uint16, Coverage), 'lookaheadGlyphCount'),
+    glyphCount: r.uint16,
+    substitute: new r.LazyArray(r.uint16, 'glyphCount')
   }
 });
 
 // Fix circular reference
-GSUBLookup.versions[7].extension.type = GSUBLookup;
+let gsubExt = /** @type {Record<string, BaseType>} */ (GSUBLookup.versions[7]);
+/** @type {Pointer} */ (gsubExt.extension).type = GSUBLookup;
 
+/** @type {import('restructure').VersionedStruct} */
 export default new r.VersionedStruct(r.uint32, {
   header: {
-    scriptList:     new r.Pointer(r.uint16, ScriptList),
-    featureList:    new r.Pointer(r.uint16, FeatureList),
-    lookupList:     new r.Pointer(r.uint16, new LookupList(GSUBLookup))
+    scriptList: new r.Pointer(r.uint16, ScriptList),
+    featureList: new r.Pointer(r.uint16, FeatureList),
+    lookupList: new r.Pointer(r.uint16, LookupList(GSUBLookup))
   },
 
   0x00010000: {},

package/src/tables/HVAR.js

@@ -2,30 +2,75 @@ import * as r from 'restructure';
 import { resolveLength } from 'restructure';
 import { ItemVariationStore } from './variations';
 
-// TODO: add this to restructure
+/** @typedef {import('restructure').BaseType} BaseType */
+/** @typedef {import('restructure').DecodeStream} DecodeStream */
+/** @typedef {import('restructure').LengthSpec} LengthSpec */
+/** @typedef {import('restructure').StructValue} StructValue */
+
+/**
+ * Integer whose byte width is computed from a LengthSpec.
+ * @implements {BaseType}
+ */
 class VariableSizeNumber {
+  /**
+   * @param {LengthSpec} size
+   */
   constructor(size) {
+    /** @type {LengthSpec} */
     this._size = size;
   }
 
+  /**
+   * @param {DecodeStream} stream
+   * @param {StructValue | null | undefined} parent
+   * @returns {number}
+   */
   decode(stream, parent) {
     switch (this.size(0, parent)) {
       case 1: return stream.readUInt8();
       case 2: return stream.readUInt16BE();
       case 3: return stream.readUInt24BE();
       case 4: return stream.readUInt32BE();
+      default: throw new Error(`Unsupported VariableSizeNumber width`);
     }
   }
 
-  size(val, parent) {
+  /**
+   * @param {unknown} _val
+   * @param {StructValue | null | undefined} [parent]
+   * @returns {number}
+   */
+  size(_val, parent) {
     return resolveLength(this._size, null, parent);
   }
 }
 
 let MapDataEntry = new r.Struct({
-  entry: new VariableSizeNumber(t => ((t.parent.entryFormat & 0x0030) >> 4) + 1),
-  outerIndex: t => t.entry >> ((t.parent.entryFormat & 0x000F) + 1),
-  innerIndex: t => t.entry & ((1 << ((t.parent.entryFormat & 0x000F) + 1)) - 1)
+  entry: new VariableSizeNumber(
+    /** @param {StructValue} t @returns {number} */
+    (t) => {
+      let parent = /** @type {StructValue} */ (t.parent);
+      return ((/** @type {number} */ (parent.entryFormat) & 0x0030) >> 4) + 1;
+    }
+  ),
+  /**
+   * @param {StructValue} t
+   * @returns {number}
+   */
+  outerIndex: (t) => {
+    let parent = /** @type {StructValue} */ (t.parent);
+    let entryFormat = /** @type {number} */ (parent.entryFormat);
+    return /** @type {number} */ (t.entry) >> ((entryFormat & 0x000F) + 1);
+  },
+  /**
+   * @param {StructValue} t
+   * @returns {number}
+   */
+  innerIndex: (t) => {
+    let parent = /** @type {StructValue} */ (t.parent);
+    let entryFormat = /** @type {number} */ (parent.entryFormat);
+    return /** @type {number} */ (t.entry) & ((1 << ((entryFormat & 0x000F) + 1)) - 1);
+  }
 });
 
 let DeltaSetIndexMap = new r.Struct({
@@ -34,6 +79,7 @@ let DeltaSetIndexMap = new r.Struct({
   mapData: new r.Array(MapDataEntry, 'mapCount')
 });
 
+/** @type {import('restructure').Struct} */
 export default new r.Struct({
   majorVersion: r.uint16,
   minorVersion: r.uint16,