@songtonyli/dsh-cli 0.1.12 → 0.1.13

package/node_modules/fontkit/src/cff/CFFDict.js

@@ -0,0 +1,167 @@
+import isEqual from 'fast-deep-equal';
+import * as r from 'restructure';
+import CFFOperand from './CFFOperand';
+import { PropertyDescriptor } from 'restructure';
+
+export default class CFFDict {
+  constructor(ops = []) {
+    this.ops = ops;
+    this.fields = {};
+    for (let field of ops) {
+      let key = Array.isArray(field[0]) ? field[0][0] << 8 | field[0][1] : field[0];
+      this.fields[key] = field;
+    }
+  }
+
+  decodeOperands(type, stream, ret, operands) {
+    if (Array.isArray(type)) {
+      return operands.map((op, i) => this.decodeOperands(type[i], stream, ret, [op]));
+    } else if (type.decode != null) {
+      return type.decode(stream, ret, operands);
+    } else {
+      switch (type) {
+        case 'number':
+        case 'offset':
+        case 'sid':
+          return operands[0];
+        case 'boolean':
+          return !!operands[0];
+        default:
+          return operands;
+      }
+    }
+  }
+
+  encodeOperands(type, stream, ctx, operands) {
+    if (Array.isArray(type)) {
+      return operands.map((op, i) => this.encodeOperands(type[i], stream, ctx, op)[0]);
+    } else if (type.encode != null) {
+      return type.encode(stream, operands, ctx);
+    } else if (typeof operands === 'number') {
+      return [operands];
+    } else if (typeof operands === 'boolean') {
+      return [+operands];
+    } else if (Array.isArray(operands)) {
+      return operands;
+    } else {
+      return [operands];
+    }
+  }
+
+  decode(stream, parent) {
+    let end = stream.pos + parent.length;
+    let ret = {};
+    let operands = [];
+
+    // define hidden properties
+    Object.defineProperties(ret, {
+      parent:         { value: parent },
+      _startOffset:   { value: stream.pos }
+    });
+
+    // fill in defaults
+    for (let key in this.fields) {
+      let field = this.fields[key];
+      ret[field[1]] = field[3];
+    }
+
+    while (stream.pos < end) {
+      let b = stream.readUInt8();
+      if (b < 28) {
+        if (b === 12) {
+          b = (b << 8) | stream.readUInt8();
+        }
+
+        let field = this.fields[b];
+        if (!field) {
+          throw new Error(`Unknown operator ${b}`);
+        }
+
+        let val = this.decodeOperands(field[2], stream, ret, operands);
+        if (val != null) {
+          if (val instanceof PropertyDescriptor) {
+            Object.defineProperty(ret, field[1], val);
+          } else {
+            ret[field[1]] = val;
+          }
+        }
+
+        operands = [];
+      } else {
+        operands.push(CFFOperand.decode(stream, b));
+      }
+    }
+
+    return ret;
+  }
+
+  size(dict, parent, includePointers = true) {
+    let ctx = {
+      parent,
+      val: dict,
+      pointerSize: 0,
+      startOffset: parent.startOffset || 0
+    };
+
+    let len = 0;
+
+    for (let k in this.fields) {
+      let field = this.fields[k];
+      let val = dict[field[1]];
+      if (val == null || isEqual(val, field[3])) {
+        continue;
+      }
+
+      let operands = this.encodeOperands(field[2], null, ctx, val);
+      for (let op of operands) {
+        len += CFFOperand.size(op);
+      }
+
+      let key = Array.isArray(field[0]) ? field[0] : [field[0]];
+      len += key.length;
+    }
+
+    if (includePointers) {
+      len += ctx.pointerSize;
+    }
+
+    return len;
+  }
+
+  encode(stream, dict, parent) {
+    let ctx = {
+      pointers: [],
+      startOffset: stream.pos,
+      parent,
+      val: dict,
+      pointerSize: 0
+    };
+
+    ctx.pointerOffset = stream.pos + this.size(dict, ctx, false);
+
+    for (let field of this.ops) {
+      let val = dict[field[1]];
+      if (val == null || isEqual(val, field[3])) {
+        continue;
+      }
+
+      let operands = this.encodeOperands(field[2], stream, ctx, val);
+      for (let op of operands) {
+        CFFOperand.encode(stream, op);
+      }
+
+      let key = Array.isArray(field[0]) ? field[0] : [field[0]];
+      for (let op of key) {
+        stream.writeUInt8(op);
+      }
+    }
+
+    let i = 0;
+    while (i < ctx.pointers.length) {
+      let ptr = ctx.pointers[i++];
+      ptr.type.encode(stream, ptr.val, ptr.parent);
+    }
+
+    return;
+  }
+}

