@cantoo/fontkit 2.0.4

package/src/tables/GDEF.js

@@ -0,0 +1,57 @@
+import * as r from 'restructure';
+import {Coverage, ClassDef, Device} from './opentype';
+import {ItemVariationStore} from './variations';
+
+let AttachPoint = new r.Array(r.uint16, r.uint16);
+let AttachList = new r.Struct({
+  coverage:       new r.Pointer(r.uint16, Coverage),
+  glyphCount:     r.uint16,
+  attachPoints:   new r.Array(new r.Pointer(r.uint16, AttachPoint), 'glyphCount')
+});
+
+let CaretValue = new r.VersionedStruct(r.uint16, {
+  1: { // Design units only
+    coordinate: r.int16
+  },
+
+  2: { // Contour point
+    caretValuePoint: r.uint16
+  },
+
+  3: { // Design units plus Device table
+    coordinate:     r.int16,
+    deviceTable:    new r.Pointer(r.uint16, Device)
+  }
+});
+
+let LigGlyph = new r.Array(new r.Pointer(r.uint16, CaretValue), r.uint16);
+
+let LigCaretList = new r.Struct({
+  coverage:       new r.Pointer(r.uint16, Coverage),
+  ligGlyphCount:  r.uint16,
+  ligGlyphs:      new r.Array(new r.Pointer(r.uint16, LigGlyph), 'ligGlyphCount')
+});
+
+let MarkGlyphSetsDef = new r.Struct({
+  markSetTableFormat: r.uint16,
+  markSetCount:       r.uint16,
+  coverage:           new r.Array(new r.Pointer(r.uint32, Coverage), 'markSetCount')
+});
+
+export default new r.VersionedStruct(r.uint32, {
+  header: {
+    glyphClassDef:      new r.Pointer(r.uint16, ClassDef),
+    attachList:         new r.Pointer(r.uint16, AttachList),
+    ligCaretList:       new r.Pointer(r.uint16, LigCaretList),
+    markAttachClassDef: new r.Pointer(r.uint16, ClassDef)
+  },
+
+  0x00010000: {},
+  0x00010002: {
+    markGlyphSetsDef:   new r.Pointer(r.uint16, MarkGlyphSetsDef)
+  },
+  0x00010003: {
+    markGlyphSetsDef:   new r.Pointer(r.uint16, MarkGlyphSetsDef),
+    itemVariationStore: new r.Pointer(r.uint32, ItemVariationStore)
+  }
+});

package/src/tables/GPOS.js

