@cantoo/fontkit 2.0.4

package/src/subset/CFFSubset.js

@@ -0,0 +1,176 @@
+import Subset from './Subset';
+import CFFTop from '../cff/CFFTop';
+import standardStrings from '../cff/CFFStandardStrings';
+
+export default class CFFSubset extends Subset {
+  constructor(font) {
+    super(font);
+
+    this.cff = this.font['CFF '];
+    if (!this.cff) {
+      throw new Error('Not a CFF Font');
+    }
+  }
+
+  includeTable() {
+    throw new Error('includeTable is only supported for TrueType (glyf) subsets, not CFF.');
+  }
+
+  subsetCharstrings() {
+    this.charstrings = [];
+    let gsubrs = {};
+
+    for (let gid of this.glyphs) {
+      this.charstrings.push(this.cff.getCharString(gid));
+
+      let glyph = this.font.getGlyph(gid);
+      void glyph.path; // this causes the glyph to be parsed
+
+      for (let subr in glyph._usedGsubrs) {
+        gsubrs[subr] = true;
+      }
+    }
+
+    this.gsubrs = this.subsetSubrs(this.cff.globalSubrIndex, gsubrs);
+  }
+
+  subsetSubrs(subrs, used) {
+    let res = [];
+    for (let i = 0; i < subrs.length; i++) {
+      let subr = subrs[i];
+      if (used[i]) {
+        this.cff.stream.pos = subr.offset;
+        res.push(this.cff.stream.readBuffer(subr.length));
+      } else {
+        res.push(new Uint8Array([11])); // return
+      }
+    }
+
+    return res;
+  }
+
+  subsetFontdict(topDict) {
+    topDict.FDArray = [];
+    topDict.FDSelect = {
+      version: 0,
+      fds: []
+    };
+
+    let used_fds = {};
+    let used_subrs = [];
+    let fd_select = {};
+    for (let gid of this.glyphs) {
+      let fd = this.cff.fdForGlyph(gid);
+      if (fd == null) {
+        continue;
+      }
+
+      if (!used_fds[fd]) {
+        topDict.FDArray.push(Object.assign({}, this.cff.topDict.FDArray[fd]));
+        used_subrs.push({});
+        fd_select[fd] = topDict.FDArray.length - 1;
+      }
+
+      used_fds[fd] = true;
+      topDict.FDSelect.fds.push(fd_select[fd]);
+
+      let glyph = this.font.getGlyph(gid);
+      void glyph.path; // this causes the glyph to be parsed
+      for (let subr in glyph._usedSubrs) {
+        used_subrs[fd_select[fd]][subr] = true;
+      }
+    }
+
+    for (let i = 0; i < topDict.FDArray.length; i++) {
+      let dict = topDict.FDArray[i];
+      delete dict.FontName;
+      if (dict.Private && dict.Private.Subrs) {
+        dict.Private = Object.assign({}, dict.Private);
+        dict.Private.Subrs = this.subsetSubrs(dict.Private.Subrs, used_subrs[i]);
+      }
+    }
+
+    return;
+  }
+
+  createCIDFontdict(topDict) {
+    let used_subrs = {};
+    for (let gid of this.glyphs) {
+      let glyph = this.font.getGlyph(gid);
+      void glyph.path; // this causes the glyph to be parsed
+
+      for (let subr in glyph._usedSubrs) {
+        used_subrs[subr] = true;
+      }
+    }
+
+    let privateDict = Object.assign({}, this.cff.topDict.Private);
+    if (this.cff.topDict.Private && this.cff.topDict.Private.Subrs) {
+      privateDict.Subrs = this.subsetSubrs(this.cff.topDict.Private.Subrs, used_subrs);
+    }
+
+    topDict.FDArray = [{ Private: privateDict }];
+    return topDict.FDSelect = {
+      version: 3,
+      nRanges: 1,
+      ranges: [{ first: 0, fd: 0 }],
+      sentinel: this.charstrings.length
+    };
+  }
+
+  addString(string) {
+    if (!string) {
+      return null;
+    }
+
+    if (!this.strings) {
+      this.strings = [];
+    }
+
+    this.strings.push(string);
+    return standardStrings.length + this.strings.length - 1;
+  }
+
+  encode() {
+    this.subsetCharstrings();
+
+    let charset = {
+      version: this.charstrings.length > 255 ? 2 : 1,
+      ranges: this.charstrings.length > 1
+        ? [{ first: 1, nLeft: this.charstrings.length - 2 }]
+        : []
+    };
+
+    let topDict = Object.assign({}, this.cff.topDict);
+    topDict.Private = null;
+    topDict.charset = charset;
+    topDict.Encoding = null;
+    topDict.CharStrings = this.charstrings;
+
+    for (let key of ['version', 'Notice', 'Copyright', 'FullName', 'FamilyName', 'Weight', 'PostScript', 'BaseFontName', 'FontName']) {
+      topDict[key] = this.addString(this.cff.string(topDict[key]));
+    }
+
+    topDict.ROS = [this.addString('Adobe'), this.addString('Identity'), 0];
+    topDict.CIDCount = this.charstrings.length;
+
+    if (this.cff.isCIDFont) {
+      this.subsetFontdict(topDict);
+    } else {
+      this.createCIDFontdict(topDict);
+    }
+
+    let top = {
+      version: 1,
+      hdrSize: this.cff.hdrSize,
+      offSize: 4,
+      header: this.cff.header,
+      nameIndex: [this.cff.postscriptName],
+      topDictIndex: [topDict],
+      stringIndex: this.strings,
+      globalSubrIndex: this.gsubrs
+    };
+
+    return CFFTop.toBuffer(top);
+  }
+}

