@cantoo/fontkit 2.0.4 → 2.0.6

package/src/tables/JSTF.js

@@ -5,39 +5,40 @@ import { GPOSLookup } from './GPOS';
 let JstfGSUBModList = new r.Array(r.uint16, r.uint16);
 
 let JstfPriority = new r.Struct({
-  shrinkageEnableGSUB:    new r.Pointer(r.uint16, JstfGSUBModList),
-  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)),
-  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))
+  shrinkageEnableGSUB: new r.Pointer(r.uint16, JstfGSUBModList),
+  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, 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, LookupList(GPOSLookup))
 });
 
 let JstfLangSys = new r.Array(new r.Pointer(r.uint16, JstfPriority), r.uint16);
 
 let JstfLangSysRecord = new r.Struct({
-  tag:         new r.String(4),
+  tag: new r.String(4),
   jstfLangSys: new r.Pointer(r.uint16, JstfLangSys)
 });
 
 let JstfScript = new r.Struct({
   extenderGlyphs: new r.Pointer(r.uint16, new r.Array(r.uint16, r.uint16)), // array of glyphs to extend line length
   defaultLangSys: new r.Pointer(r.uint16, JstfLangSys),
-  langSysCount:   r.uint16,
+  langSysCount: r.uint16,
   langSysRecords: new r.Array(JstfLangSysRecord, 'langSysCount')
 });
 
 let JstfScriptRecord = new r.Struct({
-  tag:    new r.String(4),
-  script: new r.Pointer(r.uint16, JstfScript, {type: 'parent'})
+  tag: new r.String(4),
+  script: new r.Pointer(r.uint16, JstfScript, { type: 'parent' })
 });
 
+/** @type {import('restructure').Struct} */
 export default new r.Struct({
-  version:     r.uint32,  // should be 0x00010000
+  version: r.uint32, // should be 0x00010000
   scriptCount: r.uint16,
-  scriptList:  new r.Array(JstfScriptRecord, 'scriptCount')
+  scriptList: new r.Array(JstfScriptRecord, 'scriptCount')
 });

package/src/tables/LTSH.js

@@ -3,8 +3,9 @@ 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,
-  yPels:      new r.Array(r.uint8, 'numGlyphs')
+  version: r.uint16,
+  numGlyphs: r.uint16,
+  yPels: new r.Array(r.uint8, 'numGlyphs')
 });

package/src/tables/OS2.js

@@ -1,77 +1,78 @@
 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