@@ -0,0 +1,209 @@
+import * as r from 'restructure';
+import {ScriptList, FeatureList, LookupList, Coverage, ClassDef, Device, Context, ChainingContext} from './opentype';
+import {FeatureVariations} from './variations';
+
+let ValueFormat = new r.Bitfield(r.uint16, [
+  'xPlacement', 'yPlacement',
+  'xAdvance', 'yAdvance',
+  'xPlaDevice', 'yPlaDevice',
+  'xAdvDevice', 'yAdvDevice'
+]);
+
+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 })
+};
+
+class ValueRecord {
+  constructor(key = 'valueFormat') {
+    this.key = key;
+  }
+
+  buildStruct(parent) {
+    let struct = parent;
+    while (!struct[this.key] && struct.parent) {
+      struct = struct.parent;
+    }
+
+    if (!struct[this.key]) return;
+
+    let fields = {};
+    fields.rel = () => struct._startOffset;
+
+    let format = struct[this.key];
+    for (let key in format) {
+      if (format[key]) {
+        fields[key] = types[key];
+      }
+    }
+
+    return new r.Struct(fields);
+  }
+
+  size(val, ctx) {
+    return this.buildStruct(ctx).size(val, ctx);
+  }
+
+  decode(stream, parent) {
+    let res = this.buildStruct(parent).decode(stream, parent);
+    delete res.rel;
+    return res;
+  }
+}
+
+let PairValueRecord = new r.Struct({
+  secondGlyph:    r.uint16,
+  value1:         new ValueRecord('valueFormat1'),
+  value2:         new ValueRecord('valueFormat2')
+});
+
+let PairSet = new r.Array(PairValueRecord, r.uint16);
+
+let Class2Record = new r.Struct({
+  value1: new ValueRecord('valueFormat1'),
+  value2: new ValueRecord('valueFormat2')
+});
+
+let Anchor = new r.VersionedStruct(r.uint16, {
+  1: { // Design units only
+    xCoordinate:    r.int16,
+    yCoordinate:    r.int16
+  },
+
+  2: { // Design units plus contour point
+    xCoordinate:    r.int16,
+    yCoordinate:    r.int16,
+    anchorPoint:    r.uint16
+  },
+
+  3: { // Design units plus Device tables
+    xCoordinate:    r.int16,
+    yCoordinate:    r.int16,
+    xDeviceTable:   new r.Pointer(r.uint16, Device),
+    yDeviceTable:   new r.Pointer(r.uint16, Device)
+  }
+});
+
+let EntryExitRecord = new r.Struct({
+  entryAnchor:    new r.Pointer(r.uint16, Anchor, {type: 'parent'}),
+  exitAnchor:     new r.Pointer(r.uint16, Anchor, {type: 'parent'})
+});
+
+let MarkRecord = new r.Struct({
+  class:      r.uint16,
+  markAnchor: new r.Pointer(r.uint16, Anchor, {type: 'parent'})
+});
+
+let MarkArray = new r.Array(MarkRecord, r.uint16);
+
+let BaseRecord  = new r.Array(new r.Pointer(r.uint16, Anchor), t => 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 LigatureAttach  = new r.Array(ComponentRecord, r.uint16);
+let LigatureArray   = new r.Array(new r.Pointer(r.uint16, LigatureAttach), r.uint16);
+
+let GPOSLookup = new r.VersionedStruct('lookupType', {
+  1: new r.VersionedStruct(r.uint16, { // Single Adjustment
+    1: { // Single positioning value
+      coverage:       new r.Pointer(r.uint16, Coverage),
+      valueFormat:    ValueFormat,
+      value:          new ValueRecord()
+    },
+    2: {
+      coverage:       new r.Pointer(r.uint16, Coverage),
+      valueFormat:    ValueFormat,
+      valueCount:     r.uint16,
+      values:         new r.LazyArray(new ValueRecord(), 'valueCount')
+    }
+  }),
+
+  2: new r.VersionedStruct(r.uint16, { // Pair Adjustment Positioning
+    1: { // Adjustments for glyph pairs
+      coverage:       new r.Pointer(r.uint16, Coverage),
+      valueFormat1:   ValueFormat,
+      valueFormat2:   ValueFormat,
+      pairSetCount:   r.uint16,
+      pairSets:       new r.LazyArray(new r.Pointer(r.uint16, PairSet), 'pairSetCount')
+    },
+
+    2: { // Class pair adjustment
+      coverage:       new r.Pointer(r.uint16, Coverage),
+      valueFormat1:   ValueFormat,
+      valueFormat2:   ValueFormat,
+      classDef1:      new r.Pointer(r.uint16, ClassDef),
+      classDef2:      new r.Pointer(r.uint16, ClassDef),
+      class1Count:    r.uint16,
+      class2Count:    r.uint16,
+      classRecords:   new r.LazyArray(new r.LazyArray(Class2Record, 'class2Count'), 'class1Count')
+    }
+  }),
+
+  3: { // Cursive Attachment Positioning
+    format:             r.uint16,
+    coverage:           new r.Pointer(r.uint16, Coverage),
+    entryExitCount:     r.uint16,
+    entryExitRecords:   new r.Array(EntryExitRecord, 'entryExitCount')
+  },
+
+  4: { // MarkToBase Attachment Positioning
+    format:             r.uint16,
+    markCoverage:       new r.Pointer(r.uint16, Coverage),
+    baseCoverage:       new r.Pointer(r.uint16, Coverage),
+    classCount:         r.uint16,
+    markArray:          new r.Pointer(r.uint16, MarkArray),
+    baseArray:          new r.Pointer(r.uint16, BaseArray)
+  },
+
+  5: { // MarkToLigature Attachment Positioning
+    format:             r.uint16,
+    markCoverage:       new r.Pointer(r.uint16, Coverage),
+    ligatureCoverage:   new r.Pointer(r.uint16, Coverage),
+    classCount:         r.uint16,
+    markArray:          new r.Pointer(r.uint16, MarkArray),
+    ligatureArray:      new r.Pointer(r.uint16, LigatureArray)
+  },
+
+  6: { // MarkToMark Attachment Positioning
+    format:             r.uint16,
+    mark1Coverage:      new r.Pointer(r.uint16, Coverage),
+    mark2Coverage:      new r.Pointer(r.uint16, Coverage),
+    classCount:         r.uint16,
+    mark1Array:         new r.Pointer(r.uint16, MarkArray),
+    mark2Array:         new r.Pointer(r.uint16, BaseArray)
+  },
+
+  7: Context,          // Contextual positioning
+  8: ChainingContext,  // Chaining contextual positioning
+
+  9: { // Extension Positioning
+    posFormat:   r.uint16,
+    lookupType:  r.uint16,   // cannot also be 9
+    extension:   new r.Pointer(r.uint32, null)
+  }
+});
+
+// Fix circular reference
+GPOSLookup.versions[9].extension.type = GPOSLookup;
+
+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))
+  },
+
+  0x00010000: {},
+  0x00010001: {
+    featureVariations: new r.Pointer(r.uint32, FeatureVariations)
+  }
+});
+
+// export GPOSLookup for JSTF table
+export { GPOSLookup };