package/node_modules/fontkit/src/cff/CFFEncodings.js

@@ -0,0 +1,48 @@
+export let StandardEncoding = [
+  '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',
+  '', '', '', '', 'space', 'exclam', 'quotedbl', 'numbersign', 'dollar', 'percent', 'ampersand', 'quoteright',
+  'parenleft', 'parenright', 'asterisk', 'plus', 'comma', 'hyphen', 'period', 'slash', 'zero', 'one', 'two',
+  'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'colon', 'semicolon', 'less', 'equal', 'greater',
+  'question', 'at', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S',
+  'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'bracketleft', 'backslash', 'bracketright', 'asciicircum', 'underscore',
+  'quoteleft', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
+  'u', 'v', 'w', 'x', 'y', 'z', 'braceleft', 'bar', 'braceright', 'asciitilde', '', '', '', '', '', '', '', '',
+  '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',
+  'exclamdown', 'cent', 'sterling', 'fraction', 'yen', 'florin', 'section', 'currency', 'quotesingle',
+  'quotedblleft', 'guillemotleft', 'guilsinglleft', 'guilsinglright', 'fi', 'fl', '', 'endash', 'dagger',
+  'daggerdbl', 'periodcentered', '', 'paragraph', 'bullet', 'quotesinglbase', 'quotedblbase', 'quotedblright',
+  'guillemotright', 'ellipsis', 'perthousand', '', 'questiondown', '', 'grave', 'acute', 'circumflex', 'tilde',
+  'macron', 'breve', 'dotaccent', 'dieresis', '', 'ring', 'cedilla', '', 'hungarumlaut', 'ogonek', 'caron',
+  'emdash', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', 'AE', '', 'ordfeminine', '', '', '',
+  '', 'Lslash', 'Oslash', 'OE', 'ordmasculine', '', '', '', '', '', 'ae', '', '', '', 'dotlessi', '', '',
+  'lslash', 'oslash', 'oe', 'germandbls'
+];
+
+export let ExpertEncoding = [
+  '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',
+  '', '', '', '', 'space', 'exclamsmall', 'Hungarumlautsmall', '', 'dollaroldstyle', 'dollarsuperior',
+  'ampersandsmall', 'Acutesmall', 'parenleftsuperior', 'parenrightsuperior', 'twodotenleader', 'onedotenleader',
+  'comma', 'hyphen', 'period', 'fraction', 'zerooldstyle', 'oneoldstyle', 'twooldstyle', 'threeoldstyle',
+  'fouroldstyle', 'fiveoldstyle', 'sixoldstyle', 'sevenoldstyle', 'eightoldstyle', 'nineoldstyle', 'colon',
+  'semicolon', 'commasuperior', 'threequartersemdash', 'periodsuperior', 'questionsmall', '', 'asuperior',
+  'bsuperior', 'centsuperior', 'dsuperior', 'esuperior', '', '', 'isuperior', '', '', 'lsuperior', 'msuperior',
+  'nsuperior', 'osuperior', '', '', 'rsuperior', 'ssuperior', 'tsuperior', '', 'ff', 'fi', 'fl', 'ffi', 'ffl',
+  'parenleftinferior', '', 'parenrightinferior', 'Circumflexsmall', 'hyphensuperior', 'Gravesmall', 'Asmall',
+  'Bsmall', 'Csmall', 'Dsmall', 'Esmall', 'Fsmall', 'Gsmall', 'Hsmall', 'Ismall', 'Jsmall', 'Ksmall', 'Lsmall',
+  'Msmall', 'Nsmall', 'Osmall', 'Psmall', 'Qsmall', 'Rsmall', 'Ssmall', 'Tsmall', 'Usmall', 'Vsmall', 'Wsmall',
+  'Xsmall', 'Ysmall', 'Zsmall', 'colonmonetary', 'onefitted', 'rupiah', 'Tildesmall', '', '', '', '', '', '', '',
+  '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',
+  'exclamdownsmall', 'centoldstyle', 'Lslashsmall', '', '', 'Scaronsmall', 'Zcaronsmall', 'Dieresissmall',
+  'Brevesmall', 'Caronsmall', '', 'Dotaccentsmall', '', '', 'Macronsmall', '', '', 'figuredash', 'hypheninferior',
+  '', '', 'Ogoneksmall', 'Ringsmall', 'Cedillasmall', '', '', '', 'onequarter', 'onehalf', 'threequarters',
+  'questiondownsmall', 'oneeighth', 'threeeighths', 'fiveeighths', 'seveneighths', 'onethird', 'twothirds', '',
+  '', 'zerosuperior', 'onesuperior', 'twosuperior', 'threesuperior', 'foursuperior', 'fivesuperior',
+  'sixsuperior', 'sevensuperior', 'eightsuperior', 'ninesuperior', 'zeroinferior', 'oneinferior', 'twoinferior',
+  'threeinferior', 'fourinferior', 'fiveinferior', 'sixinferior', 'seveninferior', 'eightinferior',
+  'nineinferior', 'centinferior', 'dollarinferior', 'periodinferior', 'commainferior', 'Agravesmall',
+  'Aacutesmall', 'Acircumflexsmall', 'Atildesmall', 'Adieresissmall', 'Aringsmall', 'AEsmall', 'Ccedillasmall',
+  'Egravesmall', 'Eacutesmall', 'Ecircumflexsmall', 'Edieresissmall', 'Igravesmall', 'Iacutesmall',
+  'Icircumflexsmall', 'Idieresissmall', 'Ethsmall', 'Ntildesmall', 'Ogravesmall', 'Oacutesmall',
+  'Ocircumflexsmall', 'Otildesmall', 'Odieresissmall', 'OEsmall', 'Oslashsmall', 'Ugravesmall', 'Uacutesmall',
+  'Ucircumflexsmall', 'Udieresissmall', 'Yacutesmall', 'Thornsmall', 'Ydieresissmall'
+];

