@cantoo/fontkit 2.0.4 → 2.0.6

package/src/tables/opentype.js

@@ -1,54 +1,60 @@
 import * as r from 'restructure';
 
-//########################
+/** @typedef {import('restructure').BaseType} BaseType */
+/** @typedef {import('restructure').StructValue} StructValue */
+
+// ########################
 // Scripts and Languages #
-//########################
+// ########################
 
 let LangSysTable = new r.Struct({
-  reserved:         new r.Reserved(r.uint16),
-  reqFeatureIndex:  r.uint16,
-  featureCount:     r.uint16,
-  featureIndexes:   new r.Array(r.uint16, 'featureCount')
+  reserved: new r.Reserved(r.uint16),
+  reqFeatureIndex: r.uint16,
+  featureCount: r.uint16,
+  featureIndexes: new r.Array(r.uint16, 'featureCount')
 });
 
 let LangSysRecord = new r.Struct({
-  tag:      new r.String(4),
-  langSys:  new r.Pointer(r.uint16, LangSysTable, { type: 'parent' })
+  tag: new r.String(4),
+  langSys: new r.Pointer(r.uint16, LangSysTable, { type: 'parent' })
 });
 
 let Script = new r.Struct({
   defaultLangSys: new r.Pointer(r.uint16, LangSysTable),
-  count:          r.uint16,
+  count: r.uint16,
   langSysRecords: new r.Array(LangSysRecord, 'count')
 });
 
 let ScriptRecord = new r.Struct({
-  tag:    new r.String(4),
+  tag: new r.String(4),
   script: new r.Pointer(r.uint16, Script, { type: 'parent' })
 });
 
+/** @type {import('restructure').ArrayT} */
 export let ScriptList = new r.Array(ScriptRecord, r.uint16);
 
-//#######################
+// #######################
 // Features and Lookups #
-//#######################
+// #######################
 
 let FeatureParams = new r.Struct({
-  version:    r.uint16, // should be set to 0 according OT spec
-  nameID:     r.uint16, //OT spec: UI Name ID or uiLabelNameId
+  version: r.uint16, // should be set to 0 according OT spec
+  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,
-  lookupListIndexes:  new r.Array(r.uint16, 'lookupCount')
+  featureParams: new r.Pointer(r.uint16, FeatureParams),
+  lookupCount: r.uint16,
+  lookupListIndexes: new r.Array(r.uint16, 'lookupCount')
 });
 
 let FeatureRecord = new r.Struct({
-  tag:      new r.String(4),
-  feature:  new r.Pointer(r.uint16, Feature, { type: 'parent' })
+  tag: new r.String(4),
+  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,159 +65,188 @@ 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)
+    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,
+      /** @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);
 }
 
-//#################
+// #################
 // Coverage Table #
-//#################
+// #################
 
 let RangeRecord = new r.Struct({
-  start:              r.uint16,
-  end:                r.uint16,
+  start: r.uint16,
+  end: r.uint16,
   startCoverageIndex: r.uint16
 });
 
+/** @type {import('restructure').VersionedStruct} */
 export let Coverage = new r.VersionedStruct(r.uint16, {
   1: {
-    glyphCount:   r.uint16,
-    glyphs:       new r.Array(r.uint16, 'glyphCount')
+    glyphCount: r.uint16,
+    glyphs: new r.Array(r.uint16, 'glyphCount')
   },
   2: {
-    rangeCount:   r.uint16,
+    rangeCount: r.uint16,
     rangeRecords: new r.Array(RangeRecord, 'rangeCount')
   }
 });
 
-//#########################
+// #########################
 // Class Definition Table #
-//#########################
+// #########################
 
 let ClassRangeRecord = new r.Struct({
-  start:  r.uint16,
-  end:    r.uint16,
-  class:  r.uint16
+  start: r.uint16,
+  end: r.uint16,
+  class: r.uint16
 });
 
+/** @type {import('restructure').VersionedStruct} */
 export let ClassDef = new r.VersionedStruct(r.uint16, {
   1: { // Class array
-    startGlyph:       r.uint16,
-    glyphCount:       r.uint16,
-    classValueArray:  new r.Array(r.uint16, 'glyphCount')
+    startGlyph: r.uint16,
+    glyphCount: r.uint16,
+    classValueArray: new r.Array(r.uint16, 'glyphCount')
   },
   2: { // Class ranges
-    classRangeCount:  r.uint16,
+    classRangeCount: r.uint16,
     classRangeRecord: new r.Array(ClassRangeRecord, 'classRangeCount')
   }
 });
 
-//###############
+// ###############
 // 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
   deltaFormat: r.uint16
 });
 
