@cantoo/fontkit 2.0.5 → 2.0.6

package/src/tables/feat.js

@@ -1,9 +1,29 @@
 import * as r from 'restructure';
 
+/** @typedef {import('restructure').StructValue} StructValue */
+
+/**
+ * @param {StructValue} t
+ * @param {number} depth
+ * @param {number} nameIndex
+ * @returns {unknown}
+ */
+function featureNameAt(t, depth, nameIndex) {
+  let cur = t;
+  for (let i = 0; i < depth; i++) {
+    cur = /** @type {StructValue} */ (cur.parent);
+  }
+  let name = /** @type {StructValue} */ (cur.name);
+  let records = /** @type {StructValue} */ (name.records);
+  let fontFeatures = /** @type {Record<number, unknown>} */ (records.fontFeatures);
+  return fontFeatures[nameIndex];
+}
+
 let Setting = new r.Struct({
   setting: r.uint16,
   nameIndex: r.int16,
-  name: t => t.parent.parent.parent.name.records.fontFeatures[t.nameIndex]
+  /** @param {StructValue} t @returns {unknown} */
+  name: t => featureNameAt(t, 3, /** @type {number} */ (t.nameIndex))
 });
 
 let FeatureName = new r.Struct({
@@ -16,9 +36,11 @@ let FeatureName = new r.Struct({
   ]),
   defaultSetting: r.uint8,
   nameIndex: r.int16,
-  name: t => t.parent.parent.name.records.fontFeatures[t.nameIndex]
+  /** @param {StructValue} t @returns {unknown} */
+  name: t => featureNameAt(t, 2, /** @type {number} */ (t.nameIndex))
 });
 