package/src/subset/Subset.js

@@ -0,0 +1,63 @@
+import Tables from '../tables';
+
+// Tables written by TTFSubset.encode; must not be overwritten via includeTable.
+const MANAGED_TTF_TABLES = [
+  'head', 'hhea', 'loca', 'maxp', 'cvt ', 'prep', 'glyf', 'hmtx', 'fpgm'
+];
+
+export default class Subset {
+  constructor(font) {
+    this.font = font;
+    this.glyphs = [];
+    this.mapping = {};
+    // Extra OT table tags to copy into a TTF subset (e.g. 'OS/2', 'name', 'post').
+    this.includedTables = [];
+
+    // always include the missing glyph
+    this.includeGlyph(0);
+  }
+
+  includeGlyph(glyph) {
+    if (typeof glyph === 'object') {
+      glyph = glyph.id;
+    }
+
+    if (this.mapping[glyph] == null) {
+      this.glyphs.push(glyph);
+      this.mapping[glyph] = this.glyphs.length - 1;
+    }
+
+    return this.mapping[glyph];
+  }
+
+  // Copy an OT table into the TTF subset (tag is a 4-byte string, e.g. 'OS/2').
+  // Only honored by TTFSubset.encode; CFFSubset overrides this to throw.
+  includeTable(tag) {
+    if (typeof tag !== 'string' || tag.length !== 4) {
+      throw new Error(
+        `Invalid OpenType table tag ${JSON.stringify(tag)}: tags must be 4 characters ` +
+        `(pad with spaces if needed, e.g. "cvt ").`
+      );
+    }
+
+    if (MANAGED_TTF_TABLES.includes(tag)) {
+      throw new Error(
+        `Table "${tag}" is already managed by the TrueType subsetter and cannot be included explicitly.`
+      );
+    }
+
+    if (!this.font.directory.tables[tag]) {
+      throw new Error(`Table "${tag}" is not present in this font.`);
+    }
+
+    if (!Tables[tag]) {
+      throw new Error(`Table "${tag}" cannot be encoded (no encoder registered in fontkit).`);
+    }
+
+    if (!this.includedTables.includes(tag)) {
+      this.includedTables.push(tag);
+    }
+
+    return this;
+  }
+}

package/src/subset/TTFSubset.js