-//#############################################
+// #############################################
 // Contextual Substitution/Positioning Tables #
-//#############################################
+// #############################################
 
 let LookupRecord = new r.Struct({
-  sequenceIndex:      r.uint16,
-  lookupListIndex:    r.uint16
+  sequenceIndex: r.uint16,
+  lookupListIndex: r.uint16
 });
 
 let Rule = new r.Struct({
-  glyphCount:     r.uint16,
-  lookupCount:    r.uint16,
-  input:          new r.Array(r.uint16, t => t.glyphCount - 1),
-  lookupRecords:  new r.Array(LookupRecord, 'lookupCount')
+  glyphCount: r.uint16,
+  lookupCount: r.uint16,
+  input: new r.Array(
+    r.uint16,
+    /** @param {StructValue} t @returns {number} */
+    t => /** @type {number} */ (t.glyphCount) - 1
+  ),
+  lookupRecords: new r.Array(LookupRecord, 'lookupCount')
 });
 
 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),
-  lookupRecords:  new r.Array(LookupRecord, 'lookupCount')
+  glyphCount: r.uint16,
+  lookupCount: r.uint16,
+  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),
-    ruleSetCount:  r.uint16,
-    ruleSets:      new r.Array(new r.Pointer(r.uint16, RuleSet), 'ruleSetCount')
+    coverage: new r.Pointer(r.uint16, Coverage),
+    ruleSetCount: r.uint16,
+    ruleSets: new r.Array(new r.Pointer(r.uint16, RuleSet), 'ruleSetCount')
   },
   2: { // Class-based context
-    coverage:      new r.Pointer(r.uint16, Coverage),
-    classDef:      new r.Pointer(r.uint16, ClassDef),
-    classSetCnt:   r.uint16,
-    classSet:      new r.Array(new r.Pointer(r.uint16, ClassSet), 'classSetCnt')
+    coverage: new r.Pointer(r.uint16, Coverage),
+    classDef: new r.Pointer(r.uint16, ClassDef),
+    classSetCnt: r.uint16,
+    classSet: new r.Array(new r.Pointer(r.uint16, ClassSet), 'classSetCnt')
   },
   3: {
-    glyphCount:    r.uint16,
-    lookupCount:   r.uint16,
-    coverages:     new r.Array(new r.Pointer(r.uint16, Coverage), 'glyphCount'),
+    glyphCount: r.uint16,
+    lookupCount: r.uint16,
+    coverages: new r.Array(new r.Pointer(r.uint16, Coverage), 'glyphCount'),
     lookupRecords: new r.Array(LookupRecord, 'lookupCount')
   }
 });
 
-//######################################################
+// ######################################################
 // Chaining Contextual Substitution/Positioning Tables #
-//######################################################
+// ######################################################
 
 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),
-  lookaheadGlyphCount:  r.uint16,
-  lookahead:            new r.Array(r.uint16, 'lookaheadGlyphCount'),
-  lookupCount:          r.uint16,
-  lookupRecords:        new r.Array(LookupRecord, 'lookupCount')
+  backtrackGlyphCount: r.uint16,
+  backtrack: new r.Array(r.uint16, 'backtrackGlyphCount'),
+  inputGlyphCount: r.uint16,
+  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,
+  lookupRecords: new r.Array(LookupRecord, 'lookupCount')
 });
 
 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),
