@cantoo/fontkit 2.0.4

package/src/tables/opentype.js

@@ -0,0 +1,217 @@
+import * as r from 'restructure';
+
+//########################
+// Scripts and Languages #
+//########################
+
+let LangSysTable = new r.Struct({
+  reserved:         new r.Reserved(r.uint16),
+  reqFeatureIndex:  r.uint16,
+  featureCount:     r.uint16,
+  featureIndexes:   new r.Array(r.uint16, 'featureCount')
+});
+
+let LangSysRecord = new r.Struct({
+  tag:      new r.String(4),
+  langSys:  new r.Pointer(r.uint16, LangSysTable, { type: 'parent' })
+});
+
+let Script = new r.Struct({
+  defaultLangSys: new r.Pointer(r.uint16, LangSysTable),
+  count:          r.uint16,
+  langSysRecords: new r.Array(LangSysRecord, 'count')
+});
+
+let ScriptRecord = new r.Struct({
+  tag:    new r.String(4),
+  script: new r.Pointer(r.uint16, Script, { type: 'parent' })
+});
+
+export let ScriptList = new r.Array(ScriptRecord, r.uint16);
+
+//#######################
+// Features and Lookups #
+//#######################
+
+let FeatureParams = new r.Struct({
+  version:    r.uint16, // should be set to 0 according OT spec
+  nameID:     r.uint16, //OT spec: UI Name ID or uiLabelNameId
+});
+
+export let Feature = new r.Struct({
+  featureParams:      new r.Pointer(r.uint16, FeatureParams),
+  lookupCount:        r.uint16,
+  lookupListIndexes:  new r.Array(r.uint16, 'lookupCount')
+});
+
+let FeatureRecord = new r.Struct({
+  tag:      new r.String(4),
+  feature:  new r.Pointer(r.uint16, Feature, { type: 'parent' })
+});
+
+export let FeatureList = new r.Array(FeatureRecord, r.uint16);
+
+let LookupFlags = new r.Struct({
+  markAttachmentType: r.uint8,
+  flags: new r.Bitfield(r.uint8, [
+    'rightToLeft', 'ignoreBaseGlyphs', 'ignoreLigatures',
+    'ignoreMarks', 'useMarkFilteringSet'
+  ])
+});
+
+export function LookupList(SubTable) {
+  let Lookup = new r.Struct({
+    lookupType:         r.uint16,
+    flags:              LookupFlags,
+    subTableCount:      r.uint16,
+    subTables:          new r.Array(new r.Pointer(r.uint16, SubTable), 'subTableCount'),
+    markFilteringSet:   new r.Optional(r.uint16, t => t.flags.flags.useMarkFilteringSet)
+  });
+
+  return new r.LazyArray(new r.Pointer(r.uint16, Lookup), r.uint16);
+}
+
+//#################
+// Coverage Table #
+//#################
+
+let RangeRecord = new r.Struct({
+  start:              r.uint16,
+  end:                r.uint16,
+  startCoverageIndex: r.uint16
+});
+
+export let Coverage = new r.VersionedStruct(r.uint16, {
+  1: {
+    glyphCount:   r.uint16,
+    glyphs:       new r.Array(r.uint16, 'glyphCount')
+  },
+  2: {
+    rangeCount:   r.uint16,
+    rangeRecords: new r.Array(RangeRecord, 'rangeCount')
+  }
+});
+
+//#########################
+// Class Definition Table #
+//#########################
+
+let ClassRangeRecord = new r.Struct({
+  start:  r.uint16,
+  end:    r.uint16,
+  class:  r.uint16
+});
+
+export let ClassDef = new r.VersionedStruct(r.uint16, {
+  1: { // Class array
+    startGlyph:       r.uint16,
+    glyphCount:       r.uint16,
+    classValueArray:  new r.Array(r.uint16, 'glyphCount')
+  },
+  2: { // Class ranges
+    classRangeCount:  r.uint16,
+    classRangeRecord: new r.Array(ClassRangeRecord, 'classRangeCount')
+  }
+});
+
+//###############
+// Device Table #
+//###############
+
+export let Device = new r.Struct({
+  a: r.uint16, // startSize for hinting Device, outerIndex for VariationIndex
+  b: r.uint16, // endSize for Device, innerIndex for VariationIndex
+  deltaFormat: r.uint16
+});
+
+//#############################################
+// Contextual Substitution/Positioning Tables #
+//#############################################
+
+let LookupRecord = new r.Struct({
+  sequenceIndex:      r.uint16,
+  lookupListIndex:    r.uint16
+});
+
+let Rule = new r.Struct({
+  glyphCount:     r.uint16,
+  lookupCount:    r.uint16,
+  input:          new r.Array(r.uint16, t => t.glyphCount - 1),
+  lookupRecords:  new r.Array(LookupRecord, 'lookupCount')
+});
+
+let RuleSet = new r.Array(new r.Pointer(r.uint16, Rule), r.uint16);
+
+let ClassRule = new r.Struct({
+  glyphCount:     r.uint16,
+  lookupCount:    r.uint16,
+  classes:        new r.Array(r.uint16, t => t.glyphCount - 1),
+  lookupRecords:  new r.Array(LookupRecord, 'lookupCount')
+});
+
+let ClassSet = new r.Array(new r.Pointer(r.uint16, ClassRule), r.uint16);
+
+export let Context = new r.VersionedStruct(r.uint16, {
+  1: { // Simple context
+    coverage:      new r.Pointer(r.uint16, Coverage),
+    ruleSetCount:  r.uint16,
+    ruleSets:      new r.Array(new r.Pointer(r.uint16, RuleSet), 'ruleSetCount')
+  },
+  2: { // Class-based context
+    coverage:      new r.Pointer(r.uint16, Coverage),
+    classDef:      new r.Pointer(r.uint16, ClassDef),
+    classSetCnt:   r.uint16,
+    classSet:      new r.Array(new r.Pointer(r.uint16, ClassSet), 'classSetCnt')
+  },
+  3: {
+    glyphCount:    r.uint16,
+    lookupCount:   r.uint16,
+    coverages:     new r.Array(new r.Pointer(r.uint16, Coverage), 'glyphCount'),
+    lookupRecords: new r.Array(LookupRecord, 'lookupCount')
+  }
+});
+
+//######################################################
+// Chaining Contextual Substitution/Positioning Tables #
+//######################################################
+
+let ChainRule = new r.Struct({
+  backtrackGlyphCount:  r.uint16,
+  backtrack:            new r.Array(r.uint16, 'backtrackGlyphCount'),
+  inputGlyphCount:      r.uint16,
+  input:                new r.Array(r.uint16, t => t.inputGlyphCount - 1),
+  lookaheadGlyphCount:  r.uint16,
+  lookahead:            new r.Array(r.uint16, 'lookaheadGlyphCount'),
+  lookupCount:          r.uint16,
+  lookupRecords:        new r.Array(LookupRecord, 'lookupCount')
+});
+
+let ChainRuleSet = new r.Array(new r.Pointer(r.uint16, ChainRule), r.uint16);
+
+export let ChainingContext = new r.VersionedStruct(r.uint16, {
+  1: { // Simple context glyph substitution
+    coverage:           new r.Pointer(r.uint16, Coverage),
+    chainCount:         r.uint16,
+    chainRuleSets:      new r.Array(new r.Pointer(r.uint16, ChainRuleSet), 'chainCount')
+  },
+
+  2: { // Class-based chaining context
+    coverage:           new r.Pointer(r.uint16, Coverage),
+    backtrackClassDef:  new r.Pointer(r.uint16, ClassDef),
+    inputClassDef:      new r.Pointer(r.uint16, ClassDef),
+    lookaheadClassDef:  new r.Pointer(r.uint16, ClassDef),
+    chainCount:         r.uint16,
+    chainClassSet:      new r.Array(new r.Pointer(r.uint16, ChainRuleSet), 'chainCount')
+  },
+
+  3: { // Coverage-based chaining context
+    backtrackGlyphCount:    r.uint16,
+    backtrackCoverage:      new r.Array(new r.Pointer(r.uint16, Coverage), 'backtrackGlyphCount'),
+    inputGlyphCount:        r.uint16,
+    inputCoverage:          new r.Array(new r.Pointer(r.uint16, Coverage), 'inputGlyphCount'),
+    lookaheadGlyphCount:    r.uint16,
+    lookaheadCoverage:      new r.Array(new r.Pointer(r.uint16, Coverage), 'lookaheadGlyphCount'),
+    lookupCount:            r.uint16,
+    lookupRecords:          new r.Array(LookupRecord, 'lookupCount')
+  }
+});