-    usWeightClass:          r.uint16,  // visual weight of stroke in glyphs
-    usWidthClass:           r.uint16,  // relative change from the normal aspect ratio (width to height ratio)
-    fsType:                 new r.Bitfield(r.uint16, [ // Indicates font embedding licensing rights
+    xAvgCharWidth: r.int16, // average weighted advance width of lower case letters and space
+    usWeightClass: r.uint16, // visual weight of stroke in glyphs
+    usWidthClass: r.uint16, // relative change from the normal aspect ratio (width to height ratio)
+    fsType: new r.Bitfield(r.uint16, [ // Indicates font embedding licensing rights
       null, 'noEmbedding', 'viewOnly', 'editable', null,
       null, null, null, 'noSubsetting', 'bitmapOnly'
     ]),
-    ySubscriptXSize:        r.int16,   // recommended horizontal size in pixels for subscripts
-    ySubscriptYSize:        r.int16,   // recommended vertical size in pixels for subscripts
-    ySubscriptXOffset:      r.int16,   // recommended horizontal offset for subscripts
-    ySubscriptYOffset:      r.int16,   // recommended vertical offset form the baseline for subscripts
-    ySuperscriptXSize:      r.int16,   // recommended horizontal size in pixels for superscripts
-    ySuperscriptYSize:      r.int16,   // recommended vertical size in pixels for superscripts
-    ySuperscriptXOffset:    r.int16,   // recommended horizontal offset for superscripts
-    ySuperscriptYOffset:    r.int16,   // recommended vertical offset from the baseline for superscripts
-    yStrikeoutSize:         r.int16,   // width of the strikeout stroke
-    yStrikeoutPosition:     r.int16,   // position of the strikeout stroke relative to the baseline
-    sFamilyClass:           r.int16,   // classification of font-family design
-    panose:                 new r.Array(r.uint8, 10),   // describe the visual characteristics of a given typeface
-    ulCharRange:            new r.Array(r.uint32, 4),
-    vendorID:               new r.String(4),          // four character identifier for the font vendor
-    fsSelection:            new r.Bitfield(r.uint16, [  // bit field containing information about the font
+    ySubscriptXSize: r.int16, // recommended horizontal size in pixels for subscripts
+    ySubscriptYSize: r.int16, // recommended vertical size in pixels for subscripts
+    ySubscriptXOffset: r.int16, // recommended horizontal offset for subscripts
+    ySubscriptYOffset: r.int16, // recommended vertical offset form the baseline for subscripts
+    ySuperscriptXSize: r.int16, // recommended horizontal size in pixels for superscripts
+    ySuperscriptYSize: r.int16, // recommended vertical size in pixels for superscripts
+    ySuperscriptXOffset: r.int16, // recommended horizontal offset for superscripts
+    ySuperscriptYOffset: r.int16, // recommended vertical offset from the baseline for superscripts
+    yStrikeoutSize: r.int16, // width of the strikeout stroke
+    yStrikeoutPosition: r.int16, // position of the strikeout stroke relative to the baseline
+    sFamilyClass: r.int16, // classification of font-family design
+    panose: new r.Array(r.uint8, 10), // describe the visual characteristics of a given typeface
+    ulCharRange: new r.Array(r.uint32, 4),
+    vendorID: new r.String(4), // four character identifier for the font vendor
+    fsSelection: new r.Bitfield(r.uint16, [ // bit field containing information about the font
       'italic', 'underscore', 'negative', 'outlined', 'strikeout',
       'bold', 'regular', 'useTypoMetrics', 'wws', 'oblique'
     ]),
-    usFirstCharIndex:       r.uint16,  // The minimum Unicode index in this font
-    usLastCharIndex:        r.uint16   // The maximum Unicode index in this font
+    usFirstCharIndex: r.uint16, // The minimum Unicode index in this font
+    usLastCharIndex: r.uint16 // The maximum Unicode index in this font
   },
 
   // The Apple version of this table ends here, but the Microsoft one continues on...
   0: {},
 
   1: {
-    typoAscender:       r.int16,
-    typoDescender:      r.int16,
-    typoLineGap:        r.int16,
-    winAscent:          r.uint16,
-    winDescent:         r.uint16,
-    codePageRange:      new r.Array(r.uint32, 2)
+    typoAscender: r.int16,
+    typoDescender: r.int16,
+    typoLineGap: r.int16,
+    winAscent: r.uint16,
+    winDescent: r.uint16,
+    codePageRange: new r.Array(r.uint32, 2)
   },
 
   2: {
     // these should be common with version 1 somehow
-    typoAscender:       r.int16,
-    typoDescender:      r.int16,
-    typoLineGap:        r.int16,
-    winAscent:          r.uint16,
-    winDescent:         r.uint16,
-    codePageRange:      new r.Array(r.uint32, 2),
+    typoAscender: r.int16,
+    typoDescender: r.int16,
+    typoLineGap: r.int16,
+    winAscent: r.uint16,
+    winDescent: r.uint16,
+    codePageRange: new r.Array(r.uint32, 2),
 
-    xHeight:            r.int16,
-    capHeight:          r.int16,
-    defaultChar:        r.uint16,
-    breakChar:          r.uint16,
-    maxContent:         r.uint16
+    xHeight: r.int16,
+    capHeight: r.int16,
+    defaultChar: r.uint16,
+    breakChar: r.uint16,
+    maxContent: r.uint16
   },
 
   5: {
-    typoAscender:       r.int16,
-    typoDescender:      r.int16,
-    typoLineGap:        r.int16,
-    winAscent:          r.uint16,
-    winDescent:         r.uint16,
-    codePageRange:      new r.Array(r.uint32, 2),
+    typoAscender: r.int16,
+    typoDescender: r.int16,
+    typoLineGap: r.int16,
+    winAscent: r.uint16,
+    winDescent: r.uint16,
+    codePageRange: new r.Array(r.uint32, 2),
 
-    xHeight:            r.int16,
-    capHeight:          r.int16,
-    defaultChar:        r.uint16,
-    breakChar:          r.uint16,
-    maxContent:         r.uint16,
+    xHeight: r.int16,
+    capHeight: r.int16,
+    defaultChar: r.uint16,
+    breakChar: r.uint16,
+    maxContent: r.uint16,
 
     usLowerOpticalPointSize: r.uint16,
     usUpperOpticalPointSize: r.uint16

package/src/tables/PCLT.js

@@ -2,20 +2,21 @@ 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,
-  pitch:                r.uint16,
-  xHeight:              r.uint16,
-  style:                r.uint16,
-  typeFamily:           r.uint16,
-  capHeight:            r.uint16,
-  symbolSet:            r.uint16,
-  typeface:             new r.String(16),
-  characterComplement:  new r.String(8),
-  fileName:             new r.String(6),
-  strokeWeight:         new r.String(1),
-  widthType:            new r.String(1),
-  serifStyle:           r.uint8,
-  reserved:             new r.Reserved(r.uint8)
+  version: r.uint16,
+  fontNumber: r.uint32,
+  pitch: r.uint16,
+  xHeight: r.uint16,
+  style: r.uint16,
+  typeFamily: r.uint16,
+  capHeight: r.uint16,
+  symbolSet: r.uint16,
+  typeface: new r.String(16),
+  characterComplement: new r.String(8),
+  fileName: new r.String(6),
+  strokeWeight: new r.String(1),
+  widthType: new r.String(1),
+  serifStyle: r.uint8,
+  reserved: new r.Reserved(r.uint8)
 });

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

@@ -4,30 +4,31 @@ import * as r from 'restructure';
 // sizes. This is needed in order to match font metrics on Windows.
 
 let Ratio = new r.Struct({
-  bCharSet:       r.uint8,                             // Character set
-  xRatio:         r.uint8,                             // Value to use for x-Ratio
-  yStartRatio:    r.uint8,                             // Starting y-Ratio value
-  yEndRatio:      r.uint8                              // Ending y-Ratio value
+  bCharSet: r.uint8, // Character set
+  xRatio: r.uint8, // Value to use for x-Ratio
+  yStartRatio: r.uint8, // Starting y-Ratio value
+  yEndRatio: r.uint8 // Ending y-Ratio value
 });
 
 let vTable = new r.Struct({
-  yPelHeight:     r.uint16,                            // yPelHeight to which values apply
-  yMax:           r.int16,                             // Maximum value (in pels) for this yPelHeight
-  yMin:           r.int16                              // Minimum value (in pels) for this yPelHeight
+  yPelHeight: r.uint16, // yPelHeight to which values apply
+  yMax: r.int16, // Maximum value (in pels) for this yPelHeight
+  yMin: r.int16 // Minimum value (in pels) for this yPelHeight
 });
 
 let VdmxGroup = new r.Struct({
-  recs:           r.uint16,                            // Number of height records in this group
-  startsz:        r.uint8,                             // Starting yPelHeight
-  endsz:          r.uint8,                             // Ending yPelHeight
-  entries:        new r.Array(vTable, 'recs')          // The VDMX records
+  recs: r.uint16, // Number of height records in this group
+  startsz: r.uint8, // Starting yPelHeight
+  endsz: r.uint8, // Ending yPelHeight
+  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
-  numRatios:      r.uint16,                            // Number of aspect ratio groupings
-  ratioRanges:    new r.Array(Ratio, 'numRatios'),     // Ratio ranges
-  offsets:        new r.Array(r.uint16, 'numRatios'),  // Offset to the VDMX group for this ratio range
-  groups:         new r.Array(VdmxGroup, 'numRecs')    // The actual VDMX groupings
+  version: r.uint16, // Version number (0 or 1)
+  numRecs: r.uint16, // Number of VDMX groups present
+  numRatios: r.uint16, // Number of aspect ratio groupings
+  ratioRanges: new r.Array(Ratio, 'numRatios'), // Ratio ranges
+  offsets: new r.Array(r.uint16, 'numRatios'), // Offset to the VDMX group for this ratio range
+  groups: new r.Array(VdmxGroup, 'numRecs') // The actual VDMX groupings
 });

package/src/tables/VORG.js

@@ -1,14 +1,15 @@
 import * as r from 'restructure';
 
 let VerticalOrigin = new r.Struct({
-  glyphIndex:   r.uint16,
-  vertOriginY:  r.int16
+  glyphIndex: r.uint16,
+  vertOriginY: r.int16
 });
 
+/** @type {import('restructure').Struct} */
 export default new r.Struct({
-  majorVersion:           r.uint16,
-  minorVersion:           r.uint16,
-  defaultVertOriginY:     r.int16,
-  numVertOriginYMetrics:  r.uint16,
-  metrics:                new r.Array(VerticalOrigin, 'numVertOriginYMetrics')
+  majorVersion: r.uint16,
+  minorVersion: r.uint16,
+  defaultVertOriginY: r.int16,
+  numVertOriginYMetrics: r.uint16,
+  metrics: new r.Array(VerticalOrigin, 'numVertOriginYMetrics')
 });

package/src/tables/WOFF2Directory.js

@@ -1,6 +1,19 @@
 import * as r from 'restructure';
 
+/** @typedef {import('restructure').BaseType} BaseType */
+/** @typedef {import('restructure').DecodeStream} DecodeStream */
+/** @typedef {import('restructure').StructValue} StructValue */
+/** @typedef {import('../../types/fontkit').TableEntry} TableEntry */
+
+/**
+ * WOFF2 variable-length unsigned integer (Base128).
+ * @type {BaseType}
+ */
 const Base128 = {
+  /**
+   * @param {DecodeStream} stream
+   * @returns {number}
+   */
   decode(stream) {
     let result = 0;
     let iterable = [0, 1, 2, 3, 4];
@@ -34,14 +47,46 @@ let knownTags = [
 
 let WOFF2DirectoryEntry = new r.Struct({
   flags: r.uint8,
-  customTag: new r.Optional(new r.String(4), t => (t.flags & 0x3f) === 0x3f),
-  tag: t => t.customTag || knownTags[t.flags & 0x3f],// || (() => { throw new Error(`Bad tag: ${flags & 0x3f}`); })(); },
+  customTag: new r.Optional(
+    new r.String(4),
+    /** @param {StructValue} t @returns {boolean} */
+    t => (/** @type {number} */ (t.flags) & 0x3f) === 0x3f
+  ),
+  /**
+   * @param {StructValue} t
+   * @returns {string}
+   */
+  tag: (t) => {
+    let flags = /** @type {number} */ (t.flags);
+    return /** @type {string} */ (t.customTag) || knownTags[flags & 0x3f];
+  },
   length: Base128,
-  transformVersion: t => (t.flags >>> 6) & 0x03,
-  transformed: t => (t.tag === 'glyf' || t.tag === 'loca') ? t.transformVersion === 0 : t.transformVersion !== 0,
-  transformLength: new r.Optional(Base128, t => t.transformed)
+  /**
+   * @param {StructValue} t
+   * @returns {number}
+   */
+  transformVersion: t => (/** @type {number} */ (t.flags) >>> 6) & 0x03,
+  /**
+   * @param {StructValue} t
+   * @returns {boolean}
+   */
+  transformed: t => (t.tag === 'glyf' || t.tag === 'loca')
+    ? t.transformVersion === 0
+    : t.transformVersion !== 0,
+  transformLength: new r.Optional(
+    Base128,
+    /** @param {StructValue} t @returns {boolean} */
+    t => !!t.transformed
+  )
 });
 
+/**
+ * @typedef {StructValue & {
+ *   tables: TableEntry[] | Record<string, TableEntry>
+ * }} WOFF2DirectoryValue
+ */
+
+/** @type {import('restructure').Struct} */
 let WOFF2Directory = new r.Struct({
   tag: new r.String(4), // should be 'wOF2'
   flavor: r.uint32,
@@ -60,14 +105,17 @@ let WOFF2Directory = new r.Struct({
   tables: new r.Array(WOFF2DirectoryEntry, 'numTables')
 });
 
-WOFF2Directory.process = function() {
+WOFF2Directory.process = function () {
+  let self = /** @type {WOFF2DirectoryValue} */ (this);
+  /** @type {Record<string, TableEntry>} */
   let tables = {};
-  for (let i = 0; i < this.tables.length; i++) {
-    let table = this.tables[i];
+  let list = /** @type {TableEntry[]} */ (self.tables);
+  for (let i = 0; i < list.length; i++) {
+    let table = list[i];
     tables[table.tag] = table;
   }
 
-  return this.tables = tables;
+  self.tables = tables;
 };
 
 export default WOFF2Directory;

package/src/tables/WOFFDirectory.js

@@ -1,37 +1,49 @@
 import * as r from 'restructure';
 
+/** @typedef {import('restructure').StructValue} StructValue */
+/** @typedef {import('../../types/fontkit').TableEntry} TableEntry */
+
+/**
+ * @typedef {StructValue & {
+ *   tables: TableEntry[] | Record<string, TableEntry>
+ * }} WOFFDirectoryValue
+ */
+
 let WOFFDirectoryEntry = new r.Struct({
-  tag:          new r.String(4),
-  offset:       new r.Pointer(r.uint32, 'void', {type: 'global'}),
-  compLength:   r.uint32,
-  length:       r.uint32,
+  tag: new r.String(4),
+  offset: new r.Pointer(r.uint32, 'void', { type: 'global' }),
+  compLength: r.uint32,
+  length: r.uint32,
   origChecksum: r.uint32
 });
 
+/** @type {import('restructure').Struct} */
 let WOFFDirectory = new r.Struct({
-  tag:            new r.String(4), // should be 'wOFF'
-  flavor:         r.uint32,
-  length:         r.uint32,
-  numTables:      r.uint16,
-  reserved:       new r.Reserved(r.uint16),
-  totalSfntSize:  r.uint32,
-  majorVersion:   r.uint16,
-  minorVersion:   r.uint16,
-  metaOffset:     r.uint32,
-  metaLength:     r.uint32,
+  tag: new r.String(4), // should be 'wOFF'
+  flavor: r.uint32,
+  length: r.uint32,
+  numTables: r.uint16,
+  reserved: new r.Reserved(r.uint16),
+  totalSfntSize: r.uint32,
+  majorVersion: r.uint16,
+  minorVersion: r.uint16,
+  metaOffset: r.uint32,
+  metaLength: r.uint32,
   metaOrigLength: r.uint32,
-  privOffset:     r.uint32,
-  privLength:     r.uint32,
-  tables:         new r.Array(WOFFDirectoryEntry, 'numTables')
+  privOffset: r.uint32,
+  privLength: r.uint32,
+  tables: new r.Array(WOFFDirectoryEntry, 'numTables')
 });
 
-WOFFDirectory.process = function() {
+WOFFDirectory.process = function () {
+  let self = /** @type {WOFFDirectoryValue} */ (this);
+  /** @type {Record<string, TableEntry>} */
   let tables = {};
-  for (let table of this.tables) {
+  for (let table of /** @type {TableEntry[]} */ (self.tables)) {
     tables[table.tag] = table;
   }
 
-  this.tables = tables;
+  self.tables = tables;
 };
 
 export default WOFFDirectory;