@cantoo/fontkit 2.0.4 → 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

@@ -1,15 +1,16 @@
 import * as r from 'restructure';
 
 let GaspRange = new r.Struct({
-  rangeMaxPPEM:       r.uint16,                  // Upper limit of range, in ppem
-  rangeGaspBehavior:  new r.Bitfield(r.uint16, [ // Flags describing desired rasterizer behavior
+  rangeMaxPPEM: r.uint16, // Upper limit of range, in ppem
+  rangeGaspBehavior: new r.Bitfield(r.uint16, [ // Flags describing desired rasterizer behavior
     'grayscale', 'gridfit',
-    'symmetricSmoothing', 'symmetricGridfit'     // only in version 1, for ClearType
+    'symmetricSmoothing', 'symmetricGridfit' // only in version 1, for ClearType
   ])
 });
 
+/** @type {import('restructure').Struct} */
 export default new r.Struct({
-  version:    r.uint16,  // set to 0
-  numRanges:  r.uint16,
+  version: r.uint16, // set to 0
+  numRanges: r.uint16,
   gaspRanges: new r.Array(GaspRange, 'numRanges') // Sorted by ppem
 });

package/src/tables/glyf.js

@@ -1,4 +1,5 @@
 import * as r from 'restructure';
 
 // only used for encoding
-export default new r.Array(new r.Buffer);
+/** @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,15 +1,26 @@
 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)
+  pixelSize: r.uint8,
+  maximumWidth: r.uint8,
+  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,
-  sizeDeviceRecord:   r.int32,
-  records:            new r.Array(DeviceRecord, 'numRecords')
+  version: r.uint16,
+  numRecords: r.int16,
+  sizeDeviceRecord: r.int32,
+  records: new r.Array(DeviceRecord, 'numRecords')
 });

package/src/tables/head.js

@@ -1,25 +1,26 @@
 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
+  version: r.int32, // 0x00010000 (version 1.0)
+  revision: r.int32, // set by font manufacturer
   checkSumAdjustment: r.uint32,
-  magicNumber:        r.uint32,                  // set to 0x5F0F3CF5
-  flags:              r.uint16,
-  unitsPerEm:         r.uint16,                  // range from 64 to 16384
-  created:            new r.Array(r.int32, 2),
-  modified:           new r.Array(r.int32, 2),
-  xMin:               r.int16,                   // for all glyph bounding boxes
-  yMin:               r.int16,                   // for all glyph bounding boxes
-  xMax:               r.int16,                   // for all glyph bounding boxes
-  yMax:               r.int16,                   // for all glyph bounding boxes
-  macStyle:           new r.Bitfield(r.uint16, [
+  magicNumber: r.uint32, // set to 0x5F0F3CF5
+  flags: r.uint16,
+  unitsPerEm: r.uint16, // range from 64 to 16384
+  created: new r.Array(r.int32, 2),
+  modified: new r.Array(r.int32, 2),
+  xMin: r.int16, // for all glyph bounding boxes
+  yMin: r.int16, // for all glyph bounding boxes
+  xMax: r.int16, // for all glyph bounding boxes
+  yMax: r.int16, // for all glyph bounding boxes
+  macStyle: new r.Bitfield(r.uint16, [
     'bold', 'italic', 'underline', 'outline',
     'shadow', 'condensed', 'extended'
   ]),
-  lowestRecPPEM:      r.uint16,                  // smallest readable size in pixels
-  fontDirectionHint:  r.int16,
-  indexToLocFormat:   r.int16,                   // 0 for short offsets, 1 for long
-  glyphDataFormat:    r.int16                    // 0 for current format
+  lowestRecPPEM: r.uint16, // smallest readable size in pixels
+  fontDirectionHint: r.int16,
+  indexToLocFormat: r.int16, // 0 for short offsets, 1 for long
+  glyphDataFormat: r.int16 // 0 for current format
 });

package/src/tables/hhea.js

@@ -1,19 +1,20 @@
 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
-  descent:              r.int16,   // Distance from baseline of lowest descender
-  lineGap:              r.int16,   // Typographic line gap
-  advanceWidthMax:      r.uint16,  // Maximum advance width value in 'hmtx' table
-  minLeftSideBearing:   r.int16,   // Maximum advance width value in 'hmtx' table
-  minRightSideBearing:  r.int16,   // Minimum right sidebearing value
-  xMaxExtent:           r.int16,
-  caretSlopeRise:       r.int16,   // Used to calculate the slope of the cursor (rise/run); 1 for vertical
-  caretSlopeRun:        r.int16,   // 0 for vertical
-  caretOffset:          r.int16,   // Set to 0 for non-slanted fonts
-  reserved:             new r.Reserved(r.int16, 4),
-  metricDataFormat:     r.int16,   // 0 for current format
-  numberOfMetrics:      r.uint16   // Number of advance widths in 'hmtx' table
+  version: r.int32,
+  ascent: r.int16, // Distance from baseline of highest ascender
+  descent: r.int16, // Distance from baseline of lowest descender
+  lineGap: r.int16, // Typographic line gap
+  advanceWidthMax: r.uint16, // Maximum advance width value in 'hmtx' table
+  minLeftSideBearing: r.int16, // Maximum advance width value in 'hmtx' table
+  minRightSideBearing: r.int16, // Minimum right sidebearing value
+  xMaxExtent: r.int16,
+  caretSlopeRise: r.int16, // Used to calculate the slope of the cursor (rise/run); 1 for vertical
+  caretSlopeRun: r.int16, // 0 for vertical
+  caretOffset: r.int16, // Set to 0 for non-slanted fonts
+  reserved: new r.Reserved(r.int16, 4),
+  metricDataFormat: r.int16, // 0 for current format
+  numberOfMetrics: r.uint16 // Number of advance widths in 'hmtx' table
 });

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;
 
@@ -20,7 +21,6 @@ tables.name = name;
 tables['OS/2'] = OS2;
 tables.post = post;
 
-
 // TrueType Outlines
 import cvt from './cvt';
 import fpgm from './fpgm';
@@ -34,7 +34,6 @@ tables.prep = prep;
 tables['cvt '] = cvt;
 tables.glyf = glyf;
 
-
 // PostScript Outlines
 import CFFFont from '../cff/CFFFont';
 import VORG from './VORG';
@@ -43,7 +42,6 @@ tables['CFF '] = CFFFont;
 tables['CFF2'] = CFFFont;
 tables.VORG = VORG;
 
-
 // Bitmap Glyphs
 import EBLC from './EBLC';
 import sbix from './sbix';
@@ -56,7 +54,6 @@ tables.sbix = sbix;
 tables.COLR = COLR;
 tables.CPAL = CPAL;
 
-
 // Advanced OpenType Tables
 import BASE from './BASE';
 import GDEF from './GDEF';
@@ -98,7 +95,6 @@ tables.VDMX = VDMX;
 tables.vhea = vhea;
 tables.vmtx = vmtx;
 
-
 // Apple Advanced Typography Tables
 import avar from './avar';
 import bsln from './bsln';

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,91 +1,128 @@
 import * as r from 'restructure';
 
+/** @typedef {import('restructure').StructValue} StructValue */
+
 let KernPair = new r.Struct({
-  left:   r.uint16,
-  right:  r.uint16,
-  value:  r.int16
+  left: r.uint16,
+  right: r.uint16,
+  value: r.int16
 });
 
 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')
 });
 
 let KernSubtable = new r.VersionedStruct('format', {
   0: {
-    nPairs:         r.uint16,
-    searchRange:    r.uint16,
-    entrySelector:  r.uint16,
-    rangeShift:     r.uint16,
-    pairs:          new r.Array(KernPair, 'nPairs')
+    nPairs: r.uint16,
+    searchRange: r.uint16,
+    entrySelector: r.uint16,
+    rangeShift: r.uint16,
+    pairs: new r.Array(KernPair, 'nPairs')
   },
 
   2: {
-    rowWidth:   r.uint16,
-    leftTable:  new r.Pointer(r.uint16, ClassTable, {type: 'parent'}),
-    rightTable: new r.Pointer(r.uint16, ClassTable, {type: 'parent'}),
-    array:      new r.Pointer(r.uint16, Kern2Array, {type: 'parent'})
+    rowWidth: r.uint16,
+    leftTable: new r.Pointer(r.uint16, ClassTable, { type: 'parent' }),
+    rightTable: new r.Pointer(r.uint16, ClassTable, { type: 'parent' }),
+    array: new r.Pointer(r.uint16, Kern2Array, { type: 'parent' })
   },
 
   3: {
-    glyphCount:       r.uint16,
-    kernValueCount:   r.uint8,
-    leftClassCount:   r.uint8,
-    rightClassCount:  r.uint8,
-    flags:            r.uint8,
-    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)
+    glyphCount: r.uint16,
+    kernValueCount: r.uint8,
+    leftClassCount: r.uint8,
+    rightClassCount: r.uint8,
+    flags: r.uint8,
+    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,
+      /** @param {StructValue} t @returns {number} */
+      t => /** @type {number} */ (t.leftClassCount) * /** @type {number} */ (t.rightClassCount)
+    )
   }
 });
 
 let KernTable = new r.VersionedStruct('version', {
   0: { // Microsoft uses this format
-    subVersion: r.uint16,  // Microsoft has an extra sub-table version number
-    length:     r.uint16,  // Length of the subtable, in bytes
-    format:     r.uint8,   // Format of subtable
-    coverage:   new r.Bitfield(r.uint8, [
-      'horizontal',    // 1 if table has horizontal data, 0 if vertical
-      'minimum',       // If set to 1, the table has minimum values. If set to 0, the table has kerning values.
-      'crossStream',   // If set to 1, kerning is perpendicular to the flow of the text
-      'override'      // If set to 1 the value in this table replaces the accumulated value
+    subVersion: r.uint16, // Microsoft has an extra sub-table version number
+    length: r.uint16, // Length of the subtable, in bytes
+    format: r.uint8, // Format of subtable
+    coverage: new r.Bitfield(r.uint8, [
+      'horizontal', // 1 if table has horizontal data, 0 if vertical
+      'minimum', // If set to 1, the table has minimum values. If set to 0, the table has kerning values.
+      'crossStream', // If set to 1, kerning is perpendicular to the flow of the text
+      '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)
+    subtable: KernSubtable,
+    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,
-    coverage:   new r.Bitfield(r.uint8, [
+    length: r.uint32,
+    coverage: new r.Bitfield(r.uint8, [
       null, null, null, null, null,
-      'variation',     // Set if table has variation kerning values
-      'crossStream',   // Set if table has cross-stream kerning values
-      'vertical'      // Set if table has vertical kerning values
+      'variation', // Set if table has variation kerning values
+      'crossStream', // Set if table has cross-stream kerning values
+      'vertical' // Set if table has vertical kerning values
     ]),
-    format:     r.uint8,
+    format: r.uint8,
     tupleIndex: r.uint16,
-    subtable:   KernSubtable,
-    padding: new r.Reserved(r.uint8, t => t.length - t._currentOffset)
+    subtable: KernSubtable,
+    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,
-    tables:     new r.Array(KernTable, 'nTables')
+    nTables: r.uint16,
+    tables: new r.Array(KernTable, 'nTables')
   },
 
   1: { // Apple Version
-    reserved:   new r.Reserved(r.uint16), // the other half of the version number
-    nTables:    r.uint32,
-    tables:     new r.Array(KernTable, 'nTables')
+    reserved: new r.Reserved(r.uint16), // the other half of the version number
+    nTables: r.uint32,
+    tables: new r.Array(KernTable, 'nTables')
   }
 });

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)
@@ -9,21 +20,23 @@ 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;
+loca.process = function () {
+  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;
+loca.preEncode = function () {
+  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;
   }
 };