package/node_modules/fontkit/src/cff/CFFFont.js

@@ -0,0 +1,159 @@
+import * as r from 'restructure';
+import CFFIndex from './CFFIndex';
+import CFFTop from './CFFTop';
+import CFFPrivateDict from './CFFPrivateDict';
+import standardStrings from './CFFStandardStrings';
+
+class CFFFont {
+  constructor(stream) {
+    this.stream = stream;
+    this.decode();
+  }
+
+  static decode(stream) {
+    return new CFFFont(stream);
+  }
+
+  decode() {
+    let start = this.stream.pos;
+    let top = CFFTop.decode(this.stream);
+    for (let key in top) {
+      let val = top[key];
+      this[key] = val;
+    }
+
+    if (this.version < 2) {
+      if (this.topDictIndex.length !== 1) {
+        throw new Error("Only a single font is allowed in CFF");
+      }
+
+      this.topDict = this.topDictIndex[0];
+    }
+
+    this.isCIDFont = this.topDict.ROS != null;
+    return this;
+  }
+
+  string(sid) {
+    if (this.version >= 2) {
+      return null;
+    }
+
+    if (sid < standardStrings.length) {
+      return standardStrings[sid];
+    }
+
+    return this.stringIndex[sid - standardStrings.length];
+  }
+
+  get postscriptName() {
+    if (this.version < 2) {
+      return this.nameIndex[0];
+    }
+
+    return null;
+  }
+
+  get fullName() {
+    return this.string(this.topDict.FullName);
+  }
+
+  get familyName() {
+    return this.string(this.topDict.FamilyName);
+  }
+
+  getCharString(glyph) {
+    this.stream.pos = this.topDict.CharStrings[glyph].offset;
+    return this.stream.readBuffer(this.topDict.CharStrings[glyph].length);
+  }
+
+  getGlyphName(gid) {
+    // CFF2 glyph names are in the post table.
+    if (this.version >= 2) {
+      return null;
+    }
+
+    // CID-keyed fonts don't have glyph names
+    if (this.isCIDFont) {
+      return null;
+    }
+
+    let { charset } = this.topDict;
+    if (Array.isArray(charset)) {
+      return charset[gid];
+    }
+
+    if (gid === 0) {
+      return '.notdef';
+    }
+
+    gid -= 1;
+
+    switch (charset.version) {
+      case 0:
+        return this.string(charset.glyphs[gid]);
+
+      case 1:
+      case 2:
+        for (let i = 0; i < charset.ranges.length; i++) {
+          let range = charset.ranges[i];
+          if (range.offset <= gid && gid <= range.offset + range.nLeft) {
+            return this.string(range.first + (gid - range.offset));
+          }
+        }
+        break;
+    }
+
+    return null;
+  }
+
+  fdForGlyph(gid) {
+    if (!this.topDict.FDSelect) {
+      return null;
+    }
+
+    switch (this.topDict.FDSelect.version) {
+      case 0:
+        return this.topDict.FDSelect.fds[gid];
+
+      case 3:
+      case 4:
+        let { ranges } = this.topDict.FDSelect;
+        let low = 0;
+        let high = ranges.length - 1;
+
+        while (low <= high) {
+          let mid = (low + high) >> 1;
+
+          if (gid < ranges[mid].first) {
+            high = mid - 1;
+          } else if (mid < high && gid >= ranges[mid + 1].first) {
+            low = mid + 1;
+          } else {
+            return ranges[mid].fd;
+          }
+        }
+      default:
+        throw new Error(`Unknown FDSelect version: ${this.topDict.FDSelect.version}`);
+    }
+  }
+
+  privateDictForGlyph(gid) {
+    if (this.topDict.FDSelect) {
+      let fd = this.fdForGlyph(gid);
+      if (this.topDict.FDArray[fd]) {
+        return this.topDict.FDArray[fd].Private;
+      }
+
+      return null;
+    }
+
+    if (this.version < 2) {
+      return this.topDict.Private;
+    }
+
+    return this.topDict.FDArray[0].Private;
+  }
+}
+
+export default CFFFont;