@@ -0,0 +1,130 @@
+import cloneDeep from 'clone';
+import Subset from './Subset';
+import Directory from '../tables/directory';
+import TTFGlyphEncoder from '../glyph/TTFGlyphEncoder';
+
+export default class TTFSubset extends Subset {
+  constructor(font) {
+    super(font);
+    this.glyphEncoder = new TTFGlyphEncoder;
+  }
+
+  _addGlyph(gid) {
+    let glyph = this.font.getGlyph(gid);
+    let glyf = glyph._decode();
+
+    // get the offset to the glyph from the loca table
+    let curOffset = this.font.loca.offsets[gid];
+    let nextOffset = this.font.loca.offsets[gid + 1];
+
+    let stream = this.font._getTableStream('glyf');
+    stream.pos += curOffset;
+
+    let buffer = stream.readBuffer(nextOffset - curOffset);
+
+    // if it is a compound glyph, include its components
+    if (glyf && glyf.numberOfContours < 0) {
+      buffer = new Uint8Array(buffer);
+      let view = new DataView(buffer.buffer);
+      for (let component of glyf.components) {
+        gid = this.includeGlyph(component.glyphID);
+        view.setUint16(component.pos, gid);
+      }
+    } else if (glyf && this.font._variationProcessor) {
+      // If this is a TrueType variation glyph, re-encode the path
+      buffer = this.glyphEncoder.encodeSimple(glyph.path, glyf.instructions);
+    }
+
+    this.glyf.push(buffer);
+    this.loca.offsets.push(this.offset);
+
+    this.hmtx.metrics.push({
+      advance: glyph.advanceWidth,
+      bearing: glyph._getMetrics().leftBearing
+    });
+
+    this.offset += buffer.length;
+    return this.glyf.length - 1;
+  }
+
+  encode() {
+    // tables required by PDF spec:
+    //   head, hhea, loca, maxp, cvt , prep, glyf, hmtx, fpgm
+    //
+    // additional tables required for standalone fonts:
+    //   name, cmap, OS/2, post
+
+    this.glyf = [];
+    this.offset = 0;
+    this.loca = {
+      offsets: [],
+      version: this.font.loca.version
+    };
+
+    this.hmtx = {
+      metrics: [],
+      bearings: []
+    };
+
+    // include all the glyphs
+    // not using a for loop because we need to support adding more
+    // glyphs to the array as we go, and CoffeeScript caches the length.
+    let i = 0;
+    while (i < this.glyphs.length) {
+      this._addGlyph(this.glyphs[i++]);
+    }
+
+    let maxp = cloneDeep(this.font.maxp);
+    maxp.numGlyphs = this.glyf.length;
+
+    this.loca.offsets.push(this.offset);
+
+    let head = cloneDeep(this.font.head);
+    head.indexToLocFormat = this.loca.version;
+
+    let hhea = cloneDeep(this.font.hhea);
+    hhea.numberOfMetrics = this.hmtx.metrics.length;
+
+    // map = []
+    // for index in [0...256]
+    //     if index < @numGlyphs
+    //         map[index] = index
+    //     else
+    //         map[index] = 0
+    //
+    // cmapTable =
+    //     version: 0
+    //     length: 262
+    //     language: 0
+    //     codeMap: map
+    //
+    // cmap =
+    //     version: 0
+    //     numSubtables: 1
+    //     tables: [
+    //         platformID: 1
+    //         encodingID: 0
+    //         table: cmapTable
+    //     ]
+
+    // TODO: subset prep, cvt, fpgm?
+    // The following is the minimum set of tables.
+    let t =  {
+      head,
+      hhea,
+      loca: this.loca,
+      maxp,
+      'cvt ': this.font['cvt '],
+      prep: this.font.prep,
+      glyf: this.glyf,
+      hmtx: this.hmtx,
+      fpgm: this.font.fpgm,
+    }
+
+    for (const tag of this.includedTables) {
+      t[tag] = cloneDeep(this.font[tag]);
+    }
+
+    return Directory.toBuffer({tables: t});
+  }
+}

package/src/tables/BASE.js