package/src/tables/GSUB.js

@@ -0,0 +1,85 @@
+import * as r from 'restructure';
+import {ScriptList, FeatureList, LookupList, Coverage, Context, ChainingContext} from './opentype';
+import {FeatureVariations} from './variations';
+
+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)
+});
+
+let LigatureSet = new r.Array(new r.Pointer(r.uint16, Ligature), r.uint16);
+
+let GSUBLookup = new r.VersionedStruct('lookupType', {
+  1: new r.VersionedStruct(r.uint16, {// Single Substitution
+    1: {
+      coverage:       new r.Pointer(r.uint16, Coverage),
+      deltaGlyphID:   r.int16
+    },
+    2: {
+      coverage:       new r.Pointer(r.uint16, Coverage),
+      glyphCount:     r.uint16,
+      substitute:     new r.LazyArray(r.uint16, 'glyphCount')
+    }
+  }),
+
+  2: { // Multiple Substitution
+    substFormat:    r.uint16,
+    coverage:       new r.Pointer(r.uint16, Coverage),
+    count:          r.uint16,
+    sequences:      new r.LazyArray(new r.Pointer(r.uint16, Sequence), 'count')
+  },
+
+  3: { // Alternate Substitution
+    substFormat:    r.uint16,
+    coverage:       new r.Pointer(r.uint16, Coverage),
+    count:          r.uint16,
+    alternateSet:   new r.LazyArray(new r.Pointer(r.uint16, AlternateSet), 'count')
+  },
+
+  4: { // Ligature Substitution
+    substFormat:    r.uint16,
+    coverage:       new r.Pointer(r.uint16, Coverage),
+    count:          r.uint16,
+    ligatureSets:   new r.LazyArray(new r.Pointer(r.uint16, LigatureSet), 'count')
+  },
+
+  5: Context,         // Contextual Substitution
+  6: ChainingContext, // Chaining Contextual Substitution
+
+  7: { // Extension Substitution
+    substFormat:   r.uint16,
+    lookupType:    r.uint16,   // cannot also be 7
+    extension:     new r.Pointer(r.uint32, null)
+  },
+
+  8: { // Reverse Chaining Contextual Single Substitution
+    substFormat:            r.uint16,
+    coverage:               new r.Pointer(r.uint16, Coverage),
+    backtrackGlyphCount:    r.uint16,
+    backtrackCoverage:      new r.Array(new r.Pointer(r.uint16, Coverage), 'backtrackGlyphCount'),
+    lookaheadGlyphCount:    r.uint16,
+    lookaheadCoverage:      new r.Array(new r.Pointer(r.uint16, Coverage), 'lookaheadGlyphCount'),
+    glyphCount:             r.uint16,
+    substitute:             new r.LazyArray(r.uint16, 'glyphCount')
+  }
+});
+
+// Fix circular reference
+GSUBLookup.versions[7].extension.type = GSUBLookup;
+
+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))
+  },
+
+  0x00010000: {},
+  0x00010001: {
+    featureVariations: new r.Pointer(r.uint32, FeatureVariations)
+  }
+});

package/src/tables/HVAR.js

@@ -0,0 +1,44 @@
+import * as r from 'restructure';
+import { resolveLength } from 'restructure';
+import { ItemVariationStore } from './variations';
+
+// TODO: add this to restructure
+class VariableSizeNumber {
+  constructor(size) {
+    this._size = size;
+  }
+
+  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();
+    }
+  }
+
+  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)
+});
+
+let DeltaSetIndexMap = new r.Struct({
+  entryFormat: r.uint16,
+  mapCount: r.uint16,
+  mapData: new r.Array(MapDataEntry, 'mapCount')
+});
+
+export default new r.Struct({
+  majorVersion: r.uint16,
+  minorVersion: r.uint16,
+  itemVariationStore: new r.Pointer(r.uint32, ItemVariationStore),
+  advanceWidthMapping: new r.Pointer(r.uint32, DeltaSetIndexMap),
+  LSBMapping: new r.Pointer(r.uint32, DeltaSetIndexMap),
+  RSBMapping: new r.Pointer(r.uint32, DeltaSetIndexMap)
+});

package/src/tables/JSTF.js

@@ -0,0 +1,43 @@
+import * as r from 'restructure';
+import { LookupList } from './opentype';
+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))
+});
+
+let JstfLangSys = new r.Array(new r.Pointer(r.uint16, JstfPriority), r.uint16);
+
+let JstfLangSysRecord = new r.Struct({
+  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,
+  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'})
+});
+
+export default new r.Struct({
+  version:     r.uint32,  // should be 0x00010000
+  scriptCount: r.uint16,
+  scriptList:  new r.Array(JstfScriptRecord, 'scriptCount')
+});