-    chainCount:         r.uint16,
-    chainRuleSets:      new r.Array(new r.Pointer(r.uint16, ChainRuleSet), 'chainCount')
+    coverage: new r.Pointer(r.uint16, Coverage),
+    chainCount: r.uint16,
+    chainRuleSets: new r.Array(new r.Pointer(r.uint16, ChainRuleSet), 'chainCount')
   },
 
   2: { // Class-based chaining context
-    coverage:           new r.Pointer(r.uint16, Coverage),
-    backtrackClassDef:  new r.Pointer(r.uint16, ClassDef),
-    inputClassDef:      new r.Pointer(r.uint16, ClassDef),
-    lookaheadClassDef:  new r.Pointer(r.uint16, ClassDef),
-    chainCount:         r.uint16,
-    chainClassSet:      new r.Array(new r.Pointer(r.uint16, ChainRuleSet), 'chainCount')
+    coverage: new r.Pointer(r.uint16, Coverage),
+    backtrackClassDef: new r.Pointer(r.uint16, ClassDef),
+    inputClassDef: new r.Pointer(r.uint16, ClassDef),
+    lookaheadClassDef: new r.Pointer(r.uint16, ClassDef),
+    chainCount: r.uint16,
+    chainClassSet: new r.Array(new r.Pointer(r.uint16, ChainRuleSet), 'chainCount')
   },
 
   3: { // Coverage-based chaining context
-    backtrackGlyphCount:    r.uint16,
-    backtrackCoverage:      new r.Array(new r.Pointer(r.uint16, Coverage), 'backtrackGlyphCount'),
-    inputGlyphCount:        r.uint16,
-    inputCoverage:          new r.Array(new r.Pointer(r.uint16, Coverage), 'inputGlyphCount'),
-    lookaheadGlyphCount:    r.uint16,
-    lookaheadCoverage:      new r.Array(new r.Pointer(r.uint16, Coverage), 'lookaheadGlyphCount'),
-    lookupCount:            r.uint16,
-    lookupRecords:          new r.Array(LookupRecord, 'lookupCount')
+    backtrackGlyphCount: r.uint16,
+    backtrackCoverage: new r.Array(new r.Pointer(r.uint16, Coverage), 'backtrackGlyphCount'),
+    inputGlyphCount: r.uint16,
+    inputCoverage: new r.Array(new r.Pointer(r.uint16, Coverage), 'inputGlyphCount'),
+    lookaheadGlyphCount: r.uint16,
+    lookaheadCoverage: new r.Array(new r.Pointer(r.uint16, Coverage), 'lookaheadGlyphCount'),
+    lookupCount: r.uint16,
+    lookupRecords: new r.Array(LookupRecord, 'lookupCount')
   }
 });

package/src/tables/post.js

@@ -1,16 +1,19 @@
 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.
-    underlinePosition:  r.int16,   // Suggested distance of the top of the underline from the baseline
-    underlineThickness: r.int16,   // Suggested values for the underline thickness
-    isFixedPitch:       r.uint32,  // Whether the font is monospaced
-    minMemType42:       r.uint32,  // Minimum memory usage when a TrueType font is downloaded as a Type 42 font
-    maxMemType42:       r.uint32,  // Maximum memory usage when a TrueType font is downloaded as a Type 42 font
-    minMemType1:        r.uint32,  // Minimum memory usage when a TrueType font is downloaded as a Type 1 font
-    maxMemType1:        r.uint32   // Maximum memory usage when a TrueType font is downloaded as a Type 1 font
+    italicAngle: r.fixed32, // Italic angle in counter-clockwise degrees from the vertical.
+    underlinePosition: r.int16, // Suggested distance of the top of the underline from the baseline
+    underlineThickness: r.int16, // Suggested values for the underline thickness
+    isFixedPitch: r.uint32, // Whether the font is monospaced
+    minMemType42: r.uint32, // Minimum memory usage when a TrueType font is downloaded as a Type 42 font
+    maxMemType42: r.uint32, // Maximum memory usage when a TrueType font is downloaded as a Type 42 font
+    minMemType1: r.uint32, // Minimum memory usage when a TrueType font is downloaded as a Type 1 font
+    maxMemType1: r.uint32 // Maximum memory usage when a TrueType font is downloaded as a Type 1 font
   },
 
   1: {}, // version 1 has no additional fields