@@ -0,0 +1,78 @@
+import * as r from 'restructure';
+import {Device} from './opentype';
+import {ItemVariationStore} from './variations';
+
+let BaseCoord = new r.VersionedStruct(r.uint16, {
+  1: { // Design units only
+    coordinate:   r.int16 // X or Y value, in design units
+  },
+
+  2: { // Design units plus contour point
+    coordinate:     r.int16,   // X or Y value, in design units
+    referenceGlyph: r.uint16,  // GlyphID of control glyph
+    baseCoordPoint: r.uint16   // Index of contour point on the referenceGlyph
+  },
+
+  3: { // Design units plus Device table
+    coordinate:   r.int16,                         // X or Y value, in design units
+    deviceTable:  new r.Pointer(r.uint16, Device)  // Device table for X or Y value
+  }
+});
+
+let BaseValues = new r.Struct({
+  defaultIndex:   r.uint16,  // Index of default baseline for this script-same index in the BaseTagList
+  baseCoordCount: r.uint16,
+  baseCoords:     new r.Array(new r.Pointer(r.uint16, BaseCoord), 'baseCoordCount')
+});
+
+let FeatMinMaxRecord = new r.Struct({
+  tag:        new r.String(4),  // 4-byte feature identification tag-must match FeatureTag in FeatureList
+  minCoord:   new r.Pointer(r.uint16, BaseCoord, {type: 'parent'}), // May be NULL
+  maxCoord:   new r.Pointer(r.uint16, BaseCoord, {type: 'parent'})  // May be NULL
+});
+
+let MinMax = new r.Struct({
+  minCoord:           new r.Pointer(r.uint16, BaseCoord),  // May be NULL
+  maxCoord:           new r.Pointer(r.uint16, BaseCoord),  // May be NULL
+  featMinMaxCount:    r.uint16,                            // May be 0
+  featMinMaxRecords:  new r.Array(FeatMinMaxRecord, 'featMinMaxCount') // In alphabetical order
+});
+
+let BaseLangSysRecord = new r.Struct({
+  tag:    new r.String(4),  // 4-byte language system identification tag
+  minMax: new r.Pointer(r.uint16, MinMax, {type: 'parent'})
+});
+
+let BaseScript = new r.Struct({
+  baseValues:         new r.Pointer(r.uint16, BaseValues), // May be NULL
+  defaultMinMax:      new r.Pointer(r.uint16, MinMax),     // May be NULL
+  baseLangSysCount:   r.uint16,                            // May be 0
+  baseLangSysRecords: new r.Array(BaseLangSysRecord, 'baseLangSysCount') // in alphabetical order by BaseLangSysTag
+});
+
+let BaseScriptRecord = new r.Struct({
+  tag:      new r.String(4),  // 4-byte script identification tag
+  script:   new r.Pointer(r.uint16, BaseScript, {type: 'parent'})
+});
+
+let BaseScriptList = new r.Array(BaseScriptRecord, r.uint16);
+
+// Array of 4-byte baseline identification tags-must be in alphabetical order
+let BaseTagList = new r.Array(new r.String(4), r.uint16);
+
+let Axis = new r.Struct({
+  baseTagList:    new r.Pointer(r.uint16, BaseTagList),  // May be NULL
+  baseScriptList: new r.Pointer(r.uint16, BaseScriptList)
+});
+
+export default new r.VersionedStruct(r.uint32, {
+  header: {
+    horizAxis:    new r.Pointer(r.uint16, Axis),   // May be NULL
+    vertAxis:     new r.Pointer(r.uint16, Axis)    // May be NULL
+  },
+
+  0x00010000: {},
+  0x00010001: {
+    itemVariationStore: new r.Pointer(r.uint32, ItemVariationStore)
+  }
+});

package/src/tables/COLR.js

