@cantoo/fontkit 2.0.4

package/src/tables/hhea.js

@@ -0,0 +1,19 @@
+import * as r from 'restructure';
+
+// horizontal header
+export default new r.Struct({
+  version:              r.int32,
+  ascent:               r.int16,   // Distance from baseline of highest ascender
+  descent:              r.int16,   // Distance from baseline of lowest descender
+  lineGap:              r.int16,   // Typographic line gap
+  advanceWidthMax:      r.uint16,  // Maximum advance width value in 'hmtx' table
+  minLeftSideBearing:   r.int16,   // Maximum advance width value in 'hmtx' table
+  minRightSideBearing:  r.int16,   // Minimum right sidebearing value
+  xMaxExtent:           r.int16,
+  caretSlopeRise:       r.int16,   // Used to calculate the slope of the cursor (rise/run); 1 for vertical
+  caretSlopeRun:        r.int16,   // 0 for vertical
+  caretOffset:          r.int16,   // Set to 0 for non-slanted fonts
+  reserved:             new r.Reserved(r.int16, 4),
+  metricDataFormat:     r.int16,   // 0 for current format
+  numberOfMetrics:      r.uint16   // Number of advance widths in 'hmtx' table
+});

package/src/tables/hmtx.js

@@ -0,0 +1,11 @@
+import * as r from 'restructure';
+
+let HmtxEntry = new r.Struct({
+  advance: r.uint16,
+  bearing: r.int16
+});
+
+export default new r.Struct({
+  metrics:    new r.LazyArray(HmtxEntry, t => t.parent.hhea.numberOfMetrics),
+  bearings:   new r.LazyArray(r.int16, t => t.parent.maxp.numGlyphs - t.parent.hhea.numberOfMetrics)
+});

package/src/tables/index.js

@@ -0,0 +1,119 @@
+let tables = {};
+export default tables;
+
+// Required Tables
+import cmap from './cmap';
+import head from './head';
+import hhea from './hhea';
+import hmtx from './hmtx';
+import maxp from './maxp';
+import name from './name';
+import OS2 from './OS2';
+import post from './post';
+
+tables.cmap = cmap;
+tables.head = head;
+tables.hhea = hhea;
+tables.hmtx = hmtx;
+tables.maxp = maxp;
+tables.name = name;
+tables['OS/2'] = OS2;
+tables.post = post;
+
+
+// TrueType Outlines
+import cvt from './cvt';
+import fpgm from './fpgm';
+import loca from './loca';
+import prep from './prep';
+import glyf from './glyf';
+
+tables.fpgm = fpgm;
+tables.loca = loca;
+tables.prep = prep;
+tables['cvt '] = cvt;
+tables.glyf = glyf;
+
+
+// PostScript Outlines
+import CFFFont from '../cff/CFFFont';
+import VORG from './VORG';
+
+tables['CFF '] = CFFFont;
+tables['CFF2'] = CFFFont;
+tables.VORG = VORG;
+
+
+// Bitmap Glyphs
+import EBLC from './EBLC';
+import sbix from './sbix';
+import COLR from './COLR';
+import CPAL from './CPAL';
+
+tables.EBLC = EBLC;
+tables.CBLC = tables.EBLC;
+tables.sbix = sbix;
+tables.COLR = COLR;
+tables.CPAL = CPAL;
+
+
+// Advanced OpenType Tables
+import BASE from './BASE';
+import GDEF from './GDEF';
+import GPOS from './GPOS';
+import GSUB from './GSUB';
+import JSTF from './JSTF';
+
+tables.BASE = BASE;
+tables.GDEF = GDEF;
+tables.GPOS = GPOS;
+tables.GSUB = GSUB;
+tables.JSTF = JSTF;
+
+// OpenType variations tables
+import HVAR from './HVAR';
+
+tables.HVAR = HVAR;
+
+// Other OpenType Tables
+import DSIG from './DSIG';
+import gasp from './gasp';
+import hdmx from './hdmx';
+import kern from './kern';
+import LTSH from './LTSH';
+import STAT from './STAT';
+import PCLT from './PCLT';
+import VDMX from './VDMX';
+import vhea from './vhea';
+import vmtx from './vmtx';
+
+tables.DSIG = DSIG;
+tables.gasp = gasp;
+tables.hdmx = hdmx;
+tables.kern = kern;
+tables.LTSH = LTSH;
+tables.STAT = STAT;
+tables.PCLT = PCLT;
+tables.VDMX = VDMX;
+tables.vhea = vhea;
+tables.vmtx = vmtx;
+
+
+// Apple Advanced Typography Tables
+import avar from './avar';
+import bsln from './bsln';
+import feat from './feat';
+import fvar from './fvar';
+import gvar from './gvar';
+import just from './just';
+import morx from './morx';
+import opbd from './opbd';
+
+tables.avar = avar;
+tables.bsln = bsln;
+tables.feat = feat;
+tables.fvar = fvar;
+tables.gvar = gvar;
+tables.just = just;
+tables.morx = morx;
+tables.opbd = opbd;

