@cantoo/fontkit 2.0.4

package/src/tables/VORG.js

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

package/src/tables/WOFF2Directory.js

@@ -0,0 +1,73 @@
+import * as r from 'restructure';
+
+const Base128 = {
+  decode(stream) {
+    let result = 0;
+    let iterable = [0, 1, 2, 3, 4];
+    for (let j = 0; j < iterable.length; j++) {
+      let code = stream.readUInt8();
+
+      // If any of the top seven bits are set then we're about to overflow.
+      if (result & 0xe0000000) {
+        throw new Error('Overflow');
+      }
+
+      result = (result << 7) | (code & 0x7f);
+      if ((code & 0x80) === 0) {
+        return result;
+      }
+    }
+
+    throw new Error('Bad base 128 number');
+  }
+};
+
+let knownTags = [
+  'cmap', 'head', 'hhea', 'hmtx', 'maxp', 'name', 'OS/2', 'post', 'cvt ',
+  'fpgm', 'glyf', 'loca', 'prep', 'CFF ', 'VORG', 'EBDT', 'EBLC', 'gasp',
+  'hdmx', 'kern', 'LTSH', 'PCLT', 'VDMX', 'vhea', 'vmtx', 'BASE', 'GDEF',
+  'GPOS', 'GSUB', 'EBSC', 'JSTF', 'MATH', 'CBDT', 'CBLC', 'COLR', 'CPAL',
+  'SVG ', 'sbix', 'acnt', 'avar', 'bdat', 'bloc', 'bsln', 'cvar', 'fdsc',
+  'feat', 'fmtx', 'fvar', 'gvar', 'hsty', 'just', 'lcar', 'mort', 'morx',
+  'opbd', 'prop', 'trak', 'Zapf', 'Silf', 'Glat', 'Gloc', 'Feat', 'Sill'
+];
+
+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}`); })(); },
+  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)
+});
+
+let WOFF2Directory = new r.Struct({
+  tag: new r.String(4), // should be 'wOF2'
+  flavor: r.uint32,
+  length: r.uint32,
+  numTables: r.uint16,
+  reserved: new r.Reserved(r.uint16),
+  totalSfntSize: r.uint32,
+  totalCompressedSize: 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(WOFF2DirectoryEntry, 'numTables')
+});
+
+WOFF2Directory.process = function() {
+  let tables = {};
+  for (let i = 0; i < this.tables.length; i++) {
+    let table = this.tables[i];
+    tables[table.tag] = table;
+  }
+
+  return this.tables = tables;
+};
+
+export default WOFF2Directory;

package/src/tables/WOFFDirectory.js

@@ -0,0 +1,37 @@
+import * as r from 'restructure';
+
+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,
+  origChecksum: r.uint32
+});
+
+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,
+  metaOrigLength: r.uint32,
+  privOffset:     r.uint32,
+  privLength:     r.uint32,
+  tables:         new r.Array(WOFFDirectoryEntry, 'numTables')
+});
+
+WOFFDirectory.process = function() {
+  let tables = {};
+  for (let table of this.tables) {
+    tables[table.tag] = table;
+  }
+
+  this.tables = tables;
+};
+
+export default WOFFDirectory;

package/src/tables/aat.js

@@ -0,0 +1,157 @@
+import * as r from 'restructure';
+
+class UnboundedArrayAccessor {
+  constructor(type, stream, parent) {
+    this.type = type;
+    this.stream = stream;
+    this.parent = parent;
+    this.base = this.stream.pos;
+    this._items = [];
+  }
+
+  getItem(index) {
+    if (this._items[index] == null) {
+      let pos = this.stream.pos;
+      this.stream.pos = this.base + this.type.size(null, this.parent) * index;
+      this._items[index] = this.type.decode(this.stream, this.parent);
+      this.stream.pos = pos;
+    }
+
+    return this._items[index];
+  }
+
+  inspect() {
+    return `[UnboundedArray ${this.type.constructor.name}]`;
+  }
+}
+
+export class UnboundedArray extends r.Array {
+  constructor(type) {
+    super(type, 0);
+  }
+
+  decode(stream, parent) {
+    return new UnboundedArrayAccessor(this.type, stream, parent);
+  }
+}
+
+export let LookupTable = function(ValueType = r.uint16) {
+  // Helper class that makes internal structures invisible to pointers
+  class Shadow {
+    constructor(type) {
+      this.type = type;
+    }
+
+    decode(stream, ctx) {
+      ctx = ctx.parent.parent;
+      return this.type.decode(stream, ctx);
+    }
+
+    size(val, ctx) {
+      ctx = ctx.parent.parent;
+      return this.type.size(val, ctx);
+    }
+
+    encode(stream, val, ctx) {
+      ctx = ctx.parent.parent;
+      return this.type.encode(stream, val, ctx);
+    }
+  }
+
+  ValueType = new Shadow(ValueType);
+
+  let BinarySearchHeader = new r.Struct({
+    unitSize: r.uint16,
+    nUnits: r.uint16,
+    searchRange: r.uint16,
+    entrySelector: r.uint16,
+    rangeShift: r.uint16
+  });
+
+  let LookupSegmentSingle = new r.Struct({
+    lastGlyph: r.uint16,
+    firstGlyph: r.uint16,
+    value: ValueType
+  });
+
+  let LookupSegmentArray = new r.Struct({
+    lastGlyph: r.uint16,
+    firstGlyph: r.uint16,
+    values: new r.Pointer(r.uint16, new r.Array(ValueType, t => t.lastGlyph - t.firstGlyph + 1), {type: 'parent'})
+  });
+
+  let LookupSingle = new r.Struct({
+    glyph: r.uint16,
+    value: ValueType
+  });
+
+  return new r.VersionedStruct(r.uint16, {
+    0: {
+      values: new UnboundedArray(ValueType) // length == number of glyphs maybe?
+    },
+    2: {
+      binarySearchHeader: BinarySearchHeader,
+      segments: new r.Array(LookupSegmentSingle, t => t.binarySearchHeader.nUnits)
+    },
+    4: {
+      binarySearchHeader: BinarySearchHeader,
+      segments: new r.Array(LookupSegmentArray, t => t.binarySearchHeader.nUnits)
+    },
+    6: {
+      binarySearchHeader: BinarySearchHeader,
+      segments: new r.Array(LookupSingle, t => t.binarySearchHeader.nUnits)
+    },
+    8: {
+      firstGlyph: r.uint16,
+      count: r.uint16,
+      values: new r.Array(ValueType, 'count')
+    }
+  });
+};
+
+export function StateTable(entryData = {}, lookupType = r.uint16) {
+  let entry = Object.assign({
+    newState: r.uint16,
+    flags: r.uint16
+  }, entryData);
+
+  let Entry = new r.Struct(entry);
+  let StateArray = new UnboundedArray(new r.Array(r.uint16, t => t.nClasses));
+
+  let StateHeader = new r.Struct({
+    nClasses: r.uint32,
+    classTable: new r.Pointer(r.uint32, new LookupTable(lookupType)),
+    stateArray: new r.Pointer(r.uint32, StateArray),
+    entryTable: new r.Pointer(r.uint32, new UnboundedArray(Entry))
+  });
+
+  return StateHeader;
+}
+
+// This is the old version of the StateTable structure
+export function StateTable1(entryData = {}, _lookupType = r.uint16) {
+  let ClassLookupTable = new r.Struct({
+    version() { return 8; }, // simulate LookupTable
+    firstGlyph: r.uint16,
+    values: new r.Array(r.uint8, r.uint16)
+  });
+
+  let entry = Object.assign({
+    newStateOffset: r.uint16,
+    // convert offset to stateArray index
+    newState: t => (t.newStateOffset - (t.parent.stateArray.base - t.parent._startOffset)) / t.parent.nClasses,
+    flags: r.uint16
+  }, entryData);
+
+  let Entry = new r.Struct(entry);
+  let StateArray = new UnboundedArray(new r.Array(r.uint8, t => t.nClasses));
+
+  let StateHeader1 = new r.Struct({
+    nClasses: r.uint16,
+    classTable: new r.Pointer(r.uint16, ClassLookupTable),
+    stateArray: new r.Pointer(r.uint16, StateArray),
+    entryTable: new r.Pointer(r.uint16, new UnboundedArray(Entry))
+  });
+
+  return StateHeader1;
+}

package/src/tables/avar.js

@@ -0,0 +1,19 @@
+import * as r from 'restructure';
+
+let shortFrac = new r.Fixed(16, 'BE', 14);
+
+let Correspondence = new r.Struct({
+  fromCoord: shortFrac,
+  toCoord: shortFrac
+});
+
+let Segment = new r.Struct({
+  pairCount: r.uint16,
+  correspondence: new r.Array(Correspondence, 'pairCount')
+});
+
+export default new r.Struct({
+  version: r.fixed32,
+  axisCount: r.uint32,
+  segment: new r.Array(Segment, 'axisCount')
+});

package/src/tables/bsln.js

@@ -0,0 +1,31 @@
+import * as r from 'restructure';
+import { LookupTable } from './aat';
+
+let BslnSubtable = new r.VersionedStruct('format', {
+  0: { // Distance-based, no mapping
+    deltas: new r.Array(r.int16, 32)
+  },
+
+  1: { // Distance-based, with mapping
+    deltas: new r.Array(r.int16, 32),
+    mappingData: new LookupTable(r.uint16)
+  },
+
+  2: { // Control point-based, no mapping
+    standardGlyph: r.uint16,
+    controlPoints: new r.Array(r.uint16, 32)
+  },
+
+  3: { // Control point-based, with mapping
+    standardGlyph: r.uint16,
+    controlPoints: new r.Array(r.uint16, 32),
+    mappingData: new LookupTable(r.uint16)
+  }
+});
+
+export default new r.Struct({
+  version: r.fixed32,
+  format: r.uint16,
+  defaultBaseline: r.uint16,
+  subtable: BslnSubtable
+});

package/src/tables/cmap.js

@@ -0,0 +1,127 @@
+import * as r from 'restructure';
+
+let SubHeader = new r.Struct({
+  firstCode:      r.uint16,
+  entryCount:     r.uint16,
+  idDelta:        r.int16,
+  idRangeOffset:  r.uint16
+});
+
+let CmapGroup = new r.Struct({
+  startCharCode:  r.uint32,
+  endCharCode:    r.uint32,
+  glyphID:        r.uint32
+});
+
+let UnicodeValueRange = new r.Struct({
+  startUnicodeValue:  r.uint24,
+  additionalCount:    r.uint8
+});
+
+let UVSMapping = new r.Struct({
+  unicodeValue: r.uint24,
+  glyphID:      r.uint16
+});
+
+let DefaultUVS = new r.Array(UnicodeValueRange, r.uint32);
+let NonDefaultUVS = new r.Array(UVSMapping, r.uint32);
+
+let VarSelectorRecord = new r.Struct({
+  varSelector:    r.uint24,
+  defaultUVS:     new r.Pointer(r.uint32, DefaultUVS, {type: 'parent'}),
+  nonDefaultUVS:  new r.Pointer(r.uint32, NonDefaultUVS, {type: 'parent'})
+});
+
+let CmapSubtable = new r.VersionedStruct(r.uint16, {
+  0: { // Byte encoding
+    length:     r.uint16,   // Total table length in bytes (set to 262 for format 0)
+    language:   r.uint16,   // Language code for this encoding subtable, or zero if language-independent
+    codeMap:    new r.LazyArray(r.uint8, 256)
+  },
+
+  2: { // High-byte mapping (CJK)
+    length:           r.uint16,
+    language:         r.uint16,
+    subHeaderKeys:    new r.Array(r.uint16, 256),
+    subHeaderCount:   t => Math.max.apply(Math, t.subHeaderKeys),
+    subHeaders:       new r.LazyArray(SubHeader, 'subHeaderCount'),
+    glyphIndexArray:  new r.LazyArray(r.uint16, 'subHeaderCount')
+  },
+
+  4: { // Segment mapping to delta values
+    length:           r.uint16,              // Total table length in bytes
+    language:         r.uint16,              // Language code
+    segCountX2:       r.uint16,
+    segCount:         t => t.segCountX2 >> 1,
+    searchRange:      r.uint16,
+    entrySelector:    r.uint16,
+    rangeShift:       r.uint16,
+    endCode:          new r.LazyArray(r.uint16, 'segCount'),
+    reservedPad:      new r.Reserved(r.uint16),       // This value should be zero
+    startCode:        new r.LazyArray(r.uint16, 'segCount'),
+    idDelta:          new r.LazyArray(r.int16, 'segCount'),
+    idRangeOffset:    new r.LazyArray(r.uint16, 'segCount'),
+    glyphIndexArray:  new r.LazyArray(r.uint16, t => (t.length - t._currentOffset) / 2)
+  },
+
+  6: { // Trimmed table
+    length:         r.uint16,
+    language:       r.uint16,
+    firstCode:      r.uint16,
+    entryCount:     r.uint16,
+    glyphIndices:   new r.LazyArray(r.uint16, 'entryCount')
+  },
+
+  8: { // mixed 16-bit and 32-bit coverage
+    reserved: new r.Reserved(r.uint16),
+    length:   r.uint32,
+    language: r.uint16,
+    is32:     new r.LazyArray(r.uint8, 8192),
+    nGroups:  r.uint32,
+    groups:   new r.LazyArray(CmapGroup, 'nGroups')
+  },
+
+  10: { // Trimmed Array
+    reserved:       new r.Reserved(r.uint16),
+    length:         r.uint32,
+    language:       r.uint32,
+    firstCode:      r.uint32,
+    entryCount:     r.uint32,
+    glyphIndices:   new r.LazyArray(r.uint16, 'numChars')
+  },
+
+  12: { // Segmented coverage
+    reserved: new r.Reserved(r.uint16),
+    length:   r.uint32,
+    language: r.uint32,
+    nGroups:  r.uint32,
+    groups:   new r.LazyArray(CmapGroup, 'nGroups')
+  },
+
+  13: { // Many-to-one range mappings (same as 12 except for group.startGlyphID)
+    reserved: new r.Reserved(r.uint16),
+    length:   r.uint32,
+    language: r.uint32,
+    nGroups:  r.uint32,
+    groups:   new r.LazyArray(CmapGroup, 'nGroups')
+  },
+
+  14: { // Unicode Variation Sequences
+    length:       r.uint32,
+    numRecords:   r.uint32,
+    varSelectors: new r.LazyArray(VarSelectorRecord, 'numRecords')
+  }
+});
+
+let CmapEntry = new r.Struct({
+  platformID:  r.uint16,  // Platform identifier
+  encodingID:  r.uint16,  // Platform-specific encoding identifier
+  table:       new r.Pointer(r.uint32, CmapSubtable, {type: 'parent', lazy: true})
+});
+
+// character to glyph mapping
+export default new r.Struct({
+  version:      r.uint16,
+  numSubtables: r.uint16,
+  tables:       new r.Array(CmapEntry, 'numSubtables')
+});

package/src/tables/cvt.js

@@ -0,0 +1,6 @@
+import * as r from 'restructure';
+
+// An array of predefined values accessible by instructions
+export default new r.Struct({
+  controlValues: new r.Array(r.int16)
+});

package/src/tables/directory.js

@@ -0,0 +1,58 @@
+import * as r from 'restructure';
+import Tables from './';
+
+let TableEntry = new r.Struct({
+  tag:        new r.String(4),
+  checkSum:   r.uint32,
+  offset:     new r.Pointer(r.uint32, 'void', { type: 'global' }),
+  length:     r.uint32
+});
+
+let Directory = new r.Struct({
+  tag:            new r.String(4),
+  numTables:      r.uint16,
+  searchRange:    r.uint16,
+  entrySelector:  r.uint16,
+  rangeShift:     r.uint16,
+  tables:         new r.Array(TableEntry, 'numTables')
+});
+
+Directory.process = function() {
+  let tables = {};
+  for (let table of this.tables) {
+    tables[table.tag] = table;
+  }
+
+  this.tables = tables;
+};
+
+Directory.preEncode = function() {
+  if (!Array.isArray(this.tables)) {
+    let tables = [];
+    for (let tag in this.tables) {
+      let table = this.tables[tag];
+      if (table) {
+        tables.push({
+          tag: tag,
+          checkSum: 0,
+          offset: new r.VoidPointer(Tables[tag], table),
+          length: Tables[tag].size(table)
+        });
+      }
+    }
+    
+    this.tables = tables;
+  }
+
+  this.tag = 'true';
+  this.numTables = this.tables.length;
+
+  let maxExponentFor2 = Math.floor((Math.log(this.numTables) / Math.LN2));
+  let maxPowerOf2 = Math.pow(2, maxExponentFor2);
+
+  this.searchRange =  maxPowerOf2 * 16;
+  this.entrySelector = Math.log(maxPowerOf2) / Math.LN2;
+  this.rangeShift = this.numTables * 16 - this.searchRange;
+};
+
+export default Directory;

package/src/tables/feat.js

@@ -0,0 +1,28 @@
+import * as r from 'restructure';
+
+let Setting = new r.Struct({
+  setting: r.uint16,
+  nameIndex: r.int16,
+  name: t => t.parent.parent.parent.name.records.fontFeatures[t.nameIndex]
+});
+
+let FeatureName = new r.Struct({
+  feature: r.uint16,
+  nSettings: r.uint16,
+  settingTable: new r.Pointer(r.uint32, new r.Array(Setting, 'nSettings'), { type: 'parent' }),
+  featureFlags: new r.Bitfield(r.uint8, [
+    null, null, null, null, null, null,
+    'hasDefault', 'exclusive'
+  ]),
+  defaultSetting: r.uint8,
+  nameIndex: r.int16,
+  name: t => t.parent.parent.name.records.fontFeatures[t.nameIndex]
+});
+
+export default new r.Struct({
+  version: r.fixed32,
+  featureNameCount: r.uint16,
+  reserved1: new r.Reserved(r.uint16),
+  reserved2: new r.Reserved(r.uint32),
+  featureNames: new r.Array(FeatureName, 'featureNameCount')
+});

package/src/tables/fpgm.js

@@ -0,0 +1,8 @@
+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.
+export default new r.Struct({
+  instructions: new r.Array(r.uint8)
+});

package/src/tables/fvar.js

@@ -0,0 +1,31 @@
+import * as r from 'restructure';
+
+let Axis = new r.Struct({
+  axisTag: new r.String(4),
+  minValue: r.fixed32,
+  defaultValue: r.fixed32,
+  maxValue: r.fixed32,
+  flags: r.uint16,
+  nameID: r.uint16,
+  name: t => t.parent.parent.name.records.fontFeatures[t.nameID]
+});
+
+let Instance = new r.Struct({
+  nameID: r.uint16,
+  name: t => t.parent.parent.name.records.fontFeatures[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)
+});
+
+export default new r.Struct({
+  version: r.fixed32,
+  offsetToData: r.uint16,
+  countSizePairs: r.uint16,
+  axisCount: r.uint16,
+  axisSize: r.uint16,
+  instanceCount: r.uint16,
+  instanceSize: r.uint16,
+  axis: new r.Array(Axis, 'axisCount'),
+  instance: new r.Array(Instance, 'instanceCount')
+});

package/src/tables/gasp.js

@@ -0,0 +1,15 @@
+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
+    'grayscale', 'gridfit',
+    'symmetricSmoothing', 'symmetricGridfit'     // only in version 1, for ClearType
+  ])
+});
+
+export default new r.Struct({
+  version:    r.uint16,  // set to 0
+  numRanges:  r.uint16,
+  gaspRanges: new r.Array(GaspRange, 'numRanges') // Sorted by ppem
+});

package/src/tables/glyf.js

@@ -0,0 +1,4 @@
+import * as r from 'restructure';
+
+// only used for encoding
+export default new r.Array(new r.Buffer);

package/src/tables/gvar.js

@@ -0,0 +1,27 @@
+import * as r from 'restructure';
+
+let shortFrac = new r.Fixed(16, 'BE', 14);
+class Offset {
+  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
+      ? stream.readUInt32BE()
+      : stream.readUInt16BE() * 2;
+  }
+}
+
+let gvar = new r.Struct({
+  version: r.uint16,
+  reserved: new r.Reserved(r.uint16),
+  axisCount: r.uint16,
+  globalCoordCount: r.uint16,
+  globalCoords: new r.Pointer(r.uint32, new r.Array(new r.Array(shortFrac, 'axisCount'), 'globalCoordCount')),
+  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)
+});
+
+export default gvar;

package/src/tables/hdmx.js

@@ -0,0 +1,15 @@
+import * as r from 'restructure';
+
+let DeviceRecord = new r.Struct({
+  pixelSize:      r.uint8,
+  maximumWidth:   r.uint8,
+  widths:         new r.Array(r.uint8, t => t.parent.parent.maxp.numGlyphs)
+});
+
+// The Horizontal Device Metrics table stores integer advance widths scaled to particular pixel sizes
+export default new r.Struct({
+  version:            r.uint16,
+  numRecords:         r.int16,
+  sizeDeviceRecord:   r.int32,
+  records:            new r.Array(DeviceRecord, 'numRecords')
+});

package/src/tables/head.js

@@ -0,0 +1,25 @@
+import * as r from 'restructure';
+
+// font header
+export default new r.Struct({
+  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, [
+    '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
+});