@cantoo/fontkit 2.0.4 → 2.0.6

package/src/cff/CFFTop.js

@@ -8,33 +8,89 @@ import { StandardEncoding, ExpertEncoding } from './CFFEncodings';
 import { ISOAdobeCharset, ExpertCharset, ExpertSubsetCharset } from './CFFCharsets';
 import { ItemVariationStore } from '../tables/variations';
 
+/** @typedef {import('restructure').BaseType} BaseType */
+/** @typedef {import('restructure').DecodeStream} DecodeStream */
+/** @typedef {import('restructure').EncodeStream} EncodeStream */
+/** @typedef {import('restructure').StructValue} StructValue */
+/** @typedef {import('../../types/fontkit').CFFEncodeContext} CFFEncodeContext */
+
+/**
+ * @param {StructValue} t
+ * @returns {number}
+ */
+function charStringsCount(t) {
+  let parent = t.parent;
+  if (!parent) {
+    return 0;
+  }
+  let cs = parent.CharStrings;
+  if (cs && typeof cs === 'object' && 'length' in cs && typeof /** @type {{ length: unknown }} */ (cs).length === 'number') {
+    return /** @type {{ length: number }} */ (cs).length;
+  }
+  return 0;
+}
+
 // Checks if an operand is an index of a predefined value,
 // otherwise delegates to the provided type.
 class PredefinedOp {
+  /**
+   * @param {unknown[]} predefinedOps
+   * @param {BaseType} type
+   */
   constructor(predefinedOps, type) {
+    /** @type {unknown[]} */
     this.predefinedOps = predefinedOps;
+    /** @type {BaseType} */
     this.type = type;
   }
 
+  /**
+   * @param {DecodeStream} stream
+   * @param {StructValue} parent
+   * @param {number[]} operands
+   * @returns {unknown}
+   */
   decode(stream, parent, operands) {
-    if (this.predefinedOps[operands[0]]) {
+    if (this.predefinedOps[operands[0]] != null) {
       return this.predefinedOps[operands[0]];
     }
 
+    if (!this.type.decode) {
+      throw new Error('PredefinedOp type must implement decode()');
+    }
     return this.type.decode(stream, parent, operands);
   }
 
+  /**
+   * @param {unknown} value
+   * @param {StructValue | null | undefined} ctx
+   * @returns {unknown}
+   */
   size(value, ctx) {
+    if (!this.type.size) {
+      throw new Error('PredefinedOp type must implement size()');
+    }
     return this.type.size(value, ctx);
   }
 
+  /**
+   * @param {EncodeStream | null} stream
+   * @param {unknown} value
+   * @param {StructValue | null | undefined} ctx
+   * @returns {unknown[]}
+   */
   encode(stream, value, ctx) {
     let index = this.predefinedOps.indexOf(value);
     if (index !== -1) {
-      return index;
+      // Must be an operand list — CFFDict iterates with for-of.
+      return [index];
     }
 
-    return this.type.encode(stream, value, ctx);
+    if (!this.type.encode) {
+      throw new Error('PredefinedOp type must implement encode()');
+    }
+    let encoded = this.type.encode(stream, value, ctx);
+    return Array.isArray(encoded) ? encoded : [encoded];
   }
 }
 
@@ -43,6 +99,10 @@ class CFFEncodingVersion extends r.Number {
     super('UInt8');
   }
 
+  /**
+   * @param {DecodeStream} stream
+   * @returns {number}
+   */
   decode(stream) {
     return r.uint8.decode(stream) & 0x7f;
   }
@@ -72,20 +132,34 @@ let CFFCustomEncoding = new r.VersionedStruct(new CFFEncodingVersion(), {
   // TODO: supplement?
 });
 
-let CFFEncoding = new PredefinedOp([ StandardEncoding, ExpertEncoding ], new CFFPointer(CFFCustomEncoding, { lazy: true }));
+let CFFEncoding = new PredefinedOp([StandardEncoding, ExpertEncoding], new CFFPointer(CFFCustomEncoding, { lazy: true }));
 
 // Decodes an array of ranges until the total
 // length is equal to the provided length.
 class RangeArray extends r.Array {
+  /**
+   * @param {DecodeStream} stream
+   * @param {StructValue} parent
+   * @returns {Array<StructValue & { nLeft: number, offset: number }>}
+   */
   decode(stream, parent) {
+    if (this.length == null) {
+      throw new Error('RangeArray requires a length');
+    }
     let length = resolveLength(this.length, stream, parent);
     let count = 0;
+    /** @type {Array<StructValue & { nLeft: number, offset: number }>} */
     let res = [];
     while (count < length) {
-      let range = this.type.decode(stream, parent);
+      if (!this.type.decode) {
+        throw new Error('RangeArray element type must implement decode()');
+      }
+      let range = /** @type {StructValue & { nLeft: number, offset?: number }} */ (
+        this.type.decode(stream, parent)
+      );
       range.offset = count;
       count += range.nLeft + 1;
-      res.push(range);
+      res.push(/** @type {StructValue & { nLeft: number, offset: number }} */ (range));
     }
 
     return res;
@@ -94,19 +168,19 @@ class RangeArray extends r.Array {
 
 let CFFCustomCharset = new r.VersionedStruct(r.uint8, {
   0: {
-    glyphs: new r.Array(r.uint16, t => t.parent.CharStrings.length - 1)
+    glyphs: new r.Array(r.uint16, t => charStringsCount(t) - 1)
   },
 
   1: {
-    ranges: new RangeArray(Range1, t => t.parent.CharStrings.length - 1)
+    ranges: new RangeArray(Range1, t => charStringsCount(t) - 1)
   },
 
   2: {
-    ranges: new RangeArray(Range2, t => t.parent.CharStrings.length - 1)
+    ranges: new RangeArray(Range2, t => charStringsCount(t) - 1)
   }
 });
 
-let CFFCharset = new PredefinedOp([ ISOAdobeCharset, ExpertCharset, ExpertSubsetCharset ], new CFFPointer(CFFCustomCharset, {lazy: true}));
+let CFFCharset = new PredefinedOp([ISOAdobeCharset, ExpertCharset, ExpertSubsetCharset], new CFFPointer(CFFCustomCharset, { lazy: true }));
 
 let FDRange3 = new r.Struct({
   first: r.uint16,
@@ -120,7 +194,7 @@ let FDRange4 = new r.Struct({
 
 let FDSelect = new r.VersionedStruct(r.uint8, {
   0: {
-    fds: new r.Array(r.uint8, t => t.parent.CharStrings.length)
+    fds: new r.Array(r.uint8, t => charStringsCount(t))
   },
 
   3: {
@@ -138,15 +212,34 @@ let FDSelect = new r.VersionedStruct(r.uint8, {
 
 let ptr = new CFFPointer(CFFPrivateDict);
 class CFFPrivateOp {
+  /**
+   * @param {DecodeStream} stream
+   * @param {StructValue} parent
+   * @param {number[]} operands
+   * @returns {unknown}
+   */
   decode(stream, parent, operands) {
     parent.length = operands[0];
     return ptr.decode(stream, parent, [operands[1]]);
   }
 
+  /**
+   * Size operands match encode(null, …): [privateDictByteLength, pointerOperand].
+   * @param {StructValue} dict
+   * @param {CFFEncodeContext | StructValue} ctx
+   * @returns {unknown[]}
+   */
   size(dict, ctx) {
-    return [CFFPrivateDict.size(dict, ctx, false), ptr.size(dict, ctx)[0]];
+    // Delegate to encode(null) so pointerSize is updated and operands match.
+    return this.encode(null, dict, ctx);
   }
 
+  /**
+   * @param {EncodeStream | null} stream
+   * @param {StructValue} dict
+   * @param {CFFEncodeContext | StructValue} ctx
+   * @returns {unknown[]}
+   */
   encode(stream, dict, ctx) {
     return [CFFPrivateDict.size(dict, ctx, false), ptr.encode(stream, dict, ctx)[0]];
   }
@@ -154,82 +247,82 @@ class CFFPrivateOp {
 
 let FontDict = new CFFDict([
   // key       name                   type(s)                                 default
-  [18,        'Private',              new CFFPrivateOp,                       null],
-  [[12, 38],  'FontName',             'sid',                                  null],
-  [[12, 7],   'FontMatrix',           'array',                                [0.001, 0, 0, 0.001, 0, 0]],
-  [[12, 5],   'PaintType',            'number',                               0],
+  [18, 'Private', new CFFPrivateOp(), null],
+  [[12, 38], 'FontName', 'sid', null],
+  [[12, 7], 'FontMatrix', 'array', [0.001, 0, 0, 0.001, 0, 0]],
+  [[12, 5], 'PaintType', 'number', 0]
 ]);
 
 let CFFTopDict = new CFFDict([
   // key       name                   type(s)                                 default
-  [[12, 30],  'ROS',                  ['sid', 'sid', 'number'],               null],
-
-  [0,         'version',              'sid',                                  null],
-  [1,         'Notice',               'sid',                                  null],
-  [[12, 0],   'Copyright',            'sid',                                  null],
-  [2,         'FullName',             'sid',                                  null],
-  [3,         'FamilyName',           'sid',                                  null],
-  [4,         'Weight',               'sid',                                  null],
-  [[12, 1],   'isFixedPitch',         'boolean',                              false],
-  [[12, 2],   'ItalicAngle',          'number',                               0],
-  [[12, 3],   'UnderlinePosition',    'number',                               -100],
-  [[12, 4],   'UnderlineThickness',   'number',                               50],
-  [[12, 5],   'PaintType',            'number',                               0],
-  [[12, 6],   'CharstringType',       'number',                               2],
-  [[12, 7],   'FontMatrix',           'array',                                [0.001, 0, 0, 0.001, 0, 0]],
-  [13,        'UniqueID',             'number',                               null],
-  [5,         'FontBBox',             'array',                                [0, 0, 0, 0]],
-  [[12, 8],   'StrokeWidth',          'number',                               0],
-  [14,        'XUID',                 'array',                                null],
-  [15,        'charset',              CFFCharset,                             ISOAdobeCharset],
-  [16,        'Encoding',             CFFEncoding,                            StandardEncoding],
-  [17,        'CharStrings',          new CFFPointer(new CFFIndex),           null],
-  [18,        'Private',              new CFFPrivateOp,                       null],
-  [[12, 20],  'SyntheticBase',        'number',                               null],
-  [[12, 21],  'PostScript',           'sid',                                  null],
-  [[12, 22],  'BaseFontName',         'sid',                                  null],
-  [[12, 23],  'BaseFontBlend',        'delta',                                null],
+  [[12, 30], 'ROS', ['sid', 'sid', 'number'], null],
+
+  [0, 'version', 'sid', null],
+  [1, 'Notice', 'sid', null],
+  [[12, 0], 'Copyright', 'sid', null],
+  [2, 'FullName', 'sid', null],
+  [3, 'FamilyName', 'sid', null],
+  [4, 'Weight', 'sid', null],
+  [[12, 1], 'isFixedPitch', 'boolean', false],
+  [[12, 2], 'ItalicAngle', 'number', 0],
+  [[12, 3], 'UnderlinePosition', 'number', -100],
+  [[12, 4], 'UnderlineThickness', 'number', 50],
+  [[12, 5], 'PaintType', 'number', 0],
+  [[12, 6], 'CharstringType', 'number', 2],
+  [[12, 7], 'FontMatrix', 'array', [0.001, 0, 0, 0.001, 0, 0]],
+  [13, 'UniqueID', 'number', null],
+  [5, 'FontBBox', 'array', [0, 0, 0, 0]],
+  [[12, 8], 'StrokeWidth', 'number', 0],
+  [14, 'XUID', 'array', null],
+  [15, 'charset', CFFCharset, ISOAdobeCharset],
+  [16, 'Encoding', CFFEncoding, StandardEncoding],
+  [17, 'CharStrings', new CFFPointer(new CFFIndex()), null],
+  [18, 'Private', new CFFPrivateOp(), null],
+  [[12, 20], 'SyntheticBase', 'number', null],
+  [[12, 21], 'PostScript', 'sid', null],
+  [[12, 22], 'BaseFontName', 'sid', null],
+  [[12, 23], 'BaseFontBlend', 'delta', null],
 
   // CID font specific
-  [[12, 31],  'CIDFontVersion',       'number',                               0],
-  [[12, 32],  'CIDFontRevision',      'number',                               0],
-  [[12, 33],  'CIDFontType',          'number',                               0],
-  [[12, 34],  'CIDCount',             'number',                               8720],
-  [[12, 35],  'UIDBase',              'number',                               null],
-  [[12, 37],  'FDSelect',             new CFFPointer(FDSelect),               null],
-  [[12, 36],  'FDArray',              new CFFPointer(new CFFIndex(FontDict)), null],
-  [[12, 38],  'FontName',             'sid',                                  null]
+  [[12, 31], 'CIDFontVersion', 'number', 0],
+  [[12, 32], 'CIDFontRevision', 'number', 0],
+  [[12, 33], 'CIDFontType', 'number', 0],
+  [[12, 34], 'CIDCount', 'number', 8720],
+  [[12, 35], 'UIDBase', 'number', null],
+  [[12, 37], 'FDSelect', new CFFPointer(FDSelect), null],
+  [[12, 36], 'FDArray', new CFFPointer(new CFFIndex(FontDict)), null],
+  [[12, 38], 'FontName', 'sid', null]
 ]);
 
 let VariationStore = new r.Struct({
   length: r.uint16,
   itemVariationStore: ItemVariationStore
-})
+});
 
 let CFF2TopDict = new CFFDict([
-  [[12, 7],   'FontMatrix',           'array',                                [0.001, 0, 0, 0.001, 0, 0]],
-  [17,        'CharStrings',          new CFFPointer(new CFFIndex),           null],
-  [[12, 37],  'FDSelect',             new CFFPointer(FDSelect),               null],
-  [[12, 36],  'FDArray',              new CFFPointer(new CFFIndex(FontDict)), null],
-  [24,        'vstore',               new CFFPointer(VariationStore),         null],
-  [25,        'maxstack',             'number',                               193]
+  [[12, 7], 'FontMatrix', 'array', [0.001, 0, 0, 0.001, 0, 0]],
+  [17, 'CharStrings', new CFFPointer(new CFFIndex()), null],
+  [[12, 37], 'FDSelect', new CFFPointer(FDSelect), null],
+  [[12, 36], 'FDArray', new CFFPointer(new CFFIndex(FontDict)), null],
+  [24, 'vstore', new CFFPointer(VariationStore), null],
+  [25, 'maxstack', 'number', 193]
 ]);
 
 let CFFTop = new r.VersionedStruct(r.fixed16, {
   1: {
-    hdrSize:            r.uint8,
-    offSize:            r.uint8,
-    nameIndex:          new CFFIndex(new r.String('length')),
-    topDictIndex:       new CFFIndex(CFFTopDict),
-    stringIndex:        new CFFIndex(new r.String('length')),
-    globalSubrIndex:    new CFFIndex
+    hdrSize: r.uint8,
+    offSize: r.uint8,
+    nameIndex: new CFFIndex(new r.String('length')),
+    topDictIndex: new CFFIndex(CFFTopDict),
+    stringIndex: new CFFIndex(new r.String('length')),
+    globalSubrIndex: new CFFIndex()
   },
 
   2: {
-    hdrSize:            r.uint8,
-    length:             r.uint16,
-    topDict:            CFF2TopDict,
-    globalSubrIndex:    new CFFIndex
+    hdrSize: r.uint8,
+    length: r.uint16,
+    topDict: CFF2TopDict,
+    globalSubrIndex: new CFFIndex()
   }
 });
 

package/src/decorators.js

@@ -1,36 +1,55 @@
 /**
- * This decorator caches the results of a getter or method such that
- * the results are lazily computed once, and then cached.
- * @private
+ * Cache decorator for getters/methods.
+ * Results are lazily computed once, then cached on the instance.
+ *
+ * @template T
+ * @param {object} target
+ * @param {string} key
+ * @param {TypedPropertyDescriptor<T>} descriptor
+ * @returns {TypedPropertyDescriptor<T> | void}
  */
 export function cache(target, key, descriptor) {
   if (descriptor.get) {
     let get = descriptor.get;
-    descriptor.get = function() {
+    descriptor.get = function () {
       let value = get.call(this);
       Object.defineProperty(this, key, { value });
       return value;
     };
-  } else if (typeof descriptor.value === 'function') {
-    let fn = descriptor.value;
+    return;
+  }
+
+  if (typeof descriptor.value === 'function') {
+    let fn = /** @type {(...args: unknown[]) => T} */ (descriptor.value);
 
-    return {
+    /** @type {TypedPropertyDescriptor<T>} */
+    let replacement = {
+      configurable: true,
+      enumerable: false,
       get() {
-        let cache = new Map;
-        function memoized(...args) {
-          let key = args.length > 0 ? args[0] : 'value';
-          if (cache.has(key)) {
-            return cache.get(key);
+        /** @type {Map<unknown, T>} */
+        let cacheMap = new Map();
+
+        /**
+         * @param {...unknown} args
+         * @returns {T}
+         */
+        let memoized = (...args) => {
+          let cacheKey = args.length > 0 ? args[0] : 'value';
+          if (cacheMap.has(cacheKey)) {
+            return /** @type {T} */ (cacheMap.get(cacheKey));
           }
 
           let result = fn.apply(this, args);
-          cache.set(key, result);
+          cacheMap.set(cacheKey, result);
           return result;
         };
 
-        Object.defineProperty(this, key, {value: memoized});
-        return memoized;
+        Object.defineProperty(this, key, { value: memoized });
+        return /** @type {T} */ (/** @type {unknown} */ (memoized));
       }
     };
+
+    return replacement;
   }
 }