package/src/tables/just.js

@@ -0,0 +1,81 @@
+import * as r from 'restructure';
+import { LookupTable, StateTable1 } from './aat';
+
+let ClassTable = new r.Struct({
+  length: r.uint16,
+  coverage: r.uint16,
+  subFeatureFlags: r.uint32,
+  stateTable: new StateTable1
+});
+
+let WidthDeltaRecord = new r.Struct({
+  justClass: r.uint32,
+  beforeGrowLimit: r.fixed32,
+  beforeShrinkLimit: r.fixed32,
+  afterGrowLimit: r.fixed32,
+  afterShrinkLimit: r.fixed32,
+  growFlags: r.uint16,
+  shrinkFlags: r.uint16
+});
+
+let WidthDeltaCluster = new r.Array(WidthDeltaRecord, r.uint32);
+
+let ActionData = new r.VersionedStruct('actionType', {
+  0: { // Decomposition action
+    lowerLimit: r.fixed32,
+    upperLimit: r.fixed32,
+    order: r.uint16,
+    glyphs: new r.Array(r.uint16, r.uint16)
+  },
+
+  1: { // Unconditional add glyph action
+    addGlyph: r.uint16
+  },
+
+  2: { // Conditional add glyph action
+    substThreshold: r.fixed32,
+    addGlyph: r.uint16,
+    substGlyph: r.uint16
+  },
+
+  3: {}, // Stretch glyph action (no data, not supported by CoreText)
+
+  4: { // Ductile glyph action (not supported by CoreText)
+    variationAxis: r.uint32,
+    minimumLimit: r.fixed32,
+    noStretchValue: r.fixed32,
+    maximumLimit: r.fixed32
+  },
+
+  5: { // Repeated add glyph action
+    flags: r.uint16,
+    glyph: r.uint16
+  }
+});
+
+let Action = new r.Struct({
+  actionClass: r.uint16,
+  actionType: r.uint16,
+  actionLength: r.uint32,
+  actionData: ActionData,
+  padding: new r.Reserved(r.uint8, t => t.actionLength - t._currentOffset)
+});
+
+let PostcompensationAction = new r.Array(Action, r.uint32);
+let PostCompensationTable = new r.Struct({
+  lookupTable: new LookupTable(new r.Pointer(r.uint16, PostcompensationAction))
+});
+
+let JustificationTable = new r.Struct({
+  classTable: new r.Pointer(r.uint16, ClassTable, { type: 'parent' }),
+  wdcOffset: r.uint16,
+  postCompensationTable: new r.Pointer(r.uint16, PostCompensationTable, { type: 'parent' }),
+  widthDeltaClusters: new LookupTable(new r.Pointer(r.uint16, WidthDeltaCluster, { type: 'parent', relativeTo: ctx => ctx.wdcOffset }))
+});
+
+export default new r.Struct({
+  version: r.uint32,
+  format: r.uint16,
+  horizontal: new r.Pointer(r.uint16, JustificationTable),
+  vertical: new r.Pointer(r.uint16, JustificationTable)
+});

package/src/tables/kern.js

