@cantoo/fontkit 2.0.4 → 2.0.6

package/src/tables/maxp.js

@@ -1,20 +1,21 @@
 import * as r from 'restructure';
 
 // maxiumum profile
+/** @type {import('restructure').Struct} */
 export default new r.Struct({
-  version:                r.int32,
-  numGlyphs:              r.uint16,  // The number of glyphs in the font
-  maxPoints:              r.uint16,  // Maximum points in a non-composite glyph
-  maxContours:            r.uint16,  // Maximum contours in a non-composite glyph
-  maxComponentPoints:     r.uint16,  // Maximum points in a composite glyph
-  maxComponentContours:   r.uint16,  // Maximum contours in a composite glyph
-  maxZones:               r.uint16,  // 1 if instructions do not use the twilight zone, 2 otherwise
-  maxTwilightPoints:      r.uint16,  // Maximum points used in Z0
-  maxStorage:             r.uint16,  // Number of Storage Area locations
-  maxFunctionDefs:        r.uint16,  // Number of FDEFs
-  maxInstructionDefs:     r.uint16,  // Number of IDEFs
-  maxStackElements:       r.uint16,  // Maximum stack depth
-  maxSizeOfInstructions:  r.uint16,  // Maximum byte count for glyph instructions
-  maxComponentElements:   r.uint16,  // Maximum number of components referenced at “top level” for any composite glyph
-  maxComponentDepth:      r.uint16   // Maximum levels of recursion; 1 for simple components
+  version: r.int32,
+  numGlyphs: r.uint16, // The number of glyphs in the font
+  maxPoints: r.uint16, // Maximum points in a non-composite glyph
+  maxContours: r.uint16, // Maximum contours in a non-composite glyph
+  maxComponentPoints: r.uint16, // Maximum points in a composite glyph
+  maxComponentContours: r.uint16, // Maximum contours in a composite glyph
+  maxZones: r.uint16, // 1 if instructions do not use the twilight zone, 2 otherwise
+  maxTwilightPoints: r.uint16, // Maximum points used in Z0
+  maxStorage: r.uint16, // Number of Storage Area locations
+  maxFunctionDefs: r.uint16, // Number of FDEFs
+  maxInstructionDefs: r.uint16, // Number of IDEFs
+  maxStackElements: r.uint16, // Maximum stack depth
+  maxSizeOfInstructions: r.uint16, // Maximum byte count for glyph instructions
+  maxComponentElements: r.uint16, // Maximum number of components referenced at “top level” for any composite glyph
+  maxComponentDepth: r.uint16 // Maximum levels of recursion; 1 for simple components
 });

package/src/tables/morx.js

@@ -1,6 +1,8 @@
 import * as r from 'restructure';
 import { UnboundedArray, LookupTable, StateTable } from './aat';
 
+/** @typedef {import('restructure').StructValue} StructValue */
+
 let LigatureData = {
   action: r.uint16
 };
@@ -16,32 +18,32 @@ let InsertionData = {
 };
 
 let SubstitutionTable = new r.Struct({
-  items: new UnboundedArray(new r.Pointer(r.uint32, new LookupTable))
+  items: new UnboundedArray(new r.Pointer(r.uint32, LookupTable()))
 });
 
 let SubtableData = new r.VersionedStruct('type', {
   0: { // Indic Rearrangement Subtable
-    stateTable: new StateTable
+    stateTable: StateTable()
   },
 
   1: { // Contextual Glyph Substitution Subtable
-    stateTable: new StateTable(ContextualData),
+    stateTable: StateTable(ContextualData),
     substitutionTable: new r.Pointer(r.uint32, SubstitutionTable)
   },
 
   2: { // Ligature subtable
-    stateTable: new StateTable(LigatureData),
+    stateTable: StateTable(LigatureData),
     ligatureActions: new r.Pointer(r.uint32, new UnboundedArray(r.uint32)),
     components: new r.Pointer(r.uint32, new UnboundedArray(r.uint16)),
     ligatureList: new r.Pointer(r.uint32, new UnboundedArray(r.uint16))
   },
 
   4: { // Non-contextual Glyph Substitution Subtable
-    lookupTable: new LookupTable
+    lookupTable: LookupTable()
   },
 
   5: { // Glyph Insertion Subtable
-    stateTable: new StateTable(InsertionData),
+    stateTable: StateTable(InsertionData),
     insertionActions: new r.Pointer(r.uint32, new UnboundedArray(r.uint16))
   }
 });