@@ -0,0 +1,25 @@
+import * as r from 'restructure';
+
+let LayerRecord = new r.Struct({
+  gid: r.uint16,          // Glyph ID of layer glyph (must be in z-order from bottom to top).
+  paletteIndex: r.uint16  // Index value to use in the appropriate palette. This value must
+});                       // be less than numPaletteEntries in the CPAL table, except for
+                          // the special case noted below. Each palette entry is 16 bits.
+                          // A palette index of 0xFFFF is a special case indicating that
+                          // the text foreground color should be used.
+
+let BaseGlyphRecord = new r.Struct({
+  gid: r.uint16,             // Glyph ID of reference glyph. This glyph is for reference only
+                             // and is not rendered for color.
+  firstLayerIndex: r.uint16, // Index (from beginning of the Layer Records) to the layer record.
+                             // There will be numLayers consecutive entries for this base glyph.
+  numLayers: r.uint16
+});
+
+export default new r.Struct({
+  version: r.uint16,
+  numBaseGlyphRecords: r.uint16,
+  baseGlyphRecord: new r.Pointer(r.uint32, new r.Array(BaseGlyphRecord, 'numBaseGlyphRecords')),
+  layerRecords: new r.Pointer(r.uint32, new r.Array(LayerRecord, 'numLayerRecords'), { lazy: true }),
+  numLayerRecords: r.uint16
+});

package/src/tables/CPAL.js

@@ -0,0 +1,24 @@
+import * as r from 'restructure';
+
+let ColorRecord = new r.Struct({
+  blue: r.uint8,
+  green: r.uint8,
+  red: r.uint8,
+  alpha: r.uint8
+});
+
+export default new r.VersionedStruct(r.uint16, {
+  header: {
+    numPaletteEntries: r.uint16,
+    numPalettes: r.uint16,
+    numColorRecords: r.uint16,
+    colorRecords: new r.Pointer(r.uint32, new r.Array(ColorRecord, 'numColorRecords')),
+    colorRecordIndices: new r.Array(r.uint16, 'numPalettes'),
+  },
+  0: {},
+  1: {
+    offsetPaletteTypeArray: new r.Pointer(r.uint32, new r.Array(r.uint32, 'numPalettes')),
+    offsetPaletteLabelArray: new r.Pointer(r.uint32, new r.Array(r.uint16, 'numPalettes')),
+    offsetPaletteEntryLabelArray: new r.Pointer(r.uint32, new r.Array(r.uint16, 'numPaletteEntries'))
+  }
+});

package/src/tables/DSIG.js

@@ -0,0 +1,21 @@
+import * as r from 'restructure';
+
+let Signature = new r.Struct({
+  format: r.uint32,
+  length: r.uint32,
+  offset: r.uint32
+});
+
+let SignatureBlock = new r.Struct({
+  reserved:       new r.Reserved(r.uint16, 2),
+  cbSignature:    r.uint32,  // Length (in bytes) of the PKCS#7 packet in pbSignature
+  signature:      new r.Buffer('cbSignature')
+});
+
+export default new r.Struct({
+  ulVersion:       r.uint32,  // Version number of the DSIG table (0x00000001)
+  usNumSigs:       r.uint16,  // Number of signatures in the table
+  usFlag:          r.uint16,  // Permission flags
+  signatures:      new r.Array(Signature, 'usNumSigs'),
+  signatureBlocks: new r.Array(SignatureBlock, 'usNumSigs')
+});

package/src/tables/EBDT.js