@@ -0,0 +1,91 @@
+import * as r from 'restructure';
+
+let KernPair = new r.Struct({
+  left:   r.uint16,
+  right:  r.uint16,
+  value:  r.int16
+});
+
+let ClassTable = new r.Struct({
+  firstGlyph: r.uint16,
+  nGlyphs: r.uint16,
+  offsets: new r.Array(r.uint16, 'nGlyphs'),
+  max: t => t.offsets.length && Math.max.apply(Math, t.offsets)
+});
+
+let Kern2Array = new r.Struct({
+  off: t => t._startOffset - t.parent.parent._startOffset,
+  len: t => (((t.parent.leftTable.max - t.off) / t.parent.rowWidth) + 1) * (t.parent.rowWidth / 2),
+  values: new r.LazyArray(r.int16, 'len')
+});
+
+let KernSubtable = new r.VersionedStruct('format', {
+  0: {
+    nPairs:         r.uint16,
+    searchRange:    r.uint16,
+    entrySelector:  r.uint16,
+    rangeShift:     r.uint16,
+    pairs:          new r.Array(KernPair, 'nPairs')
+  },
+
+  2: {
+    rowWidth:   r.uint16,
+    leftTable:  new r.Pointer(r.uint16, ClassTable, {type: 'parent'}),
+    rightTable: new r.Pointer(r.uint16, ClassTable, {type: 'parent'}),
+    array:      new r.Pointer(r.uint16, Kern2Array, {type: 'parent'})
+  },
+
+  3: {
+    glyphCount:       r.uint16,
+    kernValueCount:   r.uint8,
+    leftClassCount:   r.uint8,
+    rightClassCount:  r.uint8,
+    flags:            r.uint8,
+    kernValue:        new r.Array(r.int16, 'kernValueCount'),
+    leftClass:        new r.Array(r.uint8, 'glyphCount'),
+    rightClass:       new r.Array(r.uint8, 'glyphCount'),
+    kernIndex:        new r.Array(r.uint8, t => t.leftClassCount * t.rightClassCount)
+  }
+});
+
+let KernTable = new r.VersionedStruct('version', {
+  0: { // Microsoft uses this format
+    subVersion: r.uint16,  // Microsoft has an extra sub-table version number
+    length:     r.uint16,  // Length of the subtable, in bytes
+    format:     r.uint8,   // Format of subtable
+    coverage:   new r.Bitfield(r.uint8, [
+      'horizontal',    // 1 if table has horizontal data, 0 if vertical
+      'minimum',       // If set to 1, the table has minimum values. If set to 0, the table has kerning values.
+      'crossStream',   // If set to 1, kerning is perpendicular to the flow of the text
+      'override'      // If set to 1 the value in this table replaces the accumulated value
+    ]),
+    subtable:   KernSubtable,
+    padding: new r.Reserved(r.uint8, t => t.length - t._currentOffset)
+  },
+  1: { // Apple uses this format
+    length:     r.uint32,
+    coverage:   new r.Bitfield(r.uint8, [
+      null, null, null, null, null,
+      'variation',     // Set if table has variation kerning values
+      'crossStream',   // Set if table has cross-stream kerning values
+      'vertical'      // Set if table has vertical kerning values
+    ]),
+    format:     r.uint8,
+    tupleIndex: r.uint16,
+    subtable:   KernSubtable,
+    padding: new r.Reserved(r.uint8, t => t.length - t._currentOffset)
+  }
+});
+
+export default new r.VersionedStruct(r.uint16, {
+  0: { // Microsoft Version
+    nTables:    r.uint16,
+    tables:     new r.Array(KernTable, 'nTables')
+  },
+
+  1: { // Apple Version
+    reserved:   new r.Reserved(r.uint16), // the other half of the version number
+    nTables:    r.uint32,
+    tables:     new r.Array(KernTable, 'nTables')
+  }
+});

package/src/tables/loca.js

@@ -0,0 +1,30 @@
+import * as r from 'restructure';
+
+let loca = new r.VersionedStruct('head.indexToLocFormat', {
+  0: {
+    offsets: new r.Array(r.uint16)
+  },
+  1: {
+    offsets: new r.Array(r.uint32)
+  }
+});
+
+loca.process = function() {
+  if (this.version === 0 && !this._processed) {
+    for (let i = 0; i < this.offsets.length; i++) {
+      this.offsets[i] <<= 1;
+    }
+    this._processed = true;
+  }
+};
+
+loca.preEncode = function() {
+  if (this.version === 0 && this._processed !== false) {
+    for (let i = 0; i < this.offsets.length; i++) {
+      this.offsets[i] >>>= 1;
+    }
+    this._processed = false;
+  }
+};
+
+export default loca;

package/src/tables/maxp.js

