@cantoo/fontkit 2.0.4 → 2.0.5

package/src/tables/OS2.js

@@ -2,76 +2,76 @@ 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
+    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

@@ -3,19 +3,19 @@ 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)
+  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/VDMX.js

@@ -4,30 +4,30 @@ 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
 });
 
 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,14 @@
 import * as r from 'restructure';
 
 let VerticalOrigin = new r.Struct({
-  glyphIndex:   r.uint16,
-  vertOriginY:  r.int16
+  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')
+  majorVersion: r.uint16,
+  minorVersion: r.uint16,
+  defaultVertOriginY: r.int16,
+  numVertOriginYMetrics: r.uint16,
+  metrics: new r.Array(VerticalOrigin, 'numVertOriginYMetrics')
 });

package/src/tables/WOFF2Directory.js

@@ -35,7 +35,7 @@ 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}`); })(); },
+  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,
@@ -60,7 +60,7 @@ let WOFF2Directory = new r.Struct({
   tables: new r.Array(WOFF2DirectoryEntry, 'numTables')
 });
 
-WOFF2Directory.process = function() {
+WOFF2Directory.process = function () {
   let tables = {};
   for (let i = 0; i < this.tables.length; i++) {
     let table = this.tables[i];

package/src/tables/WOFFDirectory.js

@@ -1,31 +1,31 @@
 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,
+  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,
+  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 tables = {};
   for (let table of this.tables) {
     tables[table.tag] = table;

package/src/tables/aat.js

@@ -35,7 +35,7 @@ export class UnboundedArray extends r.Array {
   }
 }
 
-export let LookupTable = function(ValueType = r.uint16) {
+export let LookupTable = function (ValueType = r.uint16) {
   // Helper class that makes internal structures invisible to pointers
   class Shadow {
     constructor(type) {
@@ -77,7 +77,7 @@ export let LookupTable = function(ValueType = r.uint16) {
   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'})
+    values: new r.Pointer(r.uint16, new r.Array(ValueType, t => t.lastGlyph - t.firstGlyph + 1), { type: 'parent' })
   });
 
   let LookupSingle = new r.Struct({

package/src/tables/cmap.js

@@ -1,127 +1,127 @@
 import * as r from 'restructure';
 
 let SubHeader = new r.Struct({
-  firstCode:      r.uint16,
-  entryCount:     r.uint16,
-  idDelta:        r.int16,
-  idRangeOffset:  r.uint16
+  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
+  startCharCode: r.uint32,
+  endCharCode: r.uint32,
+  glyphID: r.uint32
 });
 
 let UnicodeValueRange = new r.Struct({
-  startUnicodeValue:  r.uint24,
-  additionalCount:    r.uint8
+  startUnicodeValue: r.uint24,
+  additionalCount: r.uint8
 });
 
 let UVSMapping = new r.Struct({
   unicodeValue: r.uint24,
-  glyphID:      r.uint16
+  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'})
+  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)
+    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')
+    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)
+    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')
+    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,
+    length: r.uint32,
     language: r.uint16,
-    is32:     new r.LazyArray(r.uint8, 8192),
-    nGroups:  r.uint32,
-    groups:   new r.LazyArray(CmapGroup, 'nGroups')
+    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')
+    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,
+    length: r.uint32,
     language: r.uint32,
-    nGroups:  r.uint32,
-    groups:   new r.LazyArray(CmapGroup, 'nGroups')
+    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,
+    length: r.uint32,
     language: r.uint32,
-    nGroups:  r.uint32,
-    groups:   new r.LazyArray(CmapGroup, 'nGroups')
+    nGroups: r.uint32,
+    groups: new r.LazyArray(CmapGroup, 'nGroups')
   },
 
   14: { // Unicode Variation Sequences
-    length:       r.uint32,
-    numRecords:   r.uint32,
+    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})
+  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,
+  version: r.uint16,
   numSubtables: r.uint16,
-  tables:       new r.Array(CmapEntry, 'numSubtables')
+  tables: new r.Array(CmapEntry, 'numSubtables')
 });

package/src/tables/directory.js

@@ -2,22 +2,22 @@ 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
+  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')
+  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() {
+Directory.process = function () {
   let tables = {};
   for (let table of this.tables) {
     tables[table.tag] = table;
@@ -26,7 +26,7 @@ Directory.process = function() {
   this.tables = tables;
 };
 
-Directory.preEncode = function() {
+Directory.preEncode = function () {
   if (!Array.isArray(this.tables)) {
     let tables = [];
     for (let tag in this.tables) {
@@ -40,7 +40,7 @@ Directory.preEncode = function() {
         });
       }
     }
-    
+
     this.tables = tables;
   }
 
@@ -50,7 +50,7 @@ Directory.preEncode = function() {
   let maxExponentFor2 = Math.floor((Math.log(this.numTables) / Math.LN2));
   let maxPowerOf2 = Math.pow(2, maxExponentFor2);
 
-  this.searchRange =  maxPowerOf2 * 16;
+  this.searchRange = maxPowerOf2 * 16;
   this.entrySelector = Math.log(maxPowerOf2) / Math.LN2;
   this.rangeShift = this.numTables * 16 - this.searchRange;
 };

package/src/tables/gasp.js

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

package/src/tables/glyf.js

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

package/src/tables/hdmx.js

@@ -1,15 +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)
+  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')
+  version: r.uint16,
+  numRecords: r.int16,
+  sizeDeviceRecord: r.int32,
+  records: new r.Array(DeviceRecord, 'numRecords')
 });