@@ -0,0 +1,91 @@
+import * as r from 'restructure';
+
+export let BigMetrics = new r.Struct({
+  height: r.uint8,
+  width: r.uint8,
+  horiBearingX: r.int8,
+  horiBearingY: r.int8,
+  horiAdvance: r.uint8,
+  vertBearingX: r.int8,
+  vertBearingY: r.int8,
+  vertAdvance: r.uint8
+});
+
+export let SmallMetrics = new r.Struct({
+  height: r.uint8,
+  width: r.uint8,
+  bearingX: r.int8,
+  bearingY: r.int8,
+  advance: r.uint8
+});
+
+let EBDTComponent = new r.Struct({
+  glyph: r.uint16,
+  xOffset: r.int8,
+  yOffset: r.int8
+});
+
+class ByteAligned {}
+
+class BitAligned {}
+
+export let glyph = new r.VersionedStruct('version', {
+  1: {
+    metrics: SmallMetrics,
+    data: ByteAligned
+  },
+
+  2: {
+    metrics: SmallMetrics,
+    data: BitAligned
+  },
+
+  // format 3 is deprecated
+  // format 4 is not supported by Microsoft
+
+  5: {
+    data: BitAligned
+  },
+
+  6: {
+    metrics: BigMetrics,
+    data: ByteAligned
+  },
+
+  7: {
+    metrics: BigMetrics,
+    data: BitAligned
+  },
+
+  8: {
+    metrics: SmallMetrics,
+    pad: new r.Reserved(r.uint8),
+    numComponents: r.uint16,
+    components: new r.Array(EBDTComponent, 'numComponents')
+  },
+
+  9: {
+    metrics: BigMetrics,
+    pad: new r.Reserved(r.uint8),
+    numComponents: r.uint16,
+    components: new r.Array(EBDTComponent, 'numComponents')
+  },
+
+  17: {
+    metrics: SmallMetrics,
+    dataLen: r.uint32,
+    data: new r.Buffer('dataLen')
+  },
+
+  18: {
+    metrics: BigMetrics,
+    dataLen: r.uint32,
+    data: new r.Buffer('dataLen')
+  },
+
+  19: {
+    dataLen: r.uint32,
+    data: new r.Buffer('dataLen')
+  }
+});
+

package/src/tables/EBLC.js

@@ -0,0 +1,80 @@
+import * as r from 'restructure';
+import {BigMetrics} from './EBDT';
+
+let SBitLineMetrics = new r.Struct({
+  ascender: r.int8,
+  descender: r.int8,
+  widthMax: r.uint8,
+  caretSlopeNumerator: r.int8,
+  caretSlopeDenominator: r.int8,
+  caretOffset: r.int8,
+  minOriginSB: r.int8,
+  minAdvanceSB: r.int8,
+  maxBeforeBL: r.int8,
+  minAfterBL: r.int8,
+  pad: new r.Reserved(r.int8, 2)
+});
+
+let CodeOffsetPair = new r.Struct({
+  glyphCode: r.uint16,
+  offset: r.uint16
+});
+
+let IndexSubtable = new r.VersionedStruct(r.uint16, {
+  header: {
+    imageFormat: r.uint16,
+    imageDataOffset: r.uint32
+  },
+
+  1: {
+    offsetArray: new r.Array(r.uint32, t => t.parent.lastGlyphIndex - t.parent.firstGlyphIndex + 1)
+  },
+
+  2: {
+    imageSize: r.uint32,
+    bigMetrics: BigMetrics
+  },
+
+  3: {
+    offsetArray: new r.Array(r.uint16, t => t.parent.lastGlyphIndex - t.parent.firstGlyphIndex + 1)
+  },
+
+  4: {
+    numGlyphs: r.uint32,
+    glyphArray: new r.Array(CodeOffsetPair, t => t.numGlyphs + 1)
+  },
+
+  5: {
+    imageSize: r.uint32,
+    bigMetrics: BigMetrics,
+    numGlyphs: r.uint32,
+    glyphCodeArray: new r.Array(r.uint16, 'numGlyphs')
+  }
+});
+
+let IndexSubtableArray = new r.Struct({
+  firstGlyphIndex: r.uint16,
+  lastGlyphIndex: r.uint16,
+  subtable: new r.Pointer(r.uint32, IndexSubtable)
+});
+
+let BitmapSizeTable = new r.Struct({
+  indexSubTableArray: new r.Pointer(r.uint32, new r.Array(IndexSubtableArray, 1), { type: 'parent' }),
+  indexTablesSize: r.uint32,
+  numberOfIndexSubTables: r.uint32,
+  colorRef: r.uint32,
+  hori: SBitLineMetrics,
+  vert: SBitLineMetrics,
+  startGlyphIndex: r.uint16,
+  endGlyphIndex: r.uint16,
+  ppemX: r.uint8,
+  ppemY: r.uint8,
+  bitDepth: r.uint8,
+  flags: new r.Bitfield(r.uint8, ['horizontal', 'vertical'])
+});
+
+export default new r.Struct({
+  version:  r.uint32, // 0x00020000
+  numSizes: r.uint32,
+  sizes:    new r.Array(BitmapSizeTable, 'numSizes')
+});