@@ -0,0 +1,20 @@
+import * as r from 'restructure';
+
+// maxiumum profile
+export default new r.Struct({
+  version:                r.int32,
+  numGlyphs:              r.uint16,  // The number of glyphs in the font
+  maxPoints:              r.uint16,  // Maximum points in a non-composite glyph
+  maxContours:            r.uint16,  // Maximum contours in a non-composite glyph
+  maxComponentPoints:     r.uint16,  // Maximum points in a composite glyph
+  maxComponentContours:   r.uint16,  // Maximum contours in a composite glyph
+  maxZones:               r.uint16,  // 1 if instructions do not use the twilight zone, 2 otherwise
+  maxTwilightPoints:      r.uint16,  // Maximum points used in Z0
+  maxStorage:             r.uint16,  // Number of Storage Area locations
+  maxFunctionDefs:        r.uint16,  // Number of FDEFs
+  maxInstructionDefs:     r.uint16,  // Number of IDEFs
+  maxStackElements:       r.uint16,  // Maximum stack depth
+  maxSizeOfInstructions:  r.uint16,  // Maximum byte count for glyph instructions
+  maxComponentElements:   r.uint16,  // Maximum number of components referenced at “top level” for any composite glyph
+  maxComponentDepth:      r.uint16   // Maximum levels of recursion; 1 for simple components
+});

package/src/tables/morx.js

@@ -0,0 +1,79 @@
+import * as r from 'restructure';
+import { UnboundedArray, LookupTable, StateTable } from './aat';
+
+let LigatureData = {
+  action: r.uint16
+};
+
+let ContextualData = {
+  markIndex: r.uint16,
+  currentIndex: r.uint16
+};
+
+let InsertionData = {
+  currentInsertIndex: r.uint16,
+  markedInsertIndex: r.uint16
+};
+
+let SubstitutionTable = new r.Struct({
+  items: new UnboundedArray(new r.Pointer(r.uint32, new LookupTable))
+});
+
+let SubtableData = new r.VersionedStruct('type', {
+  0: { // Indic Rearrangement Subtable
+    stateTable: new StateTable
+  },
+
+  1: { // Contextual Glyph Substitution Subtable
+    stateTable: new StateTable(ContextualData),
+    substitutionTable: new r.Pointer(r.uint32, SubstitutionTable)
+  },
+
+  2: { // Ligature subtable
+    stateTable: new StateTable(LigatureData),
+    ligatureActions: new r.Pointer(r.uint32, new UnboundedArray(r.uint32)),
+    components: new r.Pointer(r.uint32, new UnboundedArray(r.uint16)),
+    ligatureList: new r.Pointer(r.uint32, new UnboundedArray(r.uint16))
+  },
+
+  4: { // Non-contextual Glyph Substitution Subtable
+    lookupTable: new LookupTable
+  },
+
+  5: { // Glyph Insertion Subtable
+    stateTable: new StateTable(InsertionData),
+    insertionActions: new r.Pointer(r.uint32, new UnboundedArray(r.uint16))
+  }
+});
+
+let Subtable = new r.Struct({
+  length: r.uint32,
+  coverage: r.uint24,
+  type: r.uint8,
+  subFeatureFlags: r.uint32,
+  table: SubtableData,
+  padding: new r.Reserved(r.uint8, t => t.length - t._currentOffset)
+});
+
+let FeatureEntry = new r.Struct({
+  featureType:    r.uint16,
+  featureSetting: r.uint16,
+  enableFlags:    r.uint32,
+  disableFlags:   r.uint32
+});
+
+let MorxChain = new r.Struct({
+  defaultFlags:     r.uint32,
+  chainLength:      r.uint32,
+  nFeatureEntries:  r.uint32,
+  nSubtables:       r.uint32,
+  features:         new r.Array(FeatureEntry, 'nFeatureEntries'),
+  subtables:        new r.Array(Subtable, 'nSubtables')
+});
+
+export default new r.Struct({
+  version:  r.uint16,
+  unused:   new r.Reserved(r.uint16),
+  nChains:  r.uint32,
+  chains:   new r.Array(MorxChain, 'nChains')
+});

package/src/tables/name.js