+/** @type {import('restructure').Struct} */
 export default new r.Struct({
   version: r.fixed32,
   featureNameCount: r.uint16,

package/src/tables/fpgm.js

@@ -3,6 +3,7 @@ import * as r from 'restructure';
 // A list of instructions that are executed once when a font is first used.
 // These instructions are known as the font program. The main use of this table
 // is for the definition of functions that are used in many different glyph programs.
+/** @type {import('restructure').Struct} */
 export default new r.Struct({
   instructions: new r.Array(r.uint8)
 });

package/src/tables/fvar.js

@@ -1,5 +1,21 @@
 import * as r from 'restructure';
 
+/** @typedef {import('restructure').StructValue} StructValue */
+
+/**
+ * @param {StructValue} t
+ * @param {number} nameID
+ * @returns {unknown}
+ */
+function featureName(t, nameID) {
+  let parent = /** @type {StructValue} */ (t.parent);
+  let grand = /** @type {StructValue} */ (parent.parent);
+  let name = /** @type {StructValue} */ (grand.name);
+  let records = /** @type {StructValue} */ (name.records);
+  let fontFeatures = /** @type {Record<number, unknown>} */ (records.fontFeatures);
+  return fontFeatures[nameID];
+}
+
 let Axis = new r.Struct({
   axisTag: new r.String(4),
   minValue: r.fixed32,
@@ -7,17 +23,29 @@ let Axis = new r.Struct({
   maxValue: r.fixed32,
   flags: r.uint16,
   nameID: r.uint16,
-  name: t => t.parent.parent.name.records.fontFeatures[t.nameID]
+  /** @param {StructValue} t @returns {unknown} */
+  name: t => featureName(t, /** @type {number} */ (t.nameID))
 });
 
 let Instance = new r.Struct({
   nameID: r.uint16,
-  name: t => t.parent.parent.name.records.fontFeatures[t.nameID],
+  /** @param {StructValue} t @returns {unknown} */
+  name: t => featureName(t, /** @type {number} */ (t.nameID)),
   flags: r.uint16,
-  coord: new r.Array(r.fixed32, t => t.parent.axisCount),
-  postscriptNameID: new r.Optional(r.uint16, t => t.parent.instanceSize - t._currentOffset > 0)
+  coord: new r.Array(
+    r.fixed32,
+    /** @param {StructValue} t @returns {number} */
+    t => /** @type {number} */ (/** @type {StructValue} */ (t.parent).axisCount)
+  ),
+  postscriptNameID: new r.Optional(
+    r.uint16,
+    /** @param {StructValue} t @returns {boolean} */
+    t => /** @type {number} */ (/** @type {StructValue} */ (t.parent).instanceSize)
+      - /** @type {number} */ (t._currentOffset) > 0
+  )
 });
 
+/** @type {import('restructure').Struct} */
 export default new r.Struct({
   version: r.fixed32,
   offsetToData: r.uint16,

package/src/tables/gasp.js

@@ -8,6 +8,7 @@ let GaspRange = new r.Struct({
   ])
 });
 
+/** @type {import('restructure').Struct} */
 export default new r.Struct({
   version: r.uint16, // set to 0
   numRanges: r.uint16,

package/src/tables/glyf.js

@@ -1,4 +1,5 @@
 import * as r from 'restructure';
 
 // only used for encoding
+/** @type {import('restructure').ArrayT} */
 export default new r.Array(new r.Buffer());

package/src/tables/gvar.js

@@ -1,17 +1,32 @@
 import * as r from 'restructure';
 
+/** @typedef {import('restructure').BaseType} BaseType */
+/** @typedef {import('restructure').DecodeStream} DecodeStream */
+/** @typedef {import('restructure').StructValue} StructValue */
+
 let shortFrac = new r.Fixed(16, 'BE', 14);
+
+/**
+ * Offset whose width depends on gvar.flags (Apple short/long format).
+ * @implements {BaseType}
+ */
 class Offset {
+  /**
+   * @param {DecodeStream} stream
+   * @param {StructValue | null | undefined} parent
+   * @returns {number}
+   */
   static decode(stream, parent) {
     // In short format, offsets are multiplied by 2.
     // This doesn't seem to be documented by Apple, but it
     // is implemented this way in Freetype.
-    return parent.flags
+    return parent && parent.flags
       ? stream.readUInt32BE()
       : stream.readUInt16BE() * 2;
   }
 }
 
+/** @type {import('restructure').Struct} */
 let gvar = new r.Struct({
   version: r.uint16,
   reserved: new r.Reserved(r.uint16),
@@ -21,7 +36,19 @@ let gvar = new r.Struct({
   glyphCount: r.uint16,
   flags: r.uint16,
   offsetToData: r.uint32,
-  offsets: new r.Array(new r.Pointer(Offset, 'void', { relativeTo: ctx => ctx.offsetToData, allowNull: false }), t => t.glyphCount + 1)
+  offsets: new r.Array(
+    new r.Pointer(
+      /** @type {BaseType} */ (Offset),
+      'void',
+      {
+        /** @param {StructValue} ctx @returns {number} */
+        relativeTo: ctx => /** @type {number} */ (ctx.offsetToData),
+        allowNull: false
+      }
+    ),
+    /** @param {StructValue} t @returns {number} */
+    t => /** @type {number} */ (t.glyphCount) + 1
+  )
 });
 
 export default gvar;

package/src/tables/hdmx.js

@@ -1,12 +1,23 @@
 import * as r from 'restructure';
 
+/** @typedef {import('restructure').StructValue} StructValue */
+
 let DeviceRecord = new r.Struct({
   pixelSize: r.uint8,
   maximumWidth: r.uint8,
-  widths: new r.Array(r.uint8, t => t.parent.parent.maxp.numGlyphs)
+  widths: new r.Array(
+    r.uint8,
+    /** @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);
+    }
+  )
 });
 
 // The Horizontal Device Metrics table stores integer advance widths scaled to particular pixel sizes
+/** @type {import('restructure').Struct} */
 export default new r.Struct({
   version: r.uint16,
   numRecords: r.int16,

package/src/tables/head.js

@@ -1,6 +1,7 @@
 import * as r from 'restructure';
 
 // font header
+/** @type {import('restructure').Struct} */
 export default new r.Struct({
   version: r.int32, // 0x00010000 (version 1.0)
   revision: r.int32, // set by font manufacturer

package/src/tables/hhea.js

@@ -1,6 +1,7 @@
 import * as r from 'restructure';
 
 // horizontal header
+/** @type {import('restructure').Struct} */
 export default new r.Struct({
   version: r.int32,
   ascent: r.int16, // Distance from baseline of highest ascender

package/src/tables/hmtx.js

@@ -1,11 +1,27 @@
 import * as r from 'restructure';
 
+/** @typedef {import('restructure').StructValue} StructValue */
+
 let HmtxEntry = new r.Struct({
   advance: r.uint16,
   bearing: r.int16
 });
 
+/** @type {import('restructure').Struct} */
 export default new r.Struct({
-  metrics: new r.LazyArray(HmtxEntry, t => t.parent.hhea.numberOfMetrics),
-  bearings: new r.LazyArray(r.int16, t => t.parent.maxp.numGlyphs - t.parent.hhea.numberOfMetrics)
+  metrics: new r.LazyArray(
+    HmtxEntry,
+    /** @param {StructValue} t @returns {number} */
+    t => /** @type {number} */ (/** @type {StructValue} */ (/** @type {StructValue} */ (t.parent).hhea).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 hhea = /** @type {StructValue} */ (parent.hhea);
+      return /** @type {number} */ (maxp.numGlyphs) - /** @type {number} */ (hhea.numberOfMetrics);
+    }
+  )
 });

package/src/tables/index.js

@@ -1,3 +1,4 @@
+/** @type {Record<string, import('../../types/fontkit').TableCodec>} */
 let tables = {};
 export default tables;
 

package/src/tables/just.js

@@ -1,11 +1,13 @@
 import * as r from 'restructure';
 import { LookupTable, StateTable1 } from './aat';
 
+/** @typedef {import('restructure').StructValue} StructValue */
+
 let ClassTable = new r.Struct({
   length: r.uint16,
   coverage: r.uint16,
   subFeatureFlags: r.uint32,
-  stateTable: new StateTable1()
+  stateTable: StateTable1()
 });
 
 let WidthDeltaRecord = new r.Struct({
@@ -58,21 +60,30 @@ let Action = new r.Struct({
   actionType: r.uint16,
   actionLength: r.uint32,
   actionData: ActionData,
-  padding: new r.Reserved(r.uint8, t => t.actionLength - t._currentOffset)
+  padding: new r.Reserved(
+    r.uint8,
+    /** @param {StructValue} t @returns {number} */
+    t => /** @type {number} */ (t.actionLength) - /** @type {number} */ (t._currentOffset)
+  )
 });
 
 let PostcompensationAction = new r.Array(Action, r.uint32);
 let PostCompensationTable = new r.Struct({
-  lookupTable: new LookupTable(new r.Pointer(r.uint16, PostcompensationAction))
+  lookupTable: LookupTable(new r.Pointer(r.uint16, PostcompensationAction))
 });
 
 let JustificationTable = new r.Struct({
   classTable: new r.Pointer(r.uint16, ClassTable, { type: 'parent' }),
   wdcOffset: r.uint16,
   postCompensationTable: new r.Pointer(r.uint16, PostCompensationTable, { type: 'parent' }),
-  widthDeltaClusters: new LookupTable(new r.Pointer(r.uint16, WidthDeltaCluster, { type: 'parent', relativeTo: ctx => ctx.wdcOffset }))
+  widthDeltaClusters: LookupTable(new r.Pointer(r.uint16, WidthDeltaCluster, {
+    type: 'parent',
+    /** @param {StructValue} ctx @returns {number} */
+    relativeTo: ctx => /** @type {number} */ (ctx.wdcOffset)
+  }))
 });
 
+/** @type {import('restructure').Struct} */
 export default new r.Struct({
   version: r.uint32,
   format: r.uint16,

package/src/tables/kern.js

@@ -1,5 +1,7 @@
 import * as r from 'restructure';
 
+/** @typedef {import('restructure').StructValue} StructValue */
+
 let KernPair = new r.Struct({
   left: r.uint16,
   right: r.uint16,
@@ -10,12 +12,34 @@ let ClassTable = new r.Struct({
   firstGlyph: r.uint16,
   nGlyphs: r.uint16,
   offsets: new r.Array(r.uint16, 'nGlyphs'),
-  max: t => t.offsets.length && Math.max.apply(Math, t.offsets)
+  /**
+   * @param {StructValue} t
+   * @returns {number}
+   */
+  max: (t) => {
+    let offsets = /** @type {number[]} */ (t.offsets);
+    return offsets.length ? Math.max.apply(Math, offsets) : 0;
+  }
 });
 
 let Kern2Array = new r.Struct({
-  off: t => t._startOffset - t.parent.parent._startOffset,
-  len: t => (((t.parent.leftTable.max - t.off) / t.parent.rowWidth) + 1) * (t.parent.rowWidth / 2),
+  /**
+   * @param {StructValue} t
+   * @returns {number}
+   */
+  off: t => /** @type {number} */ (t._startOffset)
+    - /** @type {number} */ (/** @type {StructValue} */ (/** @type {StructValue} */ (t.parent).parent)._startOffset),
+  /**
+   * @param {StructValue} t
+   * @returns {number}
+   */
+  len: (t) => {
+    let parent = /** @type {StructValue} */ (t.parent);
+    let leftTable = /** @type {StructValue} */ (parent.leftTable);
+    let rowWidth = /** @type {number} */ (parent.rowWidth);
+    let off = /** @type {number} */ (t.off);
+    return (((/** @type {number} */ (leftTable.max) - off) / rowWidth) + 1) * (rowWidth / 2);
+  },
   values: new r.LazyArray(r.int16, 'len')
 });
 
@@ -44,7 +68,11 @@ let KernSubtable = new r.VersionedStruct('format', {
     kernValue: new r.Array(r.int16, 'kernValueCount'),
     leftClass: new r.Array(r.uint8, 'glyphCount'),
     rightClass: new r.Array(r.uint8, 'glyphCount'),
-    kernIndex: new r.Array(r.uint8, t => t.leftClassCount * t.rightClassCount)
+    kernIndex: new r.Array(
+      r.uint8,
+      /** @param {StructValue} t @returns {number} */
+      t => /** @type {number} */ (t.leftClassCount) * /** @type {number} */ (t.rightClassCount)
+    )
   }
 });
 
@@ -60,7 +88,11 @@ let KernTable = new r.VersionedStruct('version', {
       'override' // If set to 1 the value in this table replaces the accumulated value
     ]),
     subtable: KernSubtable,
-    padding: new r.Reserved(r.uint8, t => t.length - t._currentOffset)
+    padding: new r.Reserved(
+      r.uint8,
+      /** @param {StructValue} t @returns {number} */
+      t => /** @type {number} */ (t.length) - /** @type {number} */ (t._currentOffset)
+    )
   },
   1: { // Apple uses this format
     length: r.uint32,
@@ -73,10 +105,15 @@ let KernTable = new r.VersionedStruct('version', {
     format: r.uint8,
     tupleIndex: r.uint16,
     subtable: KernSubtable,
-    padding: new r.Reserved(r.uint8, t => t.length - t._currentOffset)
+    padding: new r.Reserved(
+      r.uint8,
+      /** @param {StructValue} t @returns {number} */
+      t => /** @type {number} */ (t.length) - /** @type {number} */ (t._currentOffset)
+    )
   }
 });
 
+/** @type {import('restructure').VersionedStruct} */
 export default new r.VersionedStruct(r.uint16, {
   0: { // Microsoft Version
     nTables: r.uint16,

package/src/tables/loca.js

@@ -1,5 +1,16 @@
 import * as r from 'restructure';
 
+/** @typedef {import('restructure').StructValue} StructValue */
+
+/**
+ * @typedef {StructValue & {
+ *   version: number,
+ *   offsets: number[],
+ *   _processed?: boolean
+ * }} LocaValue
+ */
+
+/** @type {import('restructure').VersionedStruct} */
 let loca = new r.VersionedStruct('head.indexToLocFormat', {
   0: {
     offsets: new r.Array(r.uint16)
@@ -10,20 +21,22 @@ let loca = new r.VersionedStruct('head.indexToLocFormat', {
 });
 
 loca.process = function () {
-  if (this.version === 0 && !this._processed) {
-    for (let i = 0; i < this.offsets.length; i++) {
-      this.offsets[i] <<= 1;
+  let self = /** @type {LocaValue} */ (this);
+  if (self.version === 0 && !self._processed) {
+    for (let i = 0; i < self.offsets.length; i++) {
+      self.offsets[i] <<= 1;
     }
-    this._processed = true;
+    self._processed = true;
   }
 };
 
 loca.preEncode = function () {
-  if (this.version === 0 && this._processed !== false) {
-    for (let i = 0; i < this.offsets.length; i++) {
-      this.offsets[i] >>>= 1;
+  let self = /** @type {LocaValue} */ (this);
+  if (self.version === 0 && self._processed !== false) {
+    for (let i = 0; i < self.offsets.length; i++) {
+      self.offsets[i] >>>= 1;
     }
-    this._processed = false;
+    self._processed = false;
   }
 };
 

package/src/tables/maxp.js

@@ -1,6 +1,7 @@
 import * as r from 'restructure';
 
 // maxiumum profile
+/** @type {import('restructure').Struct} */
 export default new r.Struct({
   version: r.int32,
   numGlyphs: r.uint16, // The number of glyphs in the font

package/src/tables/morx.js

@@ -1,6 +1,8 @@
 import * as r from 'restructure';
 import { UnboundedArray, LookupTable, StateTable } from './aat';
 
+/** @typedef {import('restructure').StructValue} StructValue */
+
 let LigatureData = {
   action: r.uint16
 };
@@ -16,32 +18,32 @@ let InsertionData = {
 };
 
 let SubstitutionTable = new r.Struct({
-  items: new UnboundedArray(new r.Pointer(r.uint32, new LookupTable()))
+  items: new UnboundedArray(new r.Pointer(r.uint32, LookupTable()))
 });
 
 let SubtableData = new r.VersionedStruct('type', {
   0: { // Indic Rearrangement Subtable
-    stateTable: new StateTable()
+    stateTable: StateTable()
   },
 
   1: { // Contextual Glyph Substitution Subtable
-    stateTable: new StateTable(ContextualData),
+    stateTable: StateTable(ContextualData),
     substitutionTable: new r.Pointer(r.uint32, SubstitutionTable)
   },
 
   2: { // Ligature subtable
-    stateTable: new StateTable(LigatureData),
+    stateTable: StateTable(LigatureData),
     ligatureActions: new r.Pointer(r.uint32, new UnboundedArray(r.uint32)),
     components: new r.Pointer(r.uint32, new UnboundedArray(r.uint16)),
     ligatureList: new r.Pointer(r.uint32, new UnboundedArray(r.uint16))
   },
 
   4: { // Non-contextual Glyph Substitution Subtable
-    lookupTable: new LookupTable()
+    lookupTable: LookupTable()
   },
 
   5: { // Glyph Insertion Subtable
-    stateTable: new StateTable(InsertionData),
+    stateTable: StateTable(InsertionData),
     insertionActions: new r.Pointer(r.uint32, new UnboundedArray(r.uint16))
   }
 });
@@ -52,7 +54,11 @@ let Subtable = new r.Struct({
   type: r.uint8,
   subFeatureFlags: r.uint32,
   table: SubtableData,
-  padding: new r.Reserved(r.uint8, t => t.length - t._currentOffset)
+  padding: new r.Reserved(
+    r.uint8,
+    /** @param {StructValue} t @returns {number} */
+    t => /** @type {number} */ (t.length) - /** @type {number} */ (t._currentOffset)
+  )
 });
 
 let FeatureEntry = new r.Struct({
@@ -71,6 +77,7 @@ let MorxChain = new r.Struct({
   subtables: new r.Array(Subtable, 'nSubtables')
 });
 
+/** @type {import('restructure').Struct} */
 export default new r.Struct({
   version: r.uint16,
   unused: new r.Reserved(r.uint16),