package/src/tables/LTSH.js

@@ -0,0 +1,10 @@
+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
+export default new r.Struct({
+  version:    r.uint16,
+  numGlyphs:  r.uint16,
+  yPels:      new r.Array(r.uint8, 'numGlyphs')
+});

package/src/tables/OS2.js

@@ -0,0 +1,84 @@
+import * as r from 'restructure';
+
+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
+      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
+      '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
+  },
+
+  // 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)
+  },
+
+  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),
+
+    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),
+
+    xHeight:            r.int16,
+    capHeight:          r.int16,
+    defaultChar:        r.uint16,
+    breakChar:          r.uint16,
+    maxContent:         r.uint16,
+
+    usLowerOpticalPointSize: r.uint16,
+    usUpperOpticalPointSize: r.uint16
+  }
+});
+
+let versions = OS2.versions;
+versions[3] = versions[4] = versions[2];
+
+export default OS2;

package/src/tables/PCLT.js

@@ -0,0 +1,21 @@
+import * as r from 'restructure';
+
+// PCL 5 Table
+// NOTE: The PCLT table is strongly discouraged for OpenType fonts with TrueType outlines
+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)
+});

package/src/tables/STAT.js

@@ -0,0 +1,99 @@
+import * as r from 'restructure';
+
+let AxisRecord = new r.Struct({
+  axisTag: new r.String(4),
+  axisNameID: r.uint16,
+  axisOrdering: r.uint16
+});
+
+// Formats 1–3 share axisIndex after format; format 4 uses axisCount instead.
+let AxisValue = new r.VersionedStruct(r.uint16, {
+  1: {
+    axisIndex: r.uint16,
+    flags: r.uint16,
+    valueNameID: r.uint16,
+    value: r.fixed32
+  },
+  2: {
+    axisIndex: r.uint16,
+    flags: r.uint16,
+    valueNameID: r.uint16,
+    nominalValue: r.fixed32,
+    rangeMinValue: r.fixed32,
+    rangeMaxValue: r.fixed32
+  },
+  3: {
+    axisIndex: r.uint16,
+    flags: r.uint16,
+    valueNameID: r.uint16,
+    value: r.fixed32,
+    linkedValue: r.fixed32
+  },
+  4: {
+    axisCount: r.uint16,
+    flags: r.uint16,
+    valueNameID: r.uint16,
+    axisValues: new r.Array(new r.Struct({
+      axisIndex: r.uint16,
+      value: r.fixed32
+    }), 'axisCount')
+  }
+});
+
+let AxisValueArray = new r.Struct({
+  axisValues: new r.Array(new r.Pointer(r.uint16, AxisValue), t => t.parent.axisValueCount)
+});
+
+// Use designAxisSize as record stride (OpenType forward-compat).
+class DesignAxisArray {
+  _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);
+  }
+
+  decode(stream, parent) {
+    let count = parent.designAxisCount;
+    let size = this._stride(parent);
+    let res = [];
+    for (let i = 0; i < count; i++) {
+      let start = stream.pos;
+      res.push(AxisRecord.decode(stream, parent));
+      stream.pos = start + size;
+    }
+    return res;
+  }
+
+  size(array, parent) {
+    return (array?.length ?? 0) * this._stride(parent);
+  }
+
+  encode(stream, array, parent) {
+    let size = this._stride(parent);
+    for (let item of array) {
+      let start = stream.pos;
+      AxisRecord.encode(stream, item, parent);
+      let pad = size - (stream.pos - start);
+      if (pad > 0) {
+        stream.fill(0, pad);
+      }
+    }
+  }
+}
+
+export default new r.VersionedStruct(r.uint32, {
+  header: {
+    designAxisSize: r.uint16,
+    designAxisCount: r.uint16,
+    offsetToDesignAxes: new r.Pointer(r.uint32, new DesignAxisArray()),
+    axisValueCount: r.uint16,
+    offsetToAxisValueOffsets: new r.Pointer(r.uint32, AxisValueArray)
+  },
+  0x00010000: {},
+  0x00010001: {
+    elidedFallbackNameID: r.uint16
+  },
+  // v1.2: same header as v1.1; adds AxisValue format 4.
+  0x00010002: {
+    elidedFallbackNameID: r.uint16
+  }
+});

package/src/tables/VDMX.js

@@ -0,0 +1,33 @@
+import * as r from 'restructure';
+
+// VDMX tables contain ascender/descender overrides for certain (usually small)
+// 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
+});
+
+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
+});
+
+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
+});
+
+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
+});