@cantoo/fontkit 2.0.4 → 2.0.6

package/src/cff/CFFOperand.js

@@ -1,17 +1,31 @@
+/** @typedef {import('restructure').DecodeStream} DecodeStream */
+/** @typedef {import('restructure').EncodeStream} EncodeStream */
+
+/**
+ * Operand value that may force a 32-bit encoding (e.g. CFF pointer placeholders).
+ * @typedef {number | { forceLarge?: boolean, valueOf(): number }} CFFOperandValue
+ */
+
 const FLOAT_EOF = 0xf;
 const FLOAT_LOOKUP = [
   '0', '1', '2', '3', '4', '5', '6', '7',
   '8', '9', '.', 'E', 'E-', null, '-'
 ];
 
+/** @type {Record<string, number>} */
 const FLOAT_ENCODE_LOOKUP = {
   '.': 10,
-  'E': 11,
+  E: 11,
   'E-': 12,
   '-': 14
 };
 
 export default class CFFOperand {
+  /**
+   * @param {DecodeStream} stream
+   * @param {number} value
+   * @returns {number | null}
+   */
   static decode(stream, value) {
     if (32 <= value && value <= 246) {
       return value - 139;
@@ -53,83 +67,94 @@ export default class CFFOperand {
     return null;
   }
 
+  /**
+   * @param {CFFOperandValue} value
+   * @returns {number}
+   */
   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;
+    /** @type {number} */
+    let n;
+    if (value && typeof value === 'object' && value.forceLarge) {
+      n = 32768;
+    } else {
+      n = Number(value);
     }
 
-    if ((value | 0) !== value) { // floating point
-      let str = '' + value;
+    if ((n | 0) !== n) { // floating point
+      let str = '' + n;
       return 1 + Math.ceil((str.length + 1) / 2);
-
-    } else if (-107 <= value && value <= 107) {
+    } else if (-107 <= n && n <= 107) {
       return 1;
-
-    } else if (108 <= value && value <= 1131 || -1131 <= value && value <= -108) {
+    } else if (108 <= n && n <= 1131 || -1131 <= n && n <= -108) {
       return 2;
-
-    } else if (-32768 <= value && value <= 32767) {
+    } else if (-32768 <= n && n <= 32767) {
       return 3;
-
     } else {
       return 5;
     }
   }
 
+  /**
+   * @param {EncodeStream} stream
+   * @param {CFFOperandValue} value
+   * @returns {void}
+   */
   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) {
+    if (value && typeof value === 'object' && value.forceLarge) {
       stream.writeUInt8(29);
-      return stream.writeInt32BE(val);
-
+      stream.writeInt32BE(val);
+      return;
     } else if ((val | 0) !== val) { // floating point
       stream.writeUInt8(30);
 
       let str = '' + val;
+      /** @type {number | undefined} */
       let n2;
       for (let i = 0; i < str.length; i += 2) {
         let c1 = str[i];
-        let n1 = FLOAT_ENCODE_LOOKUP[c1] || +c1;
+        let n1 = FLOAT_ENCODE_LOOKUP[c1] ?? (+c1);
 
         if (i === str.length - 1) {
           n2 = FLOAT_EOF;
         } else {
           let c2 = str[i + 1];
-          n2 = FLOAT_ENCODE_LOOKUP[c2] || +c2;
+          n2 = FLOAT_ENCODE_LOOKUP[c2] ?? (+c2);
         }
 
         stream.writeUInt8((n1 << 4) | (n2 & 15));
       }
 
       if (n2 !== FLOAT_EOF) {
-        return stream.writeUInt8((FLOAT_EOF << 4));
+        stream.writeUInt8((FLOAT_EOF << 4));
       }
-
+      return;
     } else if (-107 <= val && val <= 107) {
-      return stream.writeUInt8(val + 139);
-
+      stream.writeUInt8(val + 139);
+      return;
     } else if (108 <= val && val <= 1131) {
       val -= 108;
       stream.writeUInt8((val >> 8) + 247);
-      return stream.writeUInt8(val & 0xff);
-
+      stream.writeUInt8(val & 0xff);
+      return;
     } else if (-1131 <= val && val <= -108) {
       val = -val - 108;
       stream.writeUInt8((val >> 8) + 251);
-      return stream.writeUInt8(val & 0xff);
-
+      stream.writeUInt8(val & 0xff);
+      return;
     } else if (-32768 <= val && val <= 32767) {
       stream.writeUInt8(28);
-      return stream.writeInt16BE(val);
-
+      stream.writeInt16BE(val);
+      return;
     } else {
       stream.writeUInt8(29);
-      return stream.writeInt32BE(val);
+      stream.writeInt32BE(val);
+      return;
     }
   }
 }

package/src/cff/CFFPointer.js

@@ -1,6 +1,20 @@
 import * as r from 'restructure';
 
+/** @typedef {import('restructure').BaseType} BaseType */
+/** @typedef {import('restructure').DecodeStream} DecodeStream */
+/** @typedef {import('restructure').EncodeStream} EncodeStream */
+/** @typedef {import('restructure').PointerOptions} PointerOptions */
+/** @typedef {import('restructure').StructValue} StructValue */
+
+/**
+ * CFF dict pointer: offset comes from a prior operand rather than the stream.
+ * Temporary offsetType stubs only implement the method needed for that phase.
+ */
 export default class CFFPointer extends r.Pointer {
+  /**
+   * @param {BaseType | null} type
+   * @param {PointerOptions} [options]
+   */
   constructor(type, options = {}) {
     if (options.type == null) {
       options.type = 'global';
@@ -9,6 +23,12 @@ export default class CFFPointer extends r.Pointer {
     super(null, type, options);
   }
 
+  /**
+   * @param {DecodeStream} stream
+   * @param {StructValue | null | undefined} parent
+   * @param {number[]} operands
+   * @returns {unknown}
+   */
   decode(stream, parent, operands) {
     this.offsetType = {
       decode: () => operands[0]
@@ -17,6 +37,12 @@ export default class CFFPointer extends r.Pointer {
     return super.decode(stream, parent, operands);
   }
 
+  /**
+   * @param {EncodeStream | null} stream
+   * @param {unknown} value
+   * @param {StructValue | null | undefined} ctx
+   * @returns {Ptr[]}
+   */
   encode(stream, value, ctx) {
     if (!stream) {
       // compute the size (so ctx.pointerSize is correct)
@@ -28,22 +54,35 @@ export default class CFFPointer extends r.Pointer {
       return [new Ptr(0)];
     }
 
+    /** @type {number | null} */
     let ptr = null;
     this.offsetType = {
-      encode: (stream, val) => ptr = val
+      /**
+       * @param {EncodeStream} _stream
+       * @param {number} val
+       */
+      encode: (_stream, val) => { ptr = val; }
     };
 
     super.encode(stream, value, ctx);
-    return [new Ptr(ptr)];
+    return [new Ptr(ptr ?? 0)];
   }
 }
 
 class Ptr {
+  /**
+   * @param {number} val
+   */
   constructor(val) {
+    /** @type {number} */
     this.val = val;
+    /** @type {boolean} */
     this.forceLarge = true;
   }
 
+  /**
+   * @returns {number}
+   */
   valueOf() {
     return this.val;
   }

package/src/cff/CFFPrivateDict.js

@@ -2,38 +2,48 @@ import CFFDict from './CFFDict';
 import CFFIndex from './CFFIndex';
 import CFFPointer from './CFFPointer';
 
-class CFFBlendOp {
-  static decode(stream, parent, operands) {
+/** @typedef {import('restructure').DecodeStream} DecodeStream */
+/** @typedef {import('restructure').StructValue} StructValue */
+
+/** @type {import('../../types/fontkit').CFFOperandType} */
+const CFFBlendOp = {
+  /**
+   * @param {DecodeStream} _stream
+   * @param {StructValue} _parent
+   * @param {number[]} operands
+   * @returns {void}
+   */
+  decode(_stream, _parent, operands) {
     let numBlends = operands.pop();
 
     // TODO: actually blend. For now just consume the deltas
     // since we don't use any of the values anyway.
-    while (operands.length > numBlends) {
+    while (operands.length > /** @type {number} */ (numBlends)) {
       operands.pop();
     }
   }
-}
+};
 
 export default new CFFDict([
   // key       name                    type                                          default
-  [6,         'BlueValues',           'delta',                                       null],
-  [7,         'OtherBlues',           'delta',                                       null],
-  [8,         'FamilyBlues',          'delta',                                       null],
-  [9,         'FamilyOtherBlues',     'delta',                                       null],
-  [[12, 9],   'BlueScale',            'number',                                      0.039625],
-  [[12, 10],  'BlueShift',            'number',                                      7],
-  [[12, 11],  'BlueFuzz',             'number',                                      1],
-  [10,        'StdHW',                'number',                                      null],
-  [11,        'StdVW',                'number',                                      null],
-  [[12, 12],  'StemSnapH',            'delta',                                       null],
-  [[12, 13],  'StemSnapV',            'delta',                                       null],
-  [[12, 14],  'ForceBold',            'boolean',                                     false],
-  [[12, 17],  'LanguageGroup',        'number',                                      0],
-  [[12, 18],  'ExpansionFactor',      'number',                                      0.06],
-  [[12, 19],  'initialRandomSeed',    'number',                                      0],
-  [20,        'defaultWidthX',        'number',                                      0],
-  [21,        'nominalWidthX',        'number',                                      0],
-  [22,        'vsindex',              'number',                                      0],
-  [23,        'blend',                CFFBlendOp,                                    null],
-  [19,        'Subrs',                new CFFPointer(new CFFIndex, {type: 'local'}), null]
+  [6, 'BlueValues', 'delta', null],
+  [7, 'OtherBlues', 'delta', null],
+  [8, 'FamilyBlues', 'delta', null],
+  [9, 'FamilyOtherBlues', 'delta', null],
+  [[12, 9], 'BlueScale', 'number', 0.039625],
+  [[12, 10], 'BlueShift', 'number', 7],
+  [[12, 11], 'BlueFuzz', 'number', 1],
+  [10, 'StdHW', 'number', null],
+  [11, 'StdVW', 'number', null],
+  [[12, 12], 'StemSnapH', 'delta', null],
+  [[12, 13], 'StemSnapV', 'delta', null],
+  [[12, 14], 'ForceBold', 'boolean', false],
+  [[12, 17], 'LanguageGroup', 'number', 0],
+  [[12, 18], 'ExpansionFactor', 'number', 0.06],
+  [[12, 19], 'initialRandomSeed', 'number', 0],
+  [20, 'defaultWidthX', 'number', 0],
+  [21, 'nominalWidthX', 'number', 0],
+  [22, 'vsindex', 'number', 0],
+  [23, 'blend', CFFBlendOp, null],
+  [19, 'Subrs', new CFFPointer(new CFFIndex(), { type: 'local' }), null]
 ]);

package/src/cff/CFFStandardStrings.js

@@ -1,71 +1,72 @@
 // Automatically generated from Appendix A of the CFF specification; do
 // not edit. Length should be 391.
+/** @type {string[]} */
 export default [
-  ".notdef", "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", "onesuperior", "logicalnot", "mu", "trademark", "Eth",
-  "onehalf", "plusminus", "Thorn", "onequarter", "divide", "brokenbar",
-  "degree", "thorn", "threequarters", "twosuperior", "registered", "minus",
-  "eth", "multiply", "threesuperior", "copyright", "Aacute", "Acircumflex",
-  "Adieresis", "Agrave", "Aring", "Atilde", "Ccedilla", "Eacute",
-  "Ecircumflex", "Edieresis", "Egrave", "Iacute", "Icircumflex", "Idieresis",
-  "Igrave", "Ntilde", "Oacute", "Ocircumflex", "Odieresis", "Ograve",
-  "Otilde", "Scaron", "Uacute", "Ucircumflex", "Udieresis", "Ugrave",
-  "Yacute", "Ydieresis", "Zcaron", "aacute", "acircumflex", "adieresis",
-  "agrave", "aring", "atilde", "ccedilla", "eacute", "ecircumflex",
-  "edieresis", "egrave", "iacute", "icircumflex", "idieresis", "igrave",
-  "ntilde", "oacute", "ocircumflex", "odieresis", "ograve", "otilde",
-  "scaron", "uacute", "ucircumflex", "udieresis", "ugrave", "yacute",
-  "ydieresis", "zcaron", "exclamsmall", "Hungarumlautsmall",
-  "dollaroldstyle", "dollarsuperior", "ampersandsmall", "Acutesmall",
-  "parenleftsuperior", "parenrightsuperior", "twodotenleader",
-  "onedotenleader", "zerooldstyle", "oneoldstyle", "twooldstyle",
-  "threeoldstyle", "fouroldstyle", "fiveoldstyle", "sixoldstyle",
-  "sevenoldstyle", "eightoldstyle", "nineoldstyle", "commasuperior",
-  "threequartersemdash", "periodsuperior", "questionsmall", "asuperior",
-  "bsuperior", "centsuperior", "dsuperior", "esuperior", "isuperior",
-  "lsuperior", "msuperior", "nsuperior", "osuperior", "rsuperior",
-  "ssuperior", "tsuperior", "ff", "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",
-  "questiondownsmall", "oneeighth", "threeeighths", "fiveeighths",
-  "seveneighths", "onethird", "twothirds", "zerosuperior", "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", "001.000", "001.001", "001.002", "001.003", "Black",
-  "Bold", "Book", "Light", "Medium", "Regular", "Roman", "Semibold"
+  '.notdef', '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', 'onesuperior', 'logicalnot', 'mu', 'trademark', 'Eth',
+  'onehalf', 'plusminus', 'Thorn', 'onequarter', 'divide', 'brokenbar',
+  'degree', 'thorn', 'threequarters', 'twosuperior', 'registered', 'minus',
+  'eth', 'multiply', 'threesuperior', 'copyright', 'Aacute', 'Acircumflex',
+  'Adieresis', 'Agrave', 'Aring', 'Atilde', 'Ccedilla', 'Eacute',
+  'Ecircumflex', 'Edieresis', 'Egrave', 'Iacute', 'Icircumflex', 'Idieresis',
+  'Igrave', 'Ntilde', 'Oacute', 'Ocircumflex', 'Odieresis', 'Ograve',
+  'Otilde', 'Scaron', 'Uacute', 'Ucircumflex', 'Udieresis', 'Ugrave',
+  'Yacute', 'Ydieresis', 'Zcaron', 'aacute', 'acircumflex', 'adieresis',
+  'agrave', 'aring', 'atilde', 'ccedilla', 'eacute', 'ecircumflex',
+  'edieresis', 'egrave', 'iacute', 'icircumflex', 'idieresis', 'igrave',
+  'ntilde', 'oacute', 'ocircumflex', 'odieresis', 'ograve', 'otilde',
+  'scaron', 'uacute', 'ucircumflex', 'udieresis', 'ugrave', 'yacute',
+  'ydieresis', 'zcaron', 'exclamsmall', 'Hungarumlautsmall',
+  'dollaroldstyle', 'dollarsuperior', 'ampersandsmall', 'Acutesmall',
+  'parenleftsuperior', 'parenrightsuperior', 'twodotenleader',
+  'onedotenleader', 'zerooldstyle', 'oneoldstyle', 'twooldstyle',
+  'threeoldstyle', 'fouroldstyle', 'fiveoldstyle', 'sixoldstyle',
+  'sevenoldstyle', 'eightoldstyle', 'nineoldstyle', 'commasuperior',
+  'threequartersemdash', 'periodsuperior', 'questionsmall', 'asuperior',
+  'bsuperior', 'centsuperior', 'dsuperior', 'esuperior', 'isuperior',
+  'lsuperior', 'msuperior', 'nsuperior', 'osuperior', 'rsuperior',
+  'ssuperior', 'tsuperior', 'ff', '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',
+  'questiondownsmall', 'oneeighth', 'threeeighths', 'fiveeighths',
+  'seveneighths', 'onethird', 'twothirds', 'zerosuperior', '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', '001.000', '001.001', '001.002', '001.003', 'Black',
+  'Bold', 'Book', 'Light', 'Medium', 'Regular', 'Roman', 'Semibold'
 ];