@cantoo/fontkit 2.0.5 → 2.0.7

package/src/tables/EBDT.js

@@ -1,5 +1,8 @@
 import * as r from 'restructure';
 
+/** @typedef {import('restructure').BaseType} BaseType */
+
+/** @type {import('restructure').Struct} */
 export let BigMetrics = new r.Struct({
   height: r.uint8,
   width: r.uint8,
@@ -11,6 +14,7 @@ export let BigMetrics = new r.Struct({
   vertAdvance: r.uint8
 });
 
+/** @type {import('restructure').Struct} */
 export let SmallMetrics = new r.Struct({
   height: r.uint8,
   width: r.uint8,
@@ -25,10 +29,13 @@ let EBDTComponent = new r.Struct({
   yOffset: r.int8
 });
 
-class ByteAligned {}
-
-class BitAligned {}
+/** Marker codecs for bitmap payload layout (decoded by glyph consumers). */
+/** @type {BaseType} */
+const ByteAligned = {};
+/** @type {BaseType} */
+const BitAligned = {};
 
+/** @type {import('restructure').VersionedStruct} */
 export let glyph = new r.VersionedStruct('version', {
   1: {
     metrics: SmallMetrics,

package/src/tables/EBLC.js

@@ -1,6 +1,8 @@
 import * as r from 'restructure';
 import { BigMetrics } from './EBDT';
 
+/** @typedef {import('restructure').StructValue} StructValue */
+
 let SBitLineMetrics = new r.Struct({
   ascender: r.int8,
   descender: r.int8,
@@ -20,6 +22,17 @@ let CodeOffsetPair = new r.Struct({
   offset: r.uint16
 });
 
+/**
+ * Spec: numOffsets = lastGlyphIndex - firstGlyphIndex + 2 (extra sentinel for last glyph size).
+ * @param {StructValue} t
+ * @returns {number}
+ */
+function glyphRangeOffsetCount(t) {
+  let parent = /** @type {StructValue} */ (t.parent);
+  return /** @type {number} */ (parent.lastGlyphIndex)
+    - /** @type {number} */ (parent.firstGlyphIndex) + 2;
+}
+
 let IndexSubtable = new r.VersionedStruct(r.uint16, {
   header: {
     imageFormat: r.uint16,
@@ -27,7 +40,7 @@ let IndexSubtable = new r.VersionedStruct(r.uint16, {
   },
 
   1: {
-    offsetArray: new r.Array(r.uint32, t => t.parent.lastGlyphIndex - t.parent.firstGlyphIndex + 1)
+    offsetArray: new r.Array(r.uint32, glyphRangeOffsetCount)
   },
 
   2: {
@@ -36,30 +49,67 @@ let IndexSubtable = new r.VersionedStruct(r.uint16, {
   },
 
   3: {
-    offsetArray: new r.Array(r.uint16, t => t.parent.lastGlyphIndex - t.parent.firstGlyphIndex + 1)
+    offsetArray: new r.Array(r.uint16, glyphRangeOffsetCount),
+    // Format 3 pads to 32-bit alignment when the offset count is odd.
+    pad: new r.Reserved(
+      r.uint16,
+      /** @param {StructValue} t @returns {number} */
+      t => glyphRangeOffsetCount(t) % 2
+    )
   },
 
   4: {
     numGlyphs: r.uint32,
-    glyphArray: new r.Array(CodeOffsetPair, t => t.numGlyphs + 1)
+    glyphArray: new r.Array(
+      CodeOffsetPair,
+      /** @param {StructValue} t @returns {number} */
+      t => /** @type {number} */ (t.numGlyphs) + 1
+    )
   },
 
   5: {
     imageSize: r.uint32,
     bigMetrics: BigMetrics,
     numGlyphs: r.uint32,
-    glyphCodeArray: new r.Array(r.uint16, 'numGlyphs')
+    glyphCodeArray: new r.Array(r.uint16, 'numGlyphs'),
+    // Format 5 pads to 32-bit alignment when glyphCodeArray length is odd.
+    pad: new r.Reserved(
+      r.uint16,
+      /** @param {StructValue} t @returns {number} */
+      t => /** @type {number} */ (t.numGlyphs) % 2
+    )
   }
 });
 
-let IndexSubtableArray = new r.Struct({
+let IndexSubtableRecord = new r.Struct({
   firstGlyphIndex: r.uint16,
   lastGlyphIndex: r.uint16,
-  subtable: new r.Pointer(r.uint32, IndexSubtable)
+  // Offset from the start of IndexSubTableList (OpenType IndexSubTableArray).
+  subtable: new r.Pointer(r.uint32, IndexSubtable, { type: 'parent' })
+});
+
+/**
+ * Wrapper so record pointers resolve relative to the list start.
+ * process() on BitmapSizeTable unwraps `.tables` so the public shape stays an array.
+ */
+let IndexSubTableList = new r.Struct({
+  tables: new r.Array(
+    IndexSubtableRecord,
+    /** @param {StructValue} t @returns {number} */
+    t => /** @type {number} */ (/** @type {StructValue} */ (t.parent).numberOfIndexSubTables)
+  )
 });
 
+/**
+ * @typedef {StructValue & {
+ *   indexSubTableArray: { tables: StructValue[] } | StructValue[],
+ *   numberOfIndexSubTables: number
+ * }} BitmapSizeTableValue
+ */
+
 let BitmapSizeTable = new r.Struct({
-  indexSubTableArray: new r.Pointer(r.uint32, new r.Array(IndexSubtableArray, 1), { type: 'parent' }),
+  // Lazy: numberOfIndexSubTables is stored after this pointer in the binary layout.
+  indexSubTableArray: new r.Pointer(r.uint32, IndexSubTableList, { type: 'parent', lazy: true }),
   indexTablesSize: r.uint32,
   numberOfIndexSubTables: r.uint32,
   colorRef: r.uint32,
@@ -73,6 +123,16 @@ let BitmapSizeTable = new r.Struct({
   flags: new r.Bitfield(r.uint8, ['horizontal', 'vertical'])
 });
 
+BitmapSizeTable.process = function () {
+  let self = /** @type {BitmapSizeTableValue} */ (this);
+  // Access forces lazy decode now that numberOfIndexSubTables is available.
+  let list = self.indexSubTableArray;
+  if (list && !Array.isArray(list) && Array.isArray(list.tables)) {
+    self.indexSubTableArray = list.tables;
+  }
+};
+
+/** @type {import('restructure').Struct} */
 export default new r.Struct({
   version: r.uint32, // 0x00020000
   numSizes: r.uint32,

package/src/tables/GDEF.js

@@ -38,6 +38,7 @@ let MarkGlyphSetsDef = new r.Struct({
   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),

package/src/tables/GPOS.js

@@ -2,6 +2,12 @@ import * as r from 'restructure';
 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',
   'xAdvance', 'yAdvance',
@@ -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 })
+  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,12 +83,25 @@ 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;
   }
@@ -102,13 +152,24 @@ let MarkRecord = new r.Struct({
 
 let MarkArray = new r.Array(MarkRecord, r.uint16);
 
-let BaseRecord = new r.Array(new r.Pointer(r.uint16, Anchor), t => t.parent.classCount);
+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), t => t.parent.parent.classCount);
+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
@@ -190,13 +251,15 @@ let GPOSLookup = new r.VersionedStruct('lookupType', {
 });
 
 // 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))
+    lookupList: new r.Pointer(r.uint16, LookupList(GPOSLookup))
   },
 
   0x00010000: {},

package/src/tables/GSUB.js

@@ -2,17 +2,26 @@ import * as r from 'restructure';
 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)
+  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: {
@@ -69,13 +78,15 @@ let GSUBLookup = new r.VersionedStruct('lookupType', {
 });
 
 // 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))
+    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,

package/src/tables/JSTF.js

@@ -9,12 +9,12 @@ let JstfPriority = new r.Struct({
   shrinkageDisableGSUB: new r.Pointer(r.uint16, JstfGSUBModList),
   shrinkageEnableGPOS: new r.Pointer(r.uint16, JstfGSUBModList),
   shrinkageDisableGPOS: new r.Pointer(r.uint16, JstfGSUBModList),
-  shrinkageJstfMax: new r.Pointer(r.uint16, new LookupList(GPOSLookup)),
+  shrinkageJstfMax: new r.Pointer(r.uint16, LookupList(GPOSLookup)),
   extensionEnableGSUB: new r.Pointer(r.uint16, JstfGSUBModList),
   extensionDisableGSUB: new r.Pointer(r.uint16, JstfGSUBModList),
   extensionEnableGPOS: new r.Pointer(r.uint16, JstfGSUBModList),
   extensionDisableGPOS: new r.Pointer(r.uint16, JstfGSUBModList),
-  extensionJstfMax: new r.Pointer(r.uint16, new LookupList(GPOSLookup))
+  extensionJstfMax: new r.Pointer(r.uint16, LookupList(GPOSLookup))
 });
 
 let JstfLangSys = new r.Array(new r.Pointer(r.uint16, JstfPriority), r.uint16);
@@ -36,6 +36,7 @@ let JstfScriptRecord = new r.Struct({
   script: new r.Pointer(r.uint16, JstfScript, { type: 'parent' })
 });
 
+/** @type {import('restructure').Struct} */
 export default new r.Struct({
   version: r.uint32, // should be 0x00010000
   scriptCount: r.uint16,

package/src/tables/LTSH.js

@@ -3,6 +3,7 @@ import * as r from 'restructure';
 // Linear Threshold table
 // Records the ppem for each glyph at which the scaling becomes linear again,
 // despite instructions effecting the advance width
+/** @type {import('restructure').Struct} */
 export default new r.Struct({
   version: r.uint16,
   numGlyphs: r.uint16,

package/src/tables/OS2.js

@@ -1,5 +1,6 @@
 import * as r from 'restructure';
 
+/** @type {import('restructure').VersionedStruct} */
 var OS2 = new r.VersionedStruct(r.uint16, {
   header: {
     xAvgCharWidth: r.int16, // average weighted advance width of lower case letters and space

package/src/tables/PCLT.js

@@ -2,6 +2,7 @@ import * as r from 'restructure';
 
 // PCL 5 Table
 // NOTE: The PCLT table is strongly discouraged for OpenType fonts with TrueType outlines
+/** @type {import('restructure').Struct} */
 export default new r.Struct({
   version: r.uint16,
   fontNumber: r.uint32,

package/src/tables/STAT.js

@@ -1,5 +1,10 @@
 import * as r from 'restructure';
 
+/** @typedef {import('restructure').BaseType} BaseType */
+/** @typedef {import('restructure').DecodeStream} DecodeStream */
+/** @typedef {import('restructure').EncodeStream} EncodeStream */
+/** @typedef {import('restructure').StructValue} StructValue */
+
 let AxisRecord = new r.Struct({
   axisTag: new r.String(4),
   axisNameID: r.uint16,
@@ -41,19 +46,40 @@ let AxisValue = new r.VersionedStruct(r.uint16, {
 });
 
 let AxisValueArray = new r.Struct({
-  axisValues: new r.Array(new r.Pointer(r.uint16, AxisValue), t => t.parent.axisValueCount)
+  axisValues: new r.Array(
+    new r.Pointer(r.uint16, AxisValue),
+    /** @param {StructValue} t @returns {number} */
+    t => /** @type {number} */ (/** @type {StructValue} */ (t.parent).axisValueCount)
+  )
 });
 
-// Use designAxisSize as record stride (OpenType forward-compat).
+/**
+ * Design-axis array whose record stride is designAxisSize (OpenType forward-compat).
+ * @implements {BaseType}
+ */
 class DesignAxisArray {
+  /**
+   * @param {StructValue | null | undefined} parent
+   * @returns {number}
+   */
   _stride(parent) {
     // Spec requires room for Tag + 2×uint16 (8 bytes); never shrink below that.
-    return Math.max(8, parent.designAxisSize ?? parent.val?.designAxisSize ?? 8);
+    let fromParent = parent ? /** @type {number | undefined} */ (parent.designAxisSize) : undefined;
+    let fromVal = parent && parent.val
+      ? /** @type {number | undefined} */ (/** @type {StructValue} */ (parent.val).designAxisSize)
+      : undefined;
+    return Math.max(8, fromParent ?? fromVal ?? 8);
   }
 
+  /**
+   * @param {DecodeStream} stream
+   * @param {StructValue | null | undefined} parent
+   * @returns {StructValue[]}
+   */
   decode(stream, parent) {
-    let count = parent.designAxisCount;
+    let count = parent ? /** @type {number} */ (parent.designAxisCount) : 0;
     let size = this._stride(parent);
+    /** @type {StructValue[]} */
     let res = [];
     for (let i = 0; i < count; i++) {
       let start = stream.pos;
@@ -63,13 +89,26 @@ class DesignAxisArray {
     return res;
   }
 
+  /**
+   * @param {unknown} array
+   * @param {StructValue | null | undefined} parent
+   * @returns {number}
+   */
   size(array, parent) {
-    return (array?.length ?? 0) * this._stride(parent);
+    let len = Array.isArray(array) ? array.length : 0;
+    return len * this._stride(parent);
   }
 
+  /**
+   * @param {EncodeStream} stream
+   * @param {unknown} array
+   * @param {StructValue | null | undefined} parent
+   * @returns {void}
+   */
   encode(stream, array, parent) {
     let size = this._stride(parent);
-    for (let item of array) {
+    let items = Array.isArray(array) ? /** @type {StructValue[]} */ (array) : [];
+    for (let item of items) {
       let start = stream.pos;
       AxisRecord.encode(stream, item, parent);
       let pad = size - (stream.pos - start);
@@ -80,6 +119,7 @@ class DesignAxisArray {
   }
 }
 
+/** @type {import('restructure').VersionedStruct} */
 export default new r.VersionedStruct(r.uint32, {
   header: {
     designAxisSize: r.uint16,

package/src/tables/VDMX.js

@@ -23,6 +23,7 @@ let VdmxGroup = new r.Struct({
   entries: new r.Array(vTable, 'recs') // The VDMX records
 });
 
+/** @type {import('restructure').Struct} */
 export default new r.Struct({
   version: r.uint16, // Version number (0 or 1)
   numRecs: r.uint16, // Number of VDMX groups present

package/src/tables/VORG.js

@@ -5,6 +5,7 @@ let VerticalOrigin = new r.Struct({
   vertOriginY: r.int16
 });
 
+/** @type {import('restructure').Struct} */
 export default new r.Struct({
   majorVersion: r.uint16,
   minorVersion: r.uint16,