@cantoo/fontkit 2.0.5 → 2.0.6

package/src/cff/CFFDict.js

@@ -2,9 +2,32 @@ import isEqual from 'fast-deep-equal';
 import CFFOperand from './CFFOperand';
 import { PropertyDescriptor } from 'restructure';
 
+/** @typedef {import('restructure').BaseType} BaseType */
+/** @typedef {import('restructure').DecodeStream} DecodeStream */
+/** @typedef {import('restructure').EncodeStream} EncodeStream */
+/** @typedef {import('restructure').StructValue} StructValue */
+/** @typedef {import('../../types/fontkit').CFFDictField} CFFDictField */
+/** @typedef {import('../../types/fontkit').CFFOperandType} CFFOperandType */
+/** @typedef {import('../../types/fontkit').CFFEncodeContext} CFFEncodeContext */
+
+/** @typedef {number | { forceLarge?: boolean, valueOf(): number }} CFFOperandValue */
+
+/**
+ * @param {CFFOperandType} type
+ * @returns {type is BaseType}
+ */
+function isCodec(type) {
+  return typeof type === 'object' && type != null && !Array.isArray(type);
+}
+
 export default class CFFDict {
+  /**
+   * @param {CFFDictField[]} [ops]
+   */
   constructor(ops = []) {
+    /** @type {CFFDictField[]} */
     this.ops = ops;
+    /** @type {Record<number, CFFDictField>} */
     this.fields = {};
     for (let field of ops) {
       let key = Array.isArray(field[0]) ? field[0][0] << 8 | field[0][1] : field[0];
@@ -12,10 +35,17 @@ export default class CFFDict {
     }
   }
 
+  /**
+   * @param {CFFOperandType} type
+   * @param {DecodeStream} stream
+   * @param {StructValue} ret
+   * @param {unknown[]} operands
+   * @returns {unknown}
+   */
   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) {
+    } else if (isCodec(type) && type.decode != null) {
       return type.decode(stream, ret, operands);
     } else {
       switch (type) {
@@ -31,11 +61,26 @@ export default class CFFDict {
     }
   }
 
+  /**
+   * @param {CFFOperandType} type
+   * @param {EncodeStream | null} stream
+   * @param {CFFEncodeContext | StructValue} ctx
+   * @param {unknown} operands
+   * @returns {unknown[]}
+   */
   encodeOperands(type, stream, ctx, operands) {
     if (Array.isArray(type)) {
+      if (!Array.isArray(operands)) {
+        return [operands];
+      }
       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 (isCodec(type) && type.encode != null) {
+      let encoded = type.encode(stream, operands, ctx);
+      if (Array.isArray(encoded)) {
+        return encoded;
+      }
+      // Custom ops must return an operand list; coerce scalars (e.g. sid index).
+      return [encoded];
     } else if (typeof operands === 'number') {
       return [operands];
     } else if (typeof operands === 'boolean') {
@@ -47,9 +92,17 @@ export default class CFFDict {
     }
   }
 
+  /**
+   * @param {DecodeStream} stream
+   * @param {StructValue} parent
+   * @returns {StructValue}
+   */
   decode(stream, parent) {
-    let end = stream.pos + parent.length;
+    let dictLength = typeof parent.length === 'number' ? parent.length : 0;
+    let end = stream.pos + dictLength;
+    /** @type {StructValue} */
     let ret = {};
+    /** @type {unknown[]} */
     let operands = [];
 
     // define hidden properties
@@ -94,12 +147,20 @@ export default class CFFDict {
     return ret;
   }
 
+  /**
+   * @param {StructValue} dict
+   * @param {StructValue | CFFEncodeContext} parent
+   * @param {boolean} [includePointers]
+   * @returns {number}
+   */
   size(dict, parent, includePointers = true) {
+    /** @type {CFFEncodeContext} */
     let ctx = {
       parent,
       val: dict,
       pointerSize: 0,
-      startOffset: parent.startOffset || 0
+      startOffset: (typeof parent.startOffset === 'number' ? parent.startOffset : 0),
+      pointers: []
     };
 
     let len = 0;
@@ -113,7 +174,7 @@ export default class CFFDict {
 
       let operands = this.encodeOperands(field[2], null, ctx, val);
       for (let op of operands) {
-        len += CFFOperand.size(op);
+        len += CFFOperand.size(/** @type {CFFOperandValue} */ (op));
       }
 
       let key = Array.isArray(field[0]) ? field[0] : [field[0]];
@@ -127,11 +188,18 @@ export default class CFFDict {
     return len;
   }
 
+  /**
+   * @param {EncodeStream} stream
+   * @param {StructValue} dict
+   * @param {StructValue | null | undefined} parent
+   * @returns {void}
+   */
   encode(stream, dict, parent) {
+    /** @type {CFFEncodeContext} */
     let ctx = {
       pointers: [],
       startOffset: stream.pos,
-      parent,
+      parent: parent ?? undefined,
       val: dict,
       pointerSize: 0
     };
@@ -146,7 +214,7 @@ export default class CFFDict {
 
       let operands = this.encodeOperands(field[2], stream, ctx, val);
       for (let op of operands) {
-        CFFOperand.encode(stream, op);
+        CFFOperand.encode(stream, /** @type {CFFOperandValue} */ (op));
       }
 
       let key = Array.isArray(field[0]) ? field[0] : [field[0]];
@@ -158,7 +226,9 @@ export default class CFFDict {
     let i = 0;
     while (i < ctx.pointers.length) {
       let ptr = ctx.pointers[i++];
-      ptr.type.encode(stream, ptr.val, ptr.parent);
+      if (ptr.type.encode) {
+        ptr.type.encode(stream, ptr.val, ptr.parent);
+      }
     }
 
     return;

package/src/cff/CFFEncodings.js

@@ -1,3 +1,4 @@
+/** @type {string[]} */
 export let StandardEncoding = [
   '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',
   '', '', '', '', 'space', 'exclam', 'quotedbl', 'numbersign', 'dollar', 'percent', 'ampersand', 'quoteright',
@@ -18,6 +19,7 @@ export let StandardEncoding = [
   'lslash', 'oslash', 'oe', 'germandbls'
 ];
 
+/** @type {string[]} */
 export let ExpertEncoding = [
   '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',
   '', '', '', '', 'space', 'exclamsmall', 'Hungarumlautsmall', '', 'dollaroldstyle', 'dollarsuperior',

package/src/cff/CFFFont.js

@@ -1,68 +1,131 @@
 import CFFTop from './CFFTop';
 import standardStrings from './CFFStandardStrings';
 
+/** @typedef {import('restructure').DecodeStream} DecodeStream */
+/** @typedef {import('restructure').BinaryBuffer} BinaryBuffer */
+/** @typedef {import('restructure').StructValue} StructValue */
+/** @typedef {import('../../types/fontkit').CFFTopDict} CFFTopDict */
+/** @typedef {import('../../types/fontkit').CFFPrivateDict} CFFPrivateDict */
+/** @typedef {import('../../types/fontkit').CFFCharString} CFFCharString */
+
+/**
+ * Decoded CFF / CFF2 font table.
+ * Properties from CFFTop are copied onto the instance in decode().
+ */
 class CFFFont {
+  /**
+   * @param {DecodeStream} stream
+   */
   constructor(stream) {
+    /** @type {DecodeStream} */
     this.stream = stream;
+    /** @type {number} */
+    this.version = 0;
+    /** @type {number | undefined} */
+    this.hdrSize = undefined;
+    /** @type {CFFTopDict} */
+    this.topDict = /** @type {CFFTopDict} */ ({ CharStrings: [] });
+    /** @type {StructValue[] | undefined} */
+    this.topDictIndex = undefined;
+    /** @type {string[] | undefined} */
+    this.nameIndex = undefined;
+    /** @type {string[] | undefined} */
+    this.stringIndex = undefined;
+    /** @type {CFFCharString[] | undefined} */
+    this.globalSubrIndex = undefined;
+    /** @type {boolean} */
+    this.isCIDFont = false;
     this.decode();
   }
 
+  /**
+   * @param {DecodeStream} stream
+   * @returns {CFFFont}
+   */
   static decode(stream) {
     return new CFFFont(stream);
   }
 
+  /**
+   * @returns {this}
+   */
   decode() {
     let top = CFFTop.decode(this.stream);
     for (let key in top) {
-      let val = top[key];
-      this[key] = val;
+      /** @type {Record<string, unknown>} */ (/** @type {unknown} */ (this))[key] = top[key];
     }
 
     if (this.version < 2) {
-      if (this.topDictIndex.length !== 1) {
+      if (!this.topDictIndex || this.topDictIndex.length !== 1) {
         throw new Error('Only a single font is allowed in CFF');
       }
 
-      this.topDict = this.topDictIndex[0];
+      this.topDict = /** @type {CFFTopDict} */ (this.topDictIndex[0]);
     }
 
     this.isCIDFont = this.topDict.ROS != null;
     return this;
   }
 
+  /**
+   * @param {number | null | undefined} sid
+   * @returns {string | null}
+   */
   string(sid) {
     if (this.version >= 2) {
       return null;
     }
 
+    if (sid == null) {
+      return null;
+    }
+
     if (sid < standardStrings.length) {
       return standardStrings[sid];
     }
 
-    return this.stringIndex[sid - standardStrings.length];
+    return this.stringIndex ? this.stringIndex[sid - standardStrings.length] : null;
   }
 
+  /**
+   * @returns {string | null}
+   */
   get postscriptName() {
     if (this.version < 2) {
-      return this.nameIndex[0];
+      return this.nameIndex ? this.nameIndex[0] : null;
     }
 
     return null;
   }
 
+  /**
+   * @returns {string | null}
+   */
   get fullName() {
     return this.string(this.topDict.FullName);
   }
 
+  /**
+   * @returns {string | null}
+   */
   get familyName() {
     return this.string(this.topDict.FamilyName);
   }
 
+  /**
+   * @param {number} glyph
+   * @returns {BinaryBuffer}
+   */
   getCharString(glyph) {
-    this.stream.pos = this.topDict.CharStrings[glyph].offset;
-    return this.stream.readBuffer(this.topDict.CharStrings[glyph].length);
+    let cs = /** @type {CFFCharString} */ (this.topDict.CharStrings[glyph]);
+    this.stream.pos = cs.offset;
+    return this.stream.readBuffer(cs.length);
   }
 
+  /**
+   * @param {number} gid
+   * @returns {string | null}
+   */
   getGlyphName(gid) {
     // CFF2 glyph names are in the post table.
     if (this.version >= 2) {
@@ -76,7 +139,7 @@ class CFFFont {
 
     let { charset } = this.topDict;
     if (Array.isArray(charset)) {
-      return charset[gid];
+      return /** @type {string} */ (charset[gid]);
     }
 
     if (gid === 0) {
@@ -85,14 +148,30 @@ class CFFFont {
 
     gid -= 1;
 
-    switch (charset.version) {
+    if (!charset || typeof charset !== 'object') {
+      return null;
+    }
+
+    /**
+     * @typedef {{
+     *   version?: number,
+     *   glyphs?: number[],
+     *   ranges?: Array<{ offset: number, nLeft: number, first: number }>
+     * }} CharsetTable
+     */
+    let cs = /** @type {StructValue & CharsetTable} */ (charset);
+
+    switch (cs.version) {
       case 0:
-        return this.string(charset.glyphs[gid]);
+        return this.string(cs.glyphs ? cs.glyphs[gid] : undefined);
 
       case 1:
       case 2:
-        for (let i = 0; i < charset.ranges.length; i++) {
-          let range = charset.ranges[i];
+        if (!cs.ranges) {
+          return null;
+        }
+        for (let i = 0; i < cs.ranges.length; i++) {
+          let range = cs.ranges[i];
           if (range.offset <= gid && gid <= range.offset + range.nLeft) {
             return this.string(range.first + (gid - range.offset));
           }
@@ -103,44 +182,59 @@ class CFFFont {
     return null;
   }
 
+  /**
+   * @param {number} gid
+   * @returns {number | null}
+   */
   fdForGlyph(gid) {
     if (!this.topDict.FDSelect) {
       return null;
     }
 
-    switch (this.topDict.FDSelect.version) {
+    let fdSelect = this.topDict.FDSelect;
+
+    switch (fdSelect.version) {
       case 0:
-        return this.topDict.FDSelect.fds[gid];
+        return fdSelect.fds ? fdSelect.fds[gid] : null;
 
       case 3:
       case 4: {
-        let { ranges } = this.topDict.FDSelect;
+        let { ranges } = fdSelect;
+        if (!ranges) {
+          return null;
+        }
         let low = 0;
         let high = ranges.length - 1;
 
         while (low <= high) {
           let mid = (low + high) >> 1;
+          let midRange = ranges[mid];
+          let nextRange = ranges[mid + 1];
 
-          if (gid < ranges[mid].first) {
+          if (gid < midRange.first) {
             high = mid - 1;
-          } else if (mid < high && gid >= ranges[mid + 1].first) {
+          } else if (mid < high && nextRange && gid >= nextRange.first) {
             low = mid + 1;
           } else {
-            return ranges[mid].fd;
+            return midRange.fd;
           }
         }
 
-        throw new Error(`Unknown FDSelect version: ${this.topDict.FDSelect.version}`);
+        throw new Error(`Unknown FDSelect version: ${fdSelect.version}`);
       }
       default:
-        throw new Error(`Unknown FDSelect version: ${this.topDict.FDSelect.version}`);
+        throw new Error(`Unknown FDSelect version: ${fdSelect.version}`);
     }
   }
 
+  /**
+   * @param {number} gid
+   * @returns {CFFPrivateDict | null | undefined}
+   */
   privateDictForGlyph(gid) {
     if (this.topDict.FDSelect) {
       let fd = this.fdForGlyph(gid);
-      if (this.topDict.FDArray[fd]) {
+      if (fd != null && this.topDict.FDArray && this.topDict.FDArray[fd]) {
         return this.topDict.FDArray[fd].Private;
       }
 
@@ -151,7 +245,9 @@ class CFFFont {
       return this.topDict.Private;
     }
 
-    return this.topDict.FDArray[0].Private;
+    return this.topDict.FDArray && this.topDict.FDArray[0]
+      ? this.topDict.FDArray[0].Private
+      : null;
   }
 }
 

package/src/cff/CFFIndex.js

@@ -1,18 +1,38 @@
 import * as r from 'restructure';
 
+/** @typedef {import('restructure').BaseType} BaseType */
+/** @typedef {import('restructure').DecodeStream} DecodeStream */
+/** @typedef {import('restructure').EncodeStream} EncodeStream */
+/** @typedef {import('restructure').NumberT} NumberT */
+/** @typedef {import('restructure').StructValue} StructValue */
+/** @typedef {import('../../types/fontkit').CFFCharString} CFFCharString */
+
 export default class CFFIndex {
+  /**
+   * @param {BaseType} [type]
+   */
   constructor(type) {
+    /** @type {BaseType | undefined} */
     this.type = type;
   }
 
+  /**
+   * @param {StructValue | null | undefined} ctx
+   * @returns {number}
+   */
   getCFFVersion(ctx) {
     while (ctx && !ctx.hdrSize) {
       ctx = ctx.parent;
     }
 
-    return ctx ? ctx.version : -1;
+    return ctx && typeof ctx.version === 'number' ? ctx.version : -1;
   }
 
+  /**
+   * @param {DecodeStream} stream
+   * @param {StructValue} parent
+   * @returns {unknown[]}
+   */
   decode(stream, parent) {
     let version = this.getCFFVersion(parent);
     let count = version >= 2
@@ -24,6 +44,7 @@ export default class CFFIndex {
     }
 
     let offSize = stream.readUInt8();
+    /** @type {NumberT} */
     let offsetType;
     if (offSize === 1) {
       offsetType = r.uint8;
@@ -37,6 +58,7 @@ export default class CFFIndex {
       throw new Error(`Bad offset size in CFFIndex: ${offSize} ${stream.pos}`);
     }
 
+    /** @type {unknown[]} */
     let ret = [];
     let startPos = stream.pos + ((count + 1) * offSize) - 1;
 
@@ -44,7 +66,7 @@ export default class CFFIndex {
     for (let i = 0; i < count; i++) {
       let end = offsetType.decode(stream);
 
-      if (this.type != null) {
+      if (this.type != null && this.type.decode) {
         let pos = stream.pos;
         stream.pos = startPos + start;
 
@@ -52,10 +74,12 @@ export default class CFFIndex {
         ret.push(this.type.decode(stream, parent));
         stream.pos = pos;
       } else {
-        ret.push({
+        /** @type {CFFCharString} */
+        let range = {
           offset: startPos + start,
           length: end - start
-        });
+        };
+        ret.push(range);
       }
 
       start = end;
@@ -65,21 +89,35 @@ export default class CFFIndex {
     return ret;
   }
 
+  /**
+   * @param {unknown[]} arr
+   * @param {StructValue | null | undefined} parent
+   * @returns {number}
+   */
   size(arr, parent) {
     let size = 2;
     if (arr.length === 0) {
       return size;
     }
 
+    /** @type {BaseType} */
     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);
+      if (!type.size) {
+        throw new Error('CFFIndex element type must implement size()');
+      }
+      let itemSize = type.size(item, parent);
+      if (typeof itemSize !== 'number') {
+        throw new Error('CFFIndex element size() must return a number');
+      }
+      offset += itemSize;
     }
 
+    /** @type {NumberT} */
     let offsetType;
     if (offset <= 0xff) {
       offsetType = r.uint8;
@@ -99,23 +137,38 @@ export default class CFFIndex {
     return size;
   }
 
+  /**
+   * @param {EncodeStream} stream
+   * @param {unknown[]} arr
+   * @param {StructValue | null | undefined} parent
+   * @returns {void}
+   */
   encode(stream, arr, parent) {
     stream.writeUInt16BE(arr.length);
     if (arr.length === 0) {
       return;
     }
 
+    /** @type {BaseType} */
     let type = this.type || new r.Buffer();
 
     // find maximum offset to detminine offset type
+    /** @type {number[]} */
     let sizes = [];
     let offset = 1;
     for (let item of arr) {
+      if (!type.size) {
+        throw new Error('CFFIndex element type must implement size()');
+      }
       let s = type.size(item, parent);
+      if (typeof s !== 'number') {
+        throw new Error('CFFIndex element size() must return a number');
+      }
       sizes.push(s);
       offset += s;
     }
 
+    /** @type {NumberT} */
     let offsetType;
     if (offset <= 0xff) {
       offsetType = r.uint8;
@@ -142,6 +195,10 @@ export default class CFFIndex {
     }
 
     for (let item of arr) {
+      if (!type.encode) {
+        throw new Error('CFFIndex element type must implement encode()');
+      }
+      // Element type varies (String, Buffer, CFFDict, …); BaseType.encode accepts unknown.
       type.encode(stream, item, parent);
     }