@cantoo/fontkit 2.0.4 → 2.0.6

package/src/subset/Subset.js

@@ -1,22 +1,37 @@
 import Tables from '../tables';
 
+/** @typedef {import('../../types/fontkit').SubsetFont} SubsetFont */
+/** @typedef {import('../../types/fontkit').SubsetGlyph} SubsetGlyph */
+/** @typedef {import('../../types/fontkit').TableCodec} TableCodec */
+
 // Tables written by TTFSubset.encode; must not be overwritten via includeTable.
 const MANAGED_TTF_TABLES = [
   'head', 'hhea', 'loca', 'maxp', 'cvt ', 'prep', 'glyf', 'hmtx', 'fpgm'
 ];
 
 export default class Subset {
+  /**
+   * @param {SubsetFont} font
+   */
   constructor(font) {
+    /** @type {SubsetFont} */
     this.font = font;
+    /** @type {number[]} */
     this.glyphs = [];
+    /** @type {Record<number, number>} */
     this.mapping = {};
     // Extra OT table tags to copy into a TTF subset (e.g. 'OS/2', 'name', 'post').
+    /** @type {string[]} */
     this.includedTables = [];
 
     // always include the missing glyph
     this.includeGlyph(0);
   }
 
+  /**
+   * @param {number | SubsetGlyph} glyph
+   * @returns {number}
+   */
   includeGlyph(glyph) {
     if (typeof glyph === 'object') {
       glyph = glyph.id;
@@ -32,11 +47,15 @@ export default class Subset {
 
   // Copy an OT table into the TTF subset (tag is a 4-byte string, e.g. 'OS/2').
   // Only honored by TTFSubset.encode; CFFSubset overrides this to throw.
+  /**
+   * @param {string} [tag]
+   * @returns {this}
+   */
   includeTable(tag) {
     if (typeof tag !== 'string' || tag.length !== 4) {
       throw new Error(
-        `Invalid OpenType table tag ${JSON.stringify(tag)}: tags must be 4 characters ` +
-        `(pad with spaces if needed, e.g. "cvt ").`
+        `Invalid OpenType table tag ${JSON.stringify(tag)}: tags must be 4 characters `
+        + `(pad with spaces if needed, e.g. "cvt ").`
       );
     }
 
@@ -50,7 +69,8 @@ export default class Subset {
       throw new Error(`Table "${tag}" is not present in this font.`);
     }
 
-    if (!Tables[tag]) {
+    let encoders = /** @type {Record<string, TableCodec | undefined>} */ (/** @type {unknown} */ (Tables));
+    if (!encoders[tag]) {
       throw new Error(`Table "${tag}" cannot be encoded (no encoder registered in fontkit).`);
     }
 

package/src/subset/TTFSubset.js

@@ -3,36 +3,88 @@ import Subset from './Subset';
 import Directory from '../tables/directory';
 import TTFGlyphEncoder from '../glyph/TTFGlyphEncoder';
 
+/** @typedef {import('../../types/fontkit').SubsetFont} SubsetFont */
+/** @typedef {import('../../types/fontkit').DecodedGlyf} DecodedGlyf */
+/** @typedef {import('restructure').BinaryBuffer} BinaryBuffer */
+/** @typedef {import('restructure').StructValue} StructValue */
+
+/**
+ * @typedef {{ advance: number, bearing: number }} HmtxMetric
+ */
+
 export default class TTFSubset extends Subset {
+  /** @type {TTFGlyphEncoder} */
+  glyphEncoder;
+  /** @type {Uint8Array[] | null} */
+  glyf = null;
+  /** @type {number} */
+  offset = 0;
+  /** @type {{ offsets: number[], version: number } | null} */
+  loca = null;
+  /** @type {{ metrics: HmtxMetric[], bearings: number[] } | null} */
+  hmtx = null;
+
+  /**
+   * @param {SubsetFont} font
+   */
   constructor(font) {
     super(font);
-    this.glyphEncoder = new TTFGlyphEncoder;
+    this.glyphEncoder = new TTFGlyphEncoder();
   }
 
+  /**
+   * @param {number} gid
+   * @returns {number}
+   */
   _addGlyph(gid) {
     let glyph = this.font.getGlyph(gid);
+    if (!glyph || !glyph._decode) {
+      throw new Error(`Cannot decode glyph ${gid}`);
+    }
     let glyf = glyph._decode();
 
+    if (!this.font.loca) {
+      throw new Error('Font missing loca table');
+    }
+
     // get the offset to the glyph from the loca table
     let curOffset = this.font.loca.offsets[gid];
     let nextOffset = this.font.loca.offsets[gid + 1];
 
     let stream = this.font._getTableStream('glyf');
+    if (!stream) {
+      throw new Error('Font missing glyf table');
+    }
     stream.pos += curOffset;
 
-    let buffer = stream.readBuffer(nextOffset - curOffset);
+    let raw = stream.readBuffer(nextOffset - curOffset);
+    /** @type {Uint8Array} */
+    let buffer = raw instanceof Uint8Array
+      ? raw
+      : Uint8Array.from(/** @type {Iterable<number>} */ (/** @type {unknown} */ (raw)));
 
     // if it is a compound glyph, include its components
     if (glyf && glyf.numberOfContours < 0) {
       buffer = new Uint8Array(buffer);
-      let view = new DataView(buffer.buffer);
-      for (let component of glyf.components) {
+      let ab = buffer.buffer instanceof ArrayBuffer ? buffer.buffer : new Uint8Array(buffer).buffer;
+      let view = new DataView(ab, buffer.byteOffset, buffer.byteLength);
+      for (let component of glyf.components || []) {
         gid = this.includeGlyph(component.glyphID);
         view.setUint16(component.pos, gid);
       }
     } else if (glyf && this.font._variationProcessor) {
       // If this is a TrueType variation glyph, re-encode the path
-      buffer = this.glyphEncoder.encodeSimple(glyph.path, glyf.instructions);
+      let encoded = this.glyphEncoder.encodeSimple(
+        /** @type {import('../glyph/Path').default} */ (/** @type {unknown} */ (glyph.path)),
+        glyf.instructions
+      );
+      buffer = encoded instanceof Uint8Array
+        ? encoded
+        : Uint8Array.from(/** @type {Iterable<number>} */ (/** @type {unknown} */ (encoded)));
+    }
+
+    if (!this.glyf || !this.loca || !this.hmtx) {
+      throw new Error('TTFSubset.encode must initialize glyf/loca/hmtx before _addGlyph');
     }
 
     this.glyf.push(buffer);
@@ -43,10 +95,13 @@ export default class TTFSubset extends Subset {
       bearing: glyph._getMetrics().leftBearing
     });
 
-    this.offset += buffer.length;
+    this.offset += buffer.byteLength;
     return this.glyf.length - 1;
   }
 
+  /**
+   * @returns {BinaryBuffer}
+   */
   encode() {
     // tables required by PDF spec:
     //   head, hhea, loca, maxp, cvt , prep, glyf, hmtx, fpgm
@@ -54,16 +109,17 @@ export default class TTFSubset extends Subset {
     // additional tables required for standalone fonts:
     //   name, cmap, OS/2, post
 
+    /** @type {Uint8Array[]} */
     this.glyf = [];
     this.offset = 0;
     this.loca = {
-      offsets: [],
-      version: this.font.loca.version
+      offsets: /** @type {number[]} */ ([]),
+      version: this.font.loca ? (this.font.loca.version ?? 0) : 0
     };
 
     this.hmtx = {
-      metrics: [],
-      bearings: []
+      metrics: /** @type {HmtxMetric[]} */ ([]),
+      bearings: /** @type {number[]} */ ([])
     };
 
     // include all the glyphs
@@ -75,41 +131,27 @@ export default class TTFSubset extends Subset {
     }
 
     let maxp = cloneDeep(this.font.maxp);
-    maxp.numGlyphs = this.glyf.length;
+    if (maxp && typeof maxp === 'object') {
+      /** @type {StructValue} */ (maxp).numGlyphs = this.glyf.length;
+    }
 
-    this.loca.offsets.push(this.offset);
+    let loca = this.loca;
+    loca.offsets.push(this.offset);
 
     let head = cloneDeep(this.font.head);
-    head.indexToLocFormat = this.loca.version;
+    if (head && typeof head === 'object') {
+      /** @type {StructValue} */ (head).indexToLocFormat = loca.version;
+    }
 
     let hhea = cloneDeep(this.font.hhea);
-    hhea.numberOfMetrics = this.hmtx.metrics.length;
-
-    // map = []
-    // for index in [0...256]
-    //     if index < @numGlyphs
-    //         map[index] = index
-    //     else
-    //         map[index] = 0
-    //
-    // cmapTable =
-    //     version: 0
-    //     length: 262
-    //     language: 0
-    //     codeMap: map
-    //
-    // cmap =
-    //     version: 0
-    //     numSubtables: 1
-    //     tables: [
-    //         platformID: 1
-    //         encodingID: 0
-    //         table: cmapTable
-    //     ]
+    if (hhea && typeof hhea === 'object') {
+      /** @type {StructValue} */ (hhea).numberOfMetrics = this.hmtx.metrics.length;
+    }
 
     // TODO: subset prep, cvt, fpgm?
     // The following is the minimum set of tables.
-    let t =  {
+    /** @type {Record<string, unknown>} */
+    let t = {
       head,
       hhea,
       loca: this.loca,
@@ -118,13 +160,14 @@ export default class TTFSubset extends Subset {
       prep: this.font.prep,
       glyf: this.glyf,
       hmtx: this.hmtx,
-      fpgm: this.font.fpgm,
-    }
+      fpgm: this.font.fpgm
+    };
 
+    let fontTables = /** @type {Record<string, unknown>} */ (/** @type {unknown} */ (this.font));
     for (const tag of this.includedTables) {
-      t[tag] = cloneDeep(this.font[tag]);
+      t[tag] = cloneDeep(fontTables[tag]);
     }
 
-    return Directory.toBuffer({tables: t});
+    return Directory.toBuffer({ tables: t });
   }
 }

package/src/tables/BASE.js

@@ -1,58 +1,58 @@
 import * as r from 'restructure';
-import {Device} from './opentype';
-import {ItemVariationStore} from './variations';
+import { Device } from './opentype';
+import { ItemVariationStore } from './variations';
 
 let BaseCoord = new r.VersionedStruct(r.uint16, {
   1: { // Design units only
-    coordinate:   r.int16 // X or Y value, in design units
+    coordinate: r.int16 // X or Y value, in design units
   },
 
   2: { // Design units plus contour point
-    coordinate:     r.int16,   // X or Y value, in design units
-    referenceGlyph: r.uint16,  // GlyphID of control glyph
-    baseCoordPoint: r.uint16   // Index of contour point on the referenceGlyph
+    coordinate: r.int16, // X or Y value, in design units
+    referenceGlyph: r.uint16, // GlyphID of control glyph
+    baseCoordPoint: r.uint16 // Index of contour point on the referenceGlyph
   },
 
   3: { // Design units plus Device table
-    coordinate:   r.int16,                         // X or Y value, in design units
-    deviceTable:  new r.Pointer(r.uint16, Device)  // Device table for X or Y value
+    coordinate: r.int16, // X or Y value, in design units
+    deviceTable: new r.Pointer(r.uint16, Device) // Device table for X or Y value
   }
 });
 
 let BaseValues = new r.Struct({
-  defaultIndex:   r.uint16,  // Index of default baseline for this script-same index in the BaseTagList
+  defaultIndex: r.uint16, // Index of default baseline for this script-same index in the BaseTagList
   baseCoordCount: r.uint16,
-  baseCoords:     new r.Array(new r.Pointer(r.uint16, BaseCoord), 'baseCoordCount')
+  baseCoords: new r.Array(new r.Pointer(r.uint16, BaseCoord), 'baseCoordCount')
 });
 
 let FeatMinMaxRecord = new r.Struct({
-  tag:        new r.String(4),  // 4-byte feature identification tag-must match FeatureTag in FeatureList
-  minCoord:   new r.Pointer(r.uint16, BaseCoord, {type: 'parent'}), // May be NULL
-  maxCoord:   new r.Pointer(r.uint16, BaseCoord, {type: 'parent'})  // May be NULL
+  tag: new r.String(4), // 4-byte feature identification tag-must match FeatureTag in FeatureList
+  minCoord: new r.Pointer(r.uint16, BaseCoord, { type: 'parent' }), // May be NULL
+  maxCoord: new r.Pointer(r.uint16, BaseCoord, { type: 'parent' }) // May be NULL
 });
 
 let MinMax = new r.Struct({
-  minCoord:           new r.Pointer(r.uint16, BaseCoord),  // May be NULL
-  maxCoord:           new r.Pointer(r.uint16, BaseCoord),  // May be NULL
-  featMinMaxCount:    r.uint16,                            // May be 0
-  featMinMaxRecords:  new r.Array(FeatMinMaxRecord, 'featMinMaxCount') // In alphabetical order
+  minCoord: new r.Pointer(r.uint16, BaseCoord), // May be NULL
+  maxCoord: new r.Pointer(r.uint16, BaseCoord), // May be NULL
+  featMinMaxCount: r.uint16, // May be 0
+  featMinMaxRecords: new r.Array(FeatMinMaxRecord, 'featMinMaxCount') // In alphabetical order
 });
 
 let BaseLangSysRecord = new r.Struct({
-  tag:    new r.String(4),  // 4-byte language system identification tag
-  minMax: new r.Pointer(r.uint16, MinMax, {type: 'parent'})
+  tag: new r.String(4), // 4-byte language system identification tag
+  minMax: new r.Pointer(r.uint16, MinMax, { type: 'parent' })
 });
 
 let BaseScript = new r.Struct({
-  baseValues:         new r.Pointer(r.uint16, BaseValues), // May be NULL
-  defaultMinMax:      new r.Pointer(r.uint16, MinMax),     // May be NULL
-  baseLangSysCount:   r.uint16,                            // May be 0
+  baseValues: new r.Pointer(r.uint16, BaseValues), // May be NULL
+  defaultMinMax: new r.Pointer(r.uint16, MinMax), // May be NULL
+  baseLangSysCount: r.uint16, // May be 0
   baseLangSysRecords: new r.Array(BaseLangSysRecord, 'baseLangSysCount') // in alphabetical order by BaseLangSysTag
 });
 
 let BaseScriptRecord = new r.Struct({
-  tag:      new r.String(4),  // 4-byte script identification tag
-  script:   new r.Pointer(r.uint16, BaseScript, {type: 'parent'})
+  tag: new r.String(4), // 4-byte script identification tag
+  script: new r.Pointer(r.uint16, BaseScript, { type: 'parent' })
 });
 
 let BaseScriptList = new r.Array(BaseScriptRecord, r.uint16);
@@ -61,14 +61,15 @@ let BaseScriptList = new r.Array(BaseScriptRecord, r.uint16);
 let BaseTagList = new r.Array(new r.String(4), r.uint16);
 
 let Axis = new r.Struct({
-  baseTagList:    new r.Pointer(r.uint16, BaseTagList),  // May be NULL
+  baseTagList: new r.Pointer(r.uint16, BaseTagList), // May be NULL
   baseScriptList: new r.Pointer(r.uint16, BaseScriptList)
 });
 
+/** @type {import('restructure').VersionedStruct} */
 export default new r.VersionedStruct(r.uint32, {
   header: {
-    horizAxis:    new r.Pointer(r.uint16, Axis),   // May be NULL
-    vertAxis:     new r.Pointer(r.uint16, Axis)    // May be NULL
+    horizAxis: new r.Pointer(r.uint16, Axis), // May be NULL
+    vertAxis: new r.Pointer(r.uint16, Axis) // May be NULL
   },
 
   0x00010000: {},

package/src/tables/COLR.js

@@ -1,21 +1,22 @@
 import * as r from 'restructure';
 
 let LayerRecord = new r.Struct({
-  gid: r.uint16,          // Glyph ID of layer glyph (must be in z-order from bottom to top).
-  paletteIndex: r.uint16  // Index value to use in the appropriate palette. This value must
-});                       // be less than numPaletteEntries in the CPAL table, except for
-                          // the special case noted below. Each palette entry is 16 bits.
-                          // A palette index of 0xFFFF is a special case indicating that
-                          // the text foreground color should be used.
+  gid: r.uint16, // Glyph ID of layer glyph (must be in z-order from bottom to top).
+  paletteIndex: r.uint16 // Index value to use in the appropriate palette. This value must
+}); // be less than numPaletteEntries in the CPAL table, except for
+// the special case noted below. Each palette entry is 16 bits.
+// A palette index of 0xFFFF is a special case indicating that
+// the text foreground color should be used.
 
 let BaseGlyphRecord = new r.Struct({
-  gid: r.uint16,             // Glyph ID of reference glyph. This glyph is for reference only
-                             // and is not rendered for color.
+  gid: r.uint16, // Glyph ID of reference glyph. This glyph is for reference only
+  // and is not rendered for color.
   firstLayerIndex: r.uint16, // Index (from beginning of the Layer Records) to the layer record.
-                             // There will be numLayers consecutive entries for this base glyph.
+  // There will be numLayers consecutive entries for this base glyph.
   numLayers: r.uint16
 });
 
+/** @type {import('restructure').Struct} */
 export default new r.Struct({
   version: r.uint16,
   numBaseGlyphRecords: r.uint16,

package/src/tables/CPAL.js

@@ -7,13 +7,14 @@ let ColorRecord = new r.Struct({
   alpha: r.uint8
 });
 
+/** @type {import('restructure').VersionedStruct} */
 export default new r.VersionedStruct(r.uint16, {
   header: {
     numPaletteEntries: r.uint16,
     numPalettes: r.uint16,
     numColorRecords: r.uint16,
     colorRecords: new r.Pointer(r.uint32, new r.Array(ColorRecord, 'numColorRecords')),
-    colorRecordIndices: new r.Array(r.uint16, 'numPalettes'),
+    colorRecordIndices: new r.Array(r.uint16, 'numPalettes')
   },
   0: {},
   1: {

package/src/tables/DSIG.js

@@ -7,15 +7,16 @@ let Signature = new r.Struct({
 });
 
 let SignatureBlock = new r.Struct({
-  reserved:       new r.Reserved(r.uint16, 2),
-  cbSignature:    r.uint32,  // Length (in bytes) of the PKCS#7 packet in pbSignature
-  signature:      new r.Buffer('cbSignature')
+  reserved: new r.Reserved(r.uint16, 2),
+  cbSignature: r.uint32, // Length (in bytes) of the PKCS#7 packet in pbSignature
+  signature: new r.Buffer('cbSignature')
 });
 
+/** @type {import('restructure').Struct} */
 export default new r.Struct({
-  ulVersion:       r.uint32,  // Version number of the DSIG table (0x00000001)
-  usNumSigs:       r.uint16,  // Number of signatures in the table
-  usFlag:          r.uint16,  // Permission flags
-  signatures:      new r.Array(Signature, 'usNumSigs'),
+  ulVersion: r.uint32, // Version number of the DSIG table (0x00000001)
+  usNumSigs: r.uint16, // Number of signatures in the table
+  usFlag: r.uint16, // Permission flags
+  signatures: new r.Array(Signature, 'usNumSigs'),
   signatureBlocks: new r.Array(SignatureBlock, 'usNumSigs')
 });

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,
@@ -88,4 +95,3 @@ export let glyph = new r.VersionedStruct('version', {
     data: new r.Buffer('dataLen')
   }
 });
-

package/src/tables/EBLC.js

@@ -1,5 +1,7 @@
 import * as r from 'restructure';
-import {BigMetrics} from './EBDT';
+import { BigMetrics } from './EBDT';
+
+/** @typedef {import('restructure').StructValue} StructValue */
 
 let SBitLineMetrics = new r.Struct({
   ascender: 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,8 +123,18 @@ 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
+  version: r.uint32, // 0x00020000
   numSizes: r.uint32,
-  sizes:    new r.Array(BitmapSizeTable, 'numSizes')
+  sizes: new r.Array(BitmapSizeTable, 'numSizes')
 });