package/node_modules/fontkit/src/cff/CFFIndex.js

@@ -0,0 +1,150 @@
+import * as r from 'restructure';
+
+export default class CFFIndex {
+  constructor(type) {
+    this.type = type;
+  }
+
+  getCFFVersion(ctx) {
+    while (ctx && !ctx.hdrSize) {
+      ctx = ctx.parent;
+    }
+
+    return ctx ? ctx.version : -1;
+  }
+
+  decode(stream, parent) {
+    let version = this.getCFFVersion(parent);
+    let count = version >= 2
+      ? stream.readUInt32BE()
+      : stream.readUInt16BE();
+
+    if (count === 0) {
+      return [];
+    }
+
+    let offSize = stream.readUInt8();
+    let offsetType;
+    if (offSize === 1) {
+      offsetType = r.uint8;
+    } else if (offSize === 2) {
+      offsetType = r.uint16;
+    } else if (offSize === 3) {
+      offsetType = r.uint24;
+    } else if (offSize === 4) {
+      offsetType = r.uint32;
+    } else {
+      throw new Error(`Bad offset size in CFFIndex: ${offSize} ${stream.pos}`);
+    }
+
+    let ret = [];
+    let startPos = stream.pos + ((count + 1) * offSize) - 1;
+
+    let start = offsetType.decode(stream);
+    for (let i = 0; i < count; i++) {
+      let end = offsetType.decode(stream);
+
+      if (this.type != null) {
+        let pos = stream.pos;
+        stream.pos = startPos + start;
+
+        parent.length = end - start;
+        ret.push(this.type.decode(stream, parent));
+        stream.pos = pos;
+      } else {
+        ret.push({
+          offset: startPos + start,
+          length: end - start
+        });
+      }
+
+      start = end;
+    }
+
+    stream.pos = startPos + start;
+    return ret;
+  }
+
+  size(arr, parent) {
+    let size = 2;
+    if (arr.length === 0) {
+      return size;
+    }
+
+    let type = this.type || new r.Buffer;
+
+    // find maximum offset to detminine offset type
+    let offset = 1;
+    for (let i = 0; i < arr.length; i++) {
+      let item = arr[i];
+      offset += type.size(item, parent);
+    }
+
+    let offsetType;
+    if (offset <= 0xff) {
+      offsetType = r.uint8;
+    } else if (offset <= 0xffff) {
+      offsetType = r.uint16;
+    } else if (offset <= 0xffffff) {
+      offsetType = r.uint24;
+    } else if (offset <= 0xffffffff) {
+      offsetType = r.uint32;
+    } else {
+      throw new Error("Bad offset in CFFIndex");
+    }
+
+    size += 1 + offsetType.size() * (arr.length + 1);
+    size += offset - 1;
+
+    return size;
+  }
+
+  encode(stream, arr, parent) {
+    stream.writeUInt16BE(arr.length);
+    if (arr.length === 0) {
+      return;
+    }
+
+    let type = this.type || new r.Buffer;
+
+    // find maximum offset to detminine offset type
+    let sizes = [];
+    let offset = 1;
+    for (let item of arr) {
+      let s = type.size(item, parent);
+      sizes.push(s);
+      offset += s;
+    }
+
+    let offsetType;
+    if (offset <= 0xff) {
+      offsetType = r.uint8;
+    } else if (offset <= 0xffff) {
+      offsetType = r.uint16;
+    } else if (offset <= 0xffffff) {
+      offsetType = r.uint24;
+    } else if (offset <= 0xffffffff) {
+      offsetType = r.uint32;
+    } else {
+      throw new Error("Bad offset in CFFIndex");
+    }
+
+    // write offset size
+    stream.writeUInt8(offsetType.size());
+
+    // write elements
+    offset = 1;
+    offsetType.encode(stream, offset);
+
+    for (let size of sizes) {
+      offset += size;
+      offsetType.encode(stream, offset);
+    }
+
+    for (let item of arr) {
+      type.encode(stream, item, parent);
+    }
+
+    return;
+  }
+}