@@ -18,17 +21,21 @@ export default new r.VersionedStruct(r.fixed32, {
   2: {
     numberOfGlyphs: r.uint16,
     glyphNameIndex: new r.Array(r.uint16, 'numberOfGlyphs'),
-    names:          new r.Array(new r.String(r.uint8))
+    names: new r.Array(new r.String(r.uint8))
   },
 
   2.5: {
     numberOfGlyphs: r.uint16,
-    offsets:        new r.Array(r.uint8, 'numberOfGlyphs')
+    offsets: new r.Array(r.uint8, 'numberOfGlyphs')
   },
 
   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,7 +1,9 @@
-import {Feature} from './opentype';
+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),
@@ -39,7 +58,7 @@ export let ItemVariationStore = new r.Struct({
   itemVariationData: new r.Array(new r.Pointer(r.uint32, ItemVariationData), 'variationDataCount')
 });
 
-/**********************
+/** ********************
  * Feature Variations *
  **********************/
 
@@ -58,7 +77,7 @@ let ConditionSet = new r.Struct({
 
 let FeatureTableSubstitutionRecord = new r.Struct({
   featureIndex: r.uint16,
-  alternateFeatureTable: new r.Pointer(r.uint32, Feature, {type: 'parent'})
+  alternateFeatureTable: new r.Pointer(r.uint32, Feature, { type: 'parent' })
 });
 
 let FeatureTableSubstitution = new r.Struct({
@@ -68,10 +87,11 @@ let FeatureTableSubstitution = new r.Struct({
 });
 
 let FeatureVariationRecord = new r.Struct({
-  conditionSet: new r.Pointer(r.uint32, ConditionSet, {type: 'parent'}),
-  featureTableSubstitution: new r.Pointer(r.uint32, FeatureTableSubstitution, {type: 'parent'})
+  conditionSet: new r.Pointer(r.uint32, ConditionSet, { type: 'parent' }),
+  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,19 +1,20 @@
 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
-  descent:                r.int16,   // The vertical typographic descender for this font
-  lineGap:                r.int16,   // The vertical typographic line gap for this font
-  advanceHeightMax:       r.uint16,  // The maximum advance height measurement found in the font
-  minTopSideBearing:      r.int16,   // The minimum top side bearing measurement found in the font
-  minBottomSideBearing:   r.int16,   // The minimum bottom side bearing measurement found in the font
-  yMaxExtent:             r.int16,
-  caretSlopeRise:         r.int16,   // Caret slope (rise/run)
-  caretSlopeRun:          r.int16,
-  caretOffset:            r.int16,   // Set value equal to 0 for nonslanted fonts
-  reserved:               new r.Reserved(r.int16, 4),
-  metricDataFormat:       r.int16,   // Set to 0
-  numberOfMetrics:        r.uint16   // Number of advance heights in the Vertical Metrics table
+  version: r.fixed32, // Version number of the Vertical Header Table
+  ascent: r.int16, // The vertical typographic ascender for this font
+  descent: r.int16, // The vertical typographic descender for this font
+  lineGap: r.int16, // The vertical typographic line gap for this font
+  advanceHeightMax: r.uint16, // The maximum advance height measurement found in the font
+  minTopSideBearing: r.int16, // The minimum top side bearing measurement found in the font
+  minBottomSideBearing: r.int16, // The minimum bottom side bearing measurement found in the font
+  yMaxExtent: r.int16,
+  caretSlopeRise: r.int16, // Caret slope (rise/run)
+  caretSlopeRun: r.int16,
+  caretOffset: r.int16, // Set value equal to 0 for nonslanted fonts
+  reserved: new r.Reserved(r.int16, 4),
+  metricDataFormat: r.int16, // Set to 0
+  numberOfMetrics: r.uint16 // Number of advance heights in the Vertical Metrics table
 });

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
+  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;