@@ -52,28 +54,33 @@ let Subtable = new r.Struct({
   type: r.uint8,
   subFeatureFlags: r.uint32,
   table: SubtableData,
-  padding: new r.Reserved(r.uint8, t => t.length - t._currentOffset)
+  padding: new r.Reserved(
+    r.uint8,
+    /** @param {StructValue} t @returns {number} */
+    t => /** @type {number} */ (t.length) - /** @type {number} */ (t._currentOffset)
+  )
 });
 
 let FeatureEntry = new r.Struct({
-  featureType:    r.uint16,
+  featureType: r.uint16,
   featureSetting: r.uint16,
-  enableFlags:    r.uint32,
-  disableFlags:   r.uint32
+  enableFlags: r.uint32,
+  disableFlags: r.uint32
 });
 
 let MorxChain = new r.Struct({
-  defaultFlags:     r.uint32,
-  chainLength:      r.uint32,
-  nFeatureEntries:  r.uint32,
-  nSubtables:       r.uint32,
-  features:         new r.Array(FeatureEntry, 'nFeatureEntries'),
-  subtables:        new r.Array(Subtable, 'nSubtables')
+  defaultFlags: r.uint32,
+  chainLength: r.uint32,
+  nFeatureEntries: r.uint32,
+  nSubtables: r.uint32,
+  features: new r.Array(FeatureEntry, 'nFeatureEntries'),
+  subtables: new r.Array(Subtable, 'nSubtables')
 });
 
+/** @type {import('restructure').Struct} */
 export default new r.Struct({
-  version:  r.uint16,
-  unused:   new r.Reserved(r.uint16),
-  nChains:  r.uint32,
-  chains:   new r.Array(MorxChain, 'nChains')
+  version: r.uint16,
+  unused: new r.Reserved(r.uint16),
+  nChains: r.uint32,
+  chains: new r.Array(MorxChain, 'nChains')
 });

package/src/tables/name.js

@@ -1,35 +1,93 @@
 import * as r from 'restructure';
-import {getEncoding, LANGUAGES} from '../encodings';
+import { getEncoding, LANGUAGES } from '../encodings';
+
+/** @typedef {import('restructure').StructValue} StructValue */
+
+/**
+ * @typedef {{
+ *   platformID: number,
+ *   encodingID: number,
+ *   languageID: number,
+ *   nameID: number,
+ *   length: number,
+ *   string: string
+ * }} NameRecordValue
+ */
+
+/**
+ * @typedef {Record<string, string | unknown>} LangStringMap
+ */
+
+/**
+ * @typedef {{
+ *   fontFeatures: Record<number, LangStringMap>,
+ *   reservedNameID?: Record<number, LangStringMap>,
+ *   [key: string]: LangStringMap | Record<number, LangStringMap> | undefined
+ * }} NameRecordsMap
+ */
+
+/**
+ * @typedef {StructValue & {
+ *   version: number,
+ *   count: number,
+ *   stringOffset: number,
+ *   records: NameRecordValue[] | NameRecordsMap,
+ *   langTags?: Array<{ tag: string }>
+ * }} NameTableValue
+ */
 
 let NameRecord = new r.Struct({
   platformID: r.uint16,
   encodingID: r.uint16,
   languageID: r.uint16,
-  nameID:     r.uint16,
-  length:     r.uint16,
-  string:     new r.Pointer(r.uint16,
-    new r.String('length', t => getEncoding(t.platformID, t.encodingID, t.languageID)),
-    { type: 'parent', relativeTo: ctx => ctx.parent.stringOffset, allowNull: false }
+  nameID: r.uint16,
+  length: r.uint16,
+  string: new r.Pointer(
+    r.uint16,
+    new r.String(
+      'length',
+      /** @param {StructValue} t @returns {string} */
+      t => getEncoding(
+        /** @type {number} */ (t.platformID),
+        /** @type {number} */ (t.encodingID),
+        /** @type {number} */ (t.languageID)
+      ) || 'utf16be'
+    ),
+    {
+      type: 'parent',
+      /** @param {StructValue} ctx @returns {number} */
+      relativeTo: ctx => /** @type {number} */ (/** @type {StructValue} */ (ctx.parent).stringOffset),
+      allowNull: false
+    }
   )
 });
 
 let LangTagRecord = new r.Struct({
-  length:  r.uint16,
-  tag:     new r.Pointer(r.uint16, new r.String('length', 'utf16be'), {type: 'parent', relativeTo: ctx => ctx.stringOffset})
+  length: r.uint16,
+  tag: new r.Pointer(
+    r.uint16,
+    new r.String('length', 'utf16be'),
+    {
+      type: 'parent',
+      /** @param {StructValue} ctx @returns {number} */
+      relativeTo: ctx => /** @type {number} */ (ctx.stringOffset)
+    }
+  )
 });
 
+/** @type {import('restructure').VersionedStruct} */
 var NameTable = new r.VersionedStruct(r.uint16, {
   0: {
-    count:          r.uint16,
-    stringOffset:   r.uint16,
-    records:        new r.Array(NameRecord, 'count')
+    count: r.uint16,
+    stringOffset: r.uint16,
+    records: new r.Array(NameRecord, 'count')
   },
   1: {
-    count:          r.uint16,
-    stringOffset:   r.uint16,
-    records:        new r.Array(NameRecord, 'count'),
-    langTagCount:   r.uint16,
-    langTags:       new r.Array(LangTagRecord, 'langTagCount')
+    count: r.uint16,
+    stringOffset: r.uint16,
+    records: new r.Array(NameRecord, 'count'),
+    langTagCount: r.uint16,
+    langTags: new r.Array(LangTagRecord, 'langTagCount')
   }
 });
 
@@ -61,9 +119,15 @@ const NAMES = [
   'wwsSubfamilyName',
   'lightBackgroundPalette',
   'darkBackgroundPalette',
-  'variationsPostScriptNamePrefix',
+  'variationsPostScriptNamePrefix'
 ];
 
+/**
+ * @param {NameRecordValue[]} out
+ * @param {number} nameID
+ * @param {unknown} string
+ * @returns {void}
+ */
 function pushEnRecord(out, nameID, string) {
   if (typeof string !== 'string') return;
 
@@ -77,14 +141,18 @@ function pushEnRecord(out, nameID, string) {
   });
 }
 