@@ -0,0 +1,157 @@
+import * as r from 'restructure';
+import {getEncoding, LANGUAGES} from '../encodings';
+
+let NameRecord = new r.Struct({
+  platformID: r.uint16,
+  encodingID: r.uint16,
+  languageID: r.uint16,
+  nameID:     r.uint16,
+  length:     r.uint16,
+  string:     new r.Pointer(r.uint16,
+    new r.String('length', t => getEncoding(t.platformID, t.encodingID, t.languageID)),
+    { type: 'parent', relativeTo: ctx => ctx.parent.stringOffset, allowNull: false }
+  )
+});
+
+let LangTagRecord = new r.Struct({
+  length:  r.uint16,
+  tag:     new r.Pointer(r.uint16, new r.String('length', 'utf16be'), {type: 'parent', relativeTo: ctx => ctx.stringOffset})
+});
+
+var NameTable = new r.VersionedStruct(r.uint16, {
+  0: {
+    count:          r.uint16,
+    stringOffset:   r.uint16,
+    records:        new r.Array(NameRecord, 'count')
+  },
+  1: {
+    count:          r.uint16,
+    stringOffset:   r.uint16,
+    records:        new r.Array(NameRecord, 'count'),
+    langTagCount:   r.uint16,
+    langTags:       new r.Array(LangTagRecord, 'langTagCount')
+  }
+});
+
+export default NameTable;
+
+const NAMES = [
+  'copyright',
+  'fontFamily',
+  'fontSubfamily',
+  'uniqueSubfamily',
+  'fullName',
+  'version',
+  'postscriptName', // Note: A font may have only one PostScript name and that name must be ASCII.
+  'trademark',
+  'manufacturer',
+  'designer',
+  'description',
+  'vendorURL',
+  'designerURL',
+  'license',
+  'licenseURL',
+  null, // reserved (nameID 15)
+  'preferredFamily',
+  'preferredSubfamily',
+  'compatibleFull',
+  'sampleText',
+  'postscriptCIDFontName',
+  'wwsFamilyName',
+  'wwsSubfamilyName',
+  'lightBackgroundPalette',
+  'darkBackgroundPalette',
+  'variationsPostScriptNamePrefix',
+];
+
+function pushEnRecord(out, nameID, string) {
+  if (typeof string !== 'string') return;
+
+  out.push({
+    platformID: 3,
+    encodingID: 1,
+    languageID: 0x409,
+    nameID,
+    length: string.length * 2,
+    string
+  });
+}
+
+NameTable.process = function(_stream) {
+  let records = {fontFeatures: {}};
+
+  for (let record of this.records) {
+    let language = LANGUAGES[record.platformID][record.languageID];
+
+    if (language == null && this.langTags != null && record.languageID >= 0x8000) {
+      language = this.langTags[record.languageID - 0x8000].tag;
+    }
+
+    if (language == null) {
+      language = record.platformID + '-' + record.languageID;
+    }
+
+    // Single store keyed by nameID (feat/fvar look up fontFeatures[id]).
+    let byId = records.fontFeatures[record.nameID] || (records.fontFeatures[record.nameID] = {});
+    if (typeof record.string === 'string' || typeof byId[language] !== 'string') {
+      byId[language] = record.string;
+    }
+
+    // Alias standard / reserved IDs onto friendly keys (same object).
+    if (record.nameID >= 256) continue;
+
+    let name = NAMES[record.nameID];
+    if (name) {
+      records[name] = byId;
+    } else {
+      if (records.reservedNameID == null) records.reservedNameID = {};
+      records.reservedNameID[record.nameID] = byId;
+    }
+  }
+
+  this.records = records;
+};
+
+NameTable.preEncode = function() {
+  if (Array.isArray(this.records)) return;
+  this.version = 0;
+
+  let records = [];
+  for (let key in this.records) {
+    let val = this.records[key];
+
+    if (key === 'fontFeatures') {
+      // Mirrors of IDs < 256 are encoded via named/reserved keys above.
+      for (let id in val) {
+        if (+id >= 256) pushEnRecord(records, +id, val[id].en);
+      }
+      continue;
+    }
+
+    if (key === 'reservedNameID') {
+      for (let id in val) pushEnRecord(records, +id, val[id].en);
+      continue;
+    }
+
+    let nameID = NAMES.indexOf(key);
+    if (nameID < 0) continue;
+
+    pushEnRecord(records, nameID, val.en);
+
+    // Match historical behaviour: also write PostScript name for Mac platform.
+    if (key === 'postscriptName' && typeof val.en === 'string') {
+      records.push({
+        platformID: 1,
+        encodingID: 0,
+        languageID: 0,
+        nameID,
+        length: val.en.length,
+        string: val.en
+      });
+    }
+  }
+
+  this.records = records;
+  this.count = records.length;
+  this.stringOffset = NameTable.size(this, null, false);
+};

package/src/tables/opbd.js

@@ -0,0 +1,15 @@
+import * as r from 'restructure';
+import { LookupTable } from './aat';
+
+let OpticalBounds = new r.Struct({
+  left: r.int16,
+  top: r.int16,
+  right: r.int16,
+  bottom: r.int16
+});
+
+export default new r.Struct({
+  version: r.fixed32,
+  format: r.uint16,
+  lookupTable: new LookupTable(OpticalBounds)
+});