package/src/tables/post.js

@@ -0,0 +1,34 @@
+import * as r from 'restructure';
+
+// PostScript information
+export default new r.VersionedStruct(r.fixed32, {
+  header: { // these fields exist at the top of all versions
+    italicAngle:        r.fixed32, // Italic angle in counter-clockwise degrees from the vertical.
+    underlinePosition:  r.int16,   // Suggested distance of the top of the underline from the baseline
+    underlineThickness: r.int16,   // Suggested values for the underline thickness
+    isFixedPitch:       r.uint32,  // Whether the font is monospaced
+    minMemType42:       r.uint32,  // Minimum memory usage when a TrueType font is downloaded as a Type 42 font
+    maxMemType42:       r.uint32,  // Maximum memory usage when a TrueType font is downloaded as a Type 42 font
+    minMemType1:        r.uint32,  // Minimum memory usage when a TrueType font is downloaded as a Type 1 font
+    maxMemType1:        r.uint32   // Maximum memory usage when a TrueType font is downloaded as a Type 1 font
+  },
+
+  1: {}, // version 1 has no additional fields
+
+  2: {
+    numberOfGlyphs: r.uint16,
+    glyphNameIndex: new r.Array(r.uint16, 'numberOfGlyphs'),
+    names:          new r.Array(new r.String(r.uint8))
+  },
+
+  2.5: {
+    numberOfGlyphs: r.uint16,
+    offsets:        new r.Array(r.uint8, 'numberOfGlyphs')
+  },
+
+  3: {}, // version 3 has no additional fields
+
+  4: {
+    map: new r.Array(r.uint32, t => t.parent.maxp.numGlyphs)
+  }
+});