-NameTable.process = function(_stream) {
-  let records = {fontFeatures: {}};
+NameTable.process = function (_stream) {
+  let self = /** @type {NameTableValue} */ (this);
+  /** @type {NameRecordsMap} */
+  let records = { fontFeatures: {} };
 
-  for (let record of this.records) {
-    let language = LANGUAGES[record.platformID][record.languageID];
+  for (let record of /** @type {NameRecordValue[]} */ (self.records)) {
+    let platformMap = LANGUAGES[record.platformID] || {};
+    /** @type {string | undefined} */
+    let language = platformMap[record.languageID];
 
-    if (language == null && this.langTags != null && record.languageID >= 0x8000) {
-      language = this.langTags[record.languageID - 0x8000].tag;
+    if (language == null && self.langTags != null && record.languageID >= 0x8000) {
+      language = self.langTags[record.languageID - 0x8000].tag;
     }
 
     if (language == null) {
@@ -109,49 +177,62 @@ NameTable.process = function(_stream) {
     }
   }
 
-  this.records = records;
+  self.records = records;
 };
 
-NameTable.preEncode = function() {
-  if (Array.isArray(this.records)) return;
-  this.version = 0;
+NameTable.preEncode = function () {
+  let self = /** @type {NameTableValue} */ (this);
+  if (Array.isArray(self.records)) return;
+  self.version = 0;
 
+  /** @type {NameRecordValue[]} */
   let records = [];
-  for (let key in this.records) {
-    let val = this.records[key];
+  /** @type {NameRecordsMap} */
+  let map = self.records;
+  for (let key of Object.keys(map)) {
+    let val = map[key];
 
     if (key === 'fontFeatures') {
       // Mirrors of IDs < 256 are encoded via named/reserved keys above.
-      for (let id in val) {
-        if (+id >= 256) pushEnRecord(records, +id, val[id].en);
+      let features = /** @type {Record<number, LangStringMap>} */ (val);
+      for (let id of Object.keys(features)) {
+        if (+id >= 256) {
+          let langs = features[+id];
+          pushEnRecord(records, +id, langs && langs.en);
+        }
       }
       continue;
     }
 
     if (key === 'reservedNameID') {
-      for (let id in val) pushEnRecord(records, +id, val[id].en);
+      let reserved = /** @type {Record<number, LangStringMap>} */ (val);
+      for (let id of Object.keys(reserved)) {
+        let langs = reserved[+id];
+        pushEnRecord(records, +id, langs && langs.en);
+      }
       continue;
     }
 
     let nameID = NAMES.indexOf(key);
     if (nameID < 0) continue;
 
-    pushEnRecord(records, nameID, val.en);
+    let langs = /** @type {LangStringMap} */ (val);
+    pushEnRecord(records, nameID, langs.en);
 
     // Match historical behaviour: also write PostScript name for Mac platform.
-    if (key === 'postscriptName' && typeof val.en === 'string') {
+    if (key === 'postscriptName' && typeof langs.en === 'string') {
       records.push({
         platformID: 1,
         encodingID: 0,
         languageID: 0,
         nameID,
-        length: val.en.length,
-        string: val.en
+        length: langs.en.length,
+        string: langs.en
       });
     }
   }
 
-  this.records = records;
-  this.count = records.length;
-  this.stringOffset = NameTable.size(this, null, false);
+  self.records = records;
+  self.count = records.length;
+  self.stringOffset = NameTable.size(self, null, false);
 };

package/src/tables/opbd.js

@@ -8,8 +8,9 @@ let OpticalBounds = new r.Struct({
   bottom: r.int16
 });
 
+/** @type {import('restructure').Struct} */
 export default new r.Struct({
   version: r.fixed32,
   format: r.uint16,
-  lookupTable: new LookupTable(OpticalBounds)
+  lookupTable: LookupTable(OpticalBounds)
 });