package/node_modules/fontkit/src/cff/CFFOperand.js

@@ -0,0 +1,134 @@
+const FLOAT_EOF = 0xf;
+const FLOAT_LOOKUP = [
+  '0', '1', '2', '3', '4', '5', '6', '7',
+  '8', '9', '.', 'E', 'E-', null, '-'
+];
+
+const FLOAT_ENCODE_LOOKUP = {
+  '.': 10,
+  'E': 11,
+  'E-': 12,
+  '-': 14
+};
+
+export default class CFFOperand {
+  static decode(stream, value) {
+    if (32 <= value && value <= 246) {
+      return value - 139;
+    }
+
+    if (247 <= value && value <= 250) {
+      return (value - 247) * 256 + stream.readUInt8() + 108;
+    }
+
+    if (251 <= value && value <= 254) {
+      return -(value - 251) * 256 - stream.readUInt8() - 108;
+    }
+
+    if (value === 28) {
+      return stream.readInt16BE();
+    }
+
+    if (value === 29) {
+      return stream.readInt32BE();
+    }
+
+    if (value === 30) {
+      let str = '';
+      while (true) {
+        let b = stream.readUInt8();
+
+        let n1 = b >> 4;
+        if (n1 === FLOAT_EOF) { break; }
+        str += FLOAT_LOOKUP[n1];
+
+        let n2 = b & 15;
+        if (n2 === FLOAT_EOF) { break; }
+        str += FLOAT_LOOKUP[n2];
+      }
+
+      return parseFloat(str);
+    }
+
+    return null;
+  }
+
+  static size(value) {
+    // if the value needs to be forced to the largest size (32 bit)
+    // e.g. for unknown pointers, set to 32768
+    if (value.forceLarge) {
+      value = 32768;
+    }
+
+    if ((value | 0) !== value) { // floating point
+      let str = '' + value;
+      return 1 + Math.ceil((str.length + 1) / 2);
+
+    } else if (-107 <= value && value <= 107) {
+      return 1;
+
+    } else if (108 <= value && value <= 1131 || -1131 <= value && value <= -108) {
+      return 2;
+
+    } else if (-32768 <= value && value <= 32767) {
+      return 3;
+
+    } else {
+      return 5;
+    }
+  }
+
+  static encode(stream, value) {
+    // if the value needs to be forced to the largest size (32 bit)
+    // e.g. for unknown pointers, save the old value and set to 32768
+    let val = Number(value);
+
+    if (value.forceLarge) {
+      stream.writeUInt8(29);
+      return stream.writeInt32BE(val);
+
+    } else if ((val | 0) !== val) { // floating point
+      stream.writeUInt8(30);
+
+      let str = '' + val;
+      for (let i = 0; i < str.length; i += 2) {
+        let c1 = str[i];
+        let n1 = FLOAT_ENCODE_LOOKUP[c1] || +c1;
+
+        if (i === str.length - 1) {
+          var n2 = FLOAT_EOF;
+        } else {
+          let c2 = str[i + 1];
+          var n2 = FLOAT_ENCODE_LOOKUP[c2] || +c2;
+        }
+
+        stream.writeUInt8((n1 << 4) | (n2 & 15));
+      }
+
+      if (n2 !== FLOAT_EOF) {
+        return stream.writeUInt8((FLOAT_EOF << 4));
+      }
+
+    } else if (-107 <= val && val <= 107) {
+      return stream.writeUInt8(val + 139);
+
+    } else if (108 <= val && val <= 1131) {
+      val -= 108;
+      stream.writeUInt8((val >> 8) + 247);
+      return stream.writeUInt8(val & 0xff);
+
+    } else if (-1131 <= val && val <= -108) {
+      val = -val - 108;
+      stream.writeUInt8((val >> 8) + 251);
+      return stream.writeUInt8(val & 0xff);
+
+    } else if (-32768 <= val && val <= 32767) {
+      stream.writeUInt8(28);
+      return stream.writeInt16BE(val);
+
+    } else {
+      stream.writeUInt8(29);
+      return stream.writeInt32BE(val);
+    }
+  }
+}