package/src/tables/prep.js

@@ -0,0 +1,6 @@
+import * as r from 'restructure';
+
+// Set of instructions executed whenever the point size or font transformation change
+export default new r.Struct({
+  controlValueProgram: new r.Array(r.uint8)
+});

package/src/tables/sbix.js

@@ -0,0 +1,17 @@
+import * as r from 'restructure';
+
+let ImageTable = new r.Struct({
+  ppem: r.uint16,
+  resolution: r.uint16,
+  imageOffsets: new r.Array(new r.Pointer(r.uint32, 'void'), t => t.parent.parent.maxp.numGlyphs + 1)
+});
+
+// This is the Apple sbix table, used by the "Apple Color Emoji" font.
+// It includes several image tables with images for each bitmap glyph
+// of several different sizes.
+export default new r.Struct({
+  version: r.uint16,
+  flags: new r.Bitfield(r.uint16, ['renderOutlines']),
+  numImgTables: r.uint32,
+  imageTables: new r.Array(new r.Pointer(r.uint32, ImageTable), 'numImgTables')
+});

package/src/tables/variations.js

@@ -0,0 +1,80 @@
+import {Feature} from './opentype';
+import * as r from 'restructure';
+
+/*******************
+ * Variation Store *
+ *******************/
+
+let F2DOT14 = new r.Fixed(16, 'BE', 14);
+let RegionAxisCoordinates = new r.Struct({
+  startCoord: F2DOT14,
+  peakCoord: F2DOT14,
+  endCoord: F2DOT14
+});
+
+let VariationRegionList = new r.Struct({
+  axisCount: r.uint16,
+  regionCount: r.uint16,
+  variationRegions: new r.Array(new r.Array(RegionAxisCoordinates, 'axisCount'), 'regionCount')
+});
+
+let DeltaSet = new r.Struct({
+  shortDeltas: new r.Array(r.int16, t => t.parent.shortDeltaCount),
+  regionDeltas: new r.Array(r.int8, t => t.parent.regionIndexCount - t.parent.shortDeltaCount),
+  deltas: t => t.shortDeltas.concat(t.regionDeltas)
+});
+
+let ItemVariationData = new r.Struct({
+  itemCount: r.uint16,
+  shortDeltaCount: r.uint16,
+  regionIndexCount: r.uint16,
+  regionIndexes: new r.Array(r.uint16, 'regionIndexCount'),
+  deltaSets: new r.Array(DeltaSet, 'itemCount')
+});
+
+export let ItemVariationStore = new r.Struct({
+  format: r.uint16,
+  variationRegionList: new r.Pointer(r.uint32, VariationRegionList),
+  variationDataCount: r.uint16,
+  itemVariationData: new r.Array(new r.Pointer(r.uint32, ItemVariationData), 'variationDataCount')
+});
+
+/**********************
+ * Feature Variations *
+ **********************/
+
+let ConditionTable = new r.VersionedStruct(r.uint16, {
+  1: {
+    axisIndex: r.uint16,
+    filterRangeMinValue: F2DOT14,
+    filterRangeMaxValue: F2DOT14
+  }
+});
+
+let ConditionSet = new r.Struct({
+  conditionCount: r.uint16,
+  conditionTable: new r.Array(new r.Pointer(r.uint32, ConditionTable), 'conditionCount')
+});
+
+let FeatureTableSubstitutionRecord = new r.Struct({
+  featureIndex: r.uint16,
+  alternateFeatureTable: new r.Pointer(r.uint32, Feature, {type: 'parent'})
+});
+
+let FeatureTableSubstitution = new r.Struct({
+  version: r.fixed32,
+  substitutionCount: r.uint16,
+  substitutions: new r.Array(FeatureTableSubstitutionRecord, 'substitutionCount')
+});
+
+let FeatureVariationRecord = new r.Struct({
+  conditionSet: new r.Pointer(r.uint32, ConditionSet, {type: 'parent'}),
+  featureTableSubstitution: new r.Pointer(r.uint32, FeatureTableSubstitution, {type: 'parent'})
+});
+
+export let FeatureVariations = new r.Struct({
+  majorVersion: r.uint16,
+  minorVersion: r.uint16,
+  featureVariationRecordCount: r.uint32,
+  featureVariationRecords: new r.Array(FeatureVariationRecord, 'featureVariationRecordCount')
+});

package/src/tables/vhea.js

@@ -0,0 +1,19 @@
+import * as r from 'restructure';
+
+// Vertical Header Table
+export default new r.Struct({
+  version:                r.fixed32, // Version number of the Vertical Header Table
+  ascent:                 r.int16,   // The vertical typographic ascender for this font
+  descent:                r.int16,   // The vertical typographic descender for this font
+  lineGap:                r.int16,   // The vertical typographic line gap for this font
+  advanceHeightMax:       r.uint16,  // The maximum advance height measurement found in the font
+  minTopSideBearing:      r.int16,   // The minimum top side bearing measurement found in the font
+  minBottomSideBearing:   r.int16,   // The minimum bottom side bearing measurement found in the font
+  yMaxExtent:             r.int16,
+  caretSlopeRise:         r.int16,   // Caret slope (rise/run)
+  caretSlopeRun:          r.int16,
+  caretOffset:            r.int16,   // Set value equal to 0 for nonslanted fonts
+  reserved:               new r.Reserved(r.int16, 4),
+  metricDataFormat:       r.int16,   // Set to 0
+  numberOfMetrics:        r.uint16   // Number of advance heights in the Vertical Metrics table
+});

package/src/tables/vmtx.js

@@ -0,0 +1,12 @@
+import * as r from 'restructure';
+
+let VmtxEntry = new r.Struct({
+  advance: r.uint16,  // The advance height of the glyph
+  bearing: r.int16    // The top sidebearing of the glyph
+});
+
+// Vertical Metrics Table
+export default new r.Struct({
+  metrics:  new r.LazyArray(VmtxEntry, t => t.parent.vhea.numberOfMetrics),
+  bearings: new r.LazyArray(r.int16, t => t.parent.maxp.numGlyphs - t.parent.vhea.numberOfMetrics)
+});

package/src/utils.js

@@ -0,0 +1,62 @@
+export function binarySearch(arr, cmp) {
+  let min = 0;
+  let max = arr.length - 1;
+  while (min <= max) {
+    let mid = (min + max) >> 1;
+    let res = cmp(arr[mid]);
+
+    if (res < 0) {
+      max = mid - 1;
+    } else if (res > 0) {
+      min = mid + 1;
+    } else {
+      return mid;
+    }
+  }
+
+  return -1;
+}
+
+export function range(index, end) {
+  let range = [];
+  while (index < end) {
+    range.push(index++);
+  }
+  return range;
+}
+
+export const asciiDecoder = new TextDecoder('ascii');
+
+// Based on https://github.com/niklasvh/base64-arraybuffer. MIT license.
+const CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const LOOKUP = new Uint8Array(256);
+for (let i = 0; i < CHARS.length; i++) {
+  LOOKUP[CHARS.charCodeAt(i)] = i;
+}
+
+export function decodeBase64(base64) {
+  let bufferLength = base64.length * 0.75;
+
+  if (base64[base64.length - 1] === '=') {
+    bufferLength--;
+    if (base64[base64.length - 2] === '=') {
+      bufferLength--;
+    }
+  }
+
+  let bytes = new Uint8Array(bufferLength);
+  let p = 0;
+
+  for (let i = 0, len = base64.length; i < len; i += 4) {
+    let encoded1 = LOOKUP[base64.charCodeAt(i)];
+    let encoded2 = LOOKUP[base64.charCodeAt(i + 1)];
+    let encoded3 = LOOKUP[base64.charCodeAt(i + 2)];
+    let encoded4 = LOOKUP[base64.charCodeAt(i + 3)];
+
+    bytes[p++] = (encoded1 << 2) | (encoded2 >> 4);
+    bytes[p++] = ((encoded2 & 15) << 4) | (encoded3 >> 2);
+    bytes[p++] = ((encoded3 & 3) << 6) | (encoded4 & 63);
+  }
+
+  return bytes;
+}