@cantoo/fontkit 2.0.4 → 2.0.6

package/src/glyph/WOFF2Glyph.js

@@ -1,46 +1,61 @@
 import TTFGlyph, { Point } from './TTFGlyph';
 import BBox from './BBox';
 
+/** @typedef {import('../../types/fontkit').DecodedGlyf} DecodedGlyf */
+/** @typedef {import('../../types/fontkit').GlyphComponent} GlyphComponent */
+
 /**
  * Represents a TrueType glyph in the WOFF2 format, which compresses glyphs differently.
  */
 export default class WOFF2Glyph extends TTFGlyph {
   type = 'WOFF2';
 
+  /**
+   * @returns {DecodedGlyf | null}
+   */
   _decode() {
-    let cached = this._font._transformedGlyphs[this.id];
+    let cached = this._font._transformedGlyphs?.[this.id];
     if (!cached) {
       return null;
     }
 
     if (!this._font._variationProcessor) {
       // Non-variable path: return the pre-decoded glyph without copying.
-      return cached;
+      return /** @type {DecodedGlyf} */ (cached);
     }
 
     // Clone so per-instance deltas do not mutate the shared transformed cache.
     // Transformed glyf has no per-glyph bbox; zeros keep phantom-point math
     // aligned with hmtx (same approach as a missing bbox bitmap entry).
+    /** @type {DecodedGlyf} */
     let glyph = {
       numberOfContours: cached.numberOfContours,
       xMin: 0,
       yMin: 0,
       xMax: 0,
-      yMax: 0,
+      yMax: 0
     };
 
     if (cached.points) {
-      glyph.points = cached.points.map(p => p.copy());
+      glyph.points = cached.points.map((p) => {
+        if (typeof p.copy === 'function') {
+          return p.copy();
+        }
+        return new Point(p.onCurve, p.endContour, p.x, p.y);
+      });
       let points = glyph.points.concat(this._getPhantomPoints(glyph));
       this._font._variationProcessor.transformPoints(this.id, points);
       glyph.phantomPoints = points.slice(-4);
     }
 
     if (cached.components) {
-      glyph.components = cached.components.map(c => {
-        return Object.assign(Object.create(Object.getPrototypeOf(c)), c);
+      glyph.components = cached.components.map((c) => {
+        /** @type {GlyphComponent} */
+        let clone = Object.assign(Object.create(Object.getPrototypeOf(c)), c);
+        return clone;
       });
 
+      /** @type {Point[]} */
       let points = [];
       for (let component of glyph.components) {
         points.push(new Point(true, true, component.dx, component.dy));
@@ -59,6 +74,10 @@ export default class WOFF2Glyph extends TTFGlyph {
     return glyph;
   }
 
+  /**
+   * @param {boolean} [internal]
+   * @returns {BBox}
+   */
   _getCBox(internal) {
     // Avoid path recursion while building phantom points during variation decode.
     if (internal) {

package/src/layout/GlyphPosition.js

@@ -2,6 +2,12 @@
  * Represents positioning information for a glyph in a GlyphRun.
  */
 export default class GlyphPosition {
+  /**
+   * @param {number} [xAdvance]
+   * @param {number} [yAdvance]
+   * @param {number} [xOffset]
+   * @param {number} [yOffset]
+   */
   constructor(xAdvance = 0, yAdvance = 0, xOffset = 0, yOffset = 0) {
     /**
      * The amount to move the virtual pen in the X direction after rendering this glyph.

package/src/layout/GlyphRun.js

@@ -6,43 +6,50 @@ import * as Script from '../layout/Script';
  * Returned by the font layout method.
  */
 export default class GlyphRun {
+  /**
+   * @param {import('../glyph/Glyph').default[]} glyphs
+   * @param {import('../../types/fontkit').FeatureInput | null | undefined} features
+   * @param {import('../../types/fontkit').ScriptTag | string[] | null | undefined} script
+   * @param {import('../../types/fontkit').LanguageTag | null | undefined} language
+   * @param {import('../../types/fontkit').TextDirection | null | undefined} direction
+   */
   constructor(glyphs, features, script, language, direction) {
     /**
      * An array of Glyph objects in the run
-     * @type {Glyph[]}
+     * @type {import('../glyph/Glyph').default[]}
      */
     this.glyphs = glyphs;
 
     /**
      * An array of GlyphPosition objects for each glyph in the run
-     * @type {GlyphPosition[]}
+     * @type {import('./GlyphPosition').default[] | null}
      */
     this.positions = null;
 
     /**
      * The script that was requested for shaping. This was either passed in or detected automatically.
-     * @type {string}
+     * @type {import('../../types/fontkit').ScriptTag | string[] | null | undefined}
      */
     this.script = script;
 
     /**
      * The language requested for shaping, as passed in. If `null`, the default language for the
      * script was used.
-     * @type {string}
+     * @type {import('../../types/fontkit').LanguageTag | null}
      */
     this.language = language || null;
 
     /**
      * The direction requested for shaping, as passed in (either ltr or rtl).
      * If `null`, the default direction of the script is used.
-     * @type {string}
+     * @type {import('../../types/fontkit').TextDirection}
      */
     this.direction = direction || Script.direction(script);
 
     /**
      * The features requested during shaping. This is a combination of user
      * specified features and features chosen by the shaper.
-     * @type {object}
+     * @type {import('../../types/fontkit').FeatureMap}
      */
     this.features = {};
 
@@ -51,7 +58,7 @@ export default class GlyphRun {
       for (let tag of features) {
         this.features[tag] = true;
       }
-    } else if (typeof features === 'object') {
+    } else if (typeof features === 'object' && features !== null) {
       this.features = features;
     }
   }
@@ -62,6 +69,10 @@ export default class GlyphRun {
    */
   get advanceWidth() {
     let width = 0;
+    if (!this.positions) {
+      return width;
+    }
+
     for (let position of this.positions) {
       width += position.xAdvance;
     }
@@ -69,12 +80,16 @@ export default class GlyphRun {
     return width;
   }
 
- /**
+  /**
   * The total advance height of the run.
   * @type {number}
   */
   get advanceHeight() {
     let height = 0;
+    if (!this.positions) {
+      return height;
+    }
+
     for (let position of this.positions) {
       height += position.yAdvance;
     }
@@ -82,12 +97,15 @@ export default class GlyphRun {
     return height;
   }
 
- /**
+  /**
   * The bounding box containing all glyphs in the run.
   * @type {BBox}
   */
   get bbox() {
-    let bbox = new BBox;
+    let bbox = new BBox();
+    if (!this.positions) {
+      return bbox;
+    }
 
     let x = 0;
     let y = 0;

package/src/layout/KernProcessor.js

@@ -1,10 +1,54 @@
-import {binarySearch} from '../utils';
+import { binarySearch } from '../utils';
+
+/** @typedef {import('../../types/fontkit').LayoutFont} LayoutFont */
+/** @typedef {import('../../types/fontkit').KernTable} KernTable */
+/** @typedef {import('../../types/fontkit').KernPair} KernPair */
+/** @typedef {import('../../types/fontkit').KernFormat0} KernFormat0 */
+/** @typedef {import('../../types/fontkit').KernFormat2} KernFormat2 */
+/** @typedef {import('../../types/fontkit').KernFormat3} KernFormat3 */
+/** @typedef {import('../../types/fontkit').GlyphInfoLike} GlyphInfoLike */
+/** @typedef {import('../../types/fontkit').LayoutGlyph} LayoutGlyph */
+/** @typedef {import('../../types/fontkit').GlyphPositionLike} GlyphPositionLike */
+
+/**
+ * @param {unknown} s
+ * @returns {s is KernFormat0}
+ */
+function isKernFormat0(s) {
+  return typeof s === 'object' && s !== null && Array.isArray(/** @type {{ pairs?: unknown }} */ (s).pairs);
+}
+
+/**
+ * @param {unknown} s
+ * @returns {s is KernFormat2}
+ */
+function isKernFormat2(s) {
+  return typeof s === 'object' && s !== null
+    && 'leftTable' in s && 'rightTable' in s && 'array' in s;
+}
+
+/**
+ * @param {unknown} s
+ * @returns {s is KernFormat3}
+ */
+function isKernFormat3(s) {
+  return typeof s === 'object' && s !== null
+    && 'glyphCount' in s && 'kernValue' in s && 'kernIndex' in s;
+}
 
 export default class KernProcessor {
+  /**
+   * @param {LayoutFont} font
+   */
   constructor(font) {
-    this.kern = font.kern;
+    /** @type {KernTable} */
+    this.kern = /** @type {KernTable} */ (font.kern);
   }
 
+  /**
+   * @param {Array<LayoutGlyph | GlyphInfoLike>} glyphs
+   * @param {GlyphPositionLike[]} positions
+   */
   process(glyphs, positions) {
     for (let glyphIndex = 0; glyphIndex < glyphs.length - 1; glyphIndex++) {
       let left = glyphs[glyphIndex].id;
@@ -13,6 +57,11 @@ export default class KernProcessor {
     }
   }
 
+  /**
+   * @param {number} left
+   * @param {number} right
+   * @returns {number}
+   */
   getKerning(left, right) {
     let res = 0;
 
@@ -42,7 +91,10 @@ export default class KernProcessor {
       let s = table.subtable;
       switch (table.format) {
         case 0: {
-          let pairIdx = binarySearch(s.pairs, function (pair) {
+          if (!isKernFormat0(s)) {
+            break;
+          }
+          let pairIdx = binarySearch(s.pairs, /** @param {KernPair} pair */ (pair) => {
             return (left - pair.left) || (right - pair.right);
           });
 
@@ -54,7 +106,11 @@ export default class KernProcessor {
         }
 
         case 2: {
-          let leftOffset, rightOffset = 0;
+          if (!isKernFormat2(s)) {
+            break;
+          }
+          let leftOffset = 0;
+          let rightOffset = 0;
           if (left >= s.leftTable.firstGlyph && left < s.leftTable.firstGlyph + s.leftTable.nGlyphs) {
             leftOffset = s.leftTable.offsets[left - s.leftTable.firstGlyph];
           } else {
@@ -71,6 +127,9 @@ export default class KernProcessor {
         }
 
         case 3: {
+          if (!isKernFormat3(s)) {
+            break;
+          }
           if (left >= s.glyphCount || right >= s.glyphCount) {
             return 0;
           }

package/src/layout/LayoutEngine.js

@@ -6,32 +6,60 @@ import * as Script from './Script';
 import AATLayoutEngine from '../aat/AATLayoutEngine';
 import OTLayoutEngine from '../opentype/OTLayoutEngine';
 
+/** @typedef {import('../../types/fontkit').LayoutFont} LayoutFont */
+/** @typedef {import('../../types/fontkit').LayoutGlyph} LayoutGlyph */
+/** @typedef {import('../../types/fontkit').FeatureInput} FeatureInput */
+/** @typedef {import('../../types/fontkit').FeatureMap} FeatureMap */
+/** @typedef {import('../../types/fontkit').ScriptTag} ScriptTag */
+/** @typedef {import('../../types/fontkit').LanguageTag} LanguageTag */
+/** @typedef {import('../../types/fontkit').TextDirection} TextDirection */
+/** @typedef {import('../../types/fontkit').AdvancedLayoutEngine} AdvancedLayoutEngine */
+/** @typedef {import('../../types/fontkit').GlyphRunLike} GlyphRunLike */
+/** @typedef {import('../../types/fontkit').GlyphPositionLike} GlyphPositionLike */
+/** @typedef {import('./GlyphRun').default} GlyphRunInstance */
+
 export default class LayoutEngine {
+  /**
+   * @param {LayoutFont} font
+   */
   constructor(font) {
+    /** @type {LayoutFont} */
     this.font = font;
+    /** @type {UnicodeLayoutEngine | null} */
     this.unicodeLayoutEngine = null;
+    /** @type {KernProcessor | null} */
     this.kernProcessor = null;
+    /** @type {AdvancedLayoutEngine | undefined} */
+    this.engine = undefined;
 
     // Choose an advanced layout engine. We try the AAT morx table first since more
     // scripts are currently supported because the shaping logic is built into the font.
     if (this.font.morx) {
-      this.engine = new AATLayoutEngine(this.font);
-
+      this.engine = /** @type {AdvancedLayoutEngine} */ (new AATLayoutEngine(this.font));
     } else if (this.font.GSUB || this.font.GPOS) {
-      this.engine = new OTLayoutEngine(this.font);
+      this.engine = /** @type {AdvancedLayoutEngine} */ (new OTLayoutEngine(this.font));
     }
   }
 
+  /**
+   * @param {string | LayoutGlyph[]} string
+   * @param {FeatureInput | ScriptTag | string[] | null | undefined} [features]
+   * @param {ScriptTag | string[] | LanguageTag | null | undefined} [script]
+   * @param {LanguageTag | TextDirection | null | undefined} [language]
+   * @param {TextDirection | null | undefined} [direction]
+   * @returns {GlyphRunInstance}
+   */
   layout(string, features, script, language, direction) {
     // Make the features parameter optional
     if (typeof features === 'string') {
-      direction = language;
-      language = script;
+      direction = /** @type {TextDirection | null | undefined} */ (language);
+      language = /** @type {LanguageTag | null | undefined} */ (script);
       script = features;
       features = [];
     }
 
     // Map string to glyphs if needed
+    /** @type {LayoutGlyph[]} */
     let glyphs;
     if (typeof string === 'string') {
       // Attempt to detect the script from the string if not provided.
@@ -43,6 +71,7 @@ export default class LayoutEngine {
     } else {
       // Attempt to detect the script from the glyph code points if not provided.
       if (script == null) {
+        /** @type {number[]} */
         let codePoints = [];
         for (let glyph of string) {
           codePoints.push(...glyph.codePoints);
@@ -54,7 +83,13 @@ export default class LayoutEngine {
       glyphs = string;
     }
 
-    let glyphRun = new GlyphRun(glyphs, features, script, language, direction);
+    let glyphRun = new GlyphRun(
+      /** @type {import('../glyph/Glyph').default[]} */ (glyphs),
+      /** @type {FeatureInput | null | undefined} */ (features),
+      script,
+      /** @type {LanguageTag | null | undefined} */ (language),
+      /** @type {TextDirection | null | undefined} */ (direction)
+    );
 
     // Return early if there are no glyphs
     if (glyphs.length === 0) {
@@ -64,14 +99,16 @@ export default class LayoutEngine {
 
     // Setup the advanced layout engine
     if (this.engine && this.engine.setup) {
-      this.engine.setup(glyphRun);
+      this.engine.setup(/** @type {GlyphRunLike} */ (glyphRun));
     }
 
     // Substitute and position the glyphs
     this.substitute(glyphRun);
     this.position(glyphRun);
 
-    this.hideDefaultIgnorables(glyphRun.glyphs, glyphRun.positions);
+    if (glyphRun.positions) {
+      this.hideDefaultIgnorables(/** @type {LayoutGlyph[]} */ (glyphRun.glyphs), glyphRun.positions);
+    }
 
     // Let the layout engine clean up any state it might have
     if (this.engine && this.engine.cleanup) {
@@ -81,21 +118,30 @@ export default class LayoutEngine {
     return glyphRun;
   }
 
+  /**
+   * @param {GlyphRunInstance} glyphRun
+   */
   substitute(glyphRun) {
     // Call the advanced layout engine to make substitutions
     if (this.engine && this.engine.substitute) {
-      this.engine.substitute(glyphRun);
+      this.engine.substitute(/** @type {GlyphRunLike} */ (glyphRun));
     }
   }
 
+  /**
+   * @param {GlyphRunInstance} glyphRun
+   */
   position(glyphRun) {
     // Get initial glyph positions
-    glyphRun.positions = glyphRun.glyphs.map(glyph => new GlyphPosition(glyph.advanceWidth));
+    glyphRun.positions = /** @type {LayoutGlyph[]} */ (glyphRun.glyphs).map(
+      /** @param {LayoutGlyph} glyph */ glyph => new GlyphPosition(glyph.advanceWidth)
+    );
+    /** @type {FeatureMap | Record<string, import('../../types/fontkit').OTFeature> | null | undefined | false} */
     let positioned = null;
 
     // Call the advanced layout engine. Returns the features applied.
     if (this.engine && this.engine.position) {
-      positioned = this.engine.position(glyphRun);
+      positioned = this.engine.position(/** @type {GlyphRunLike} */ (glyphRun));
     }
 
     // if there is no GPOS table, use unicode properties to position marks.
@@ -104,7 +150,10 @@ export default class LayoutEngine {
         this.unicodeLayoutEngine = new UnicodeLayoutEngine(this.font);
       }
 
-      this.unicodeLayoutEngine.positionGlyphs(glyphRun.glyphs, glyphRun.positions);
+      this.unicodeLayoutEngine.positionGlyphs(
+        /** @type {LayoutGlyph[]} */ (glyphRun.glyphs),
+        /** @type {GlyphPositionLike[]} */ (glyphRun.positions)
+      );
     }
 
     // if kerning is not supported by GPOS, do kerning with the TrueType/AAT kern table
@@ -113,13 +162,23 @@ export default class LayoutEngine {
         this.kernProcessor = new KernProcessor(this.font);
       }
 
-      this.kernProcessor.process(glyphRun.glyphs, glyphRun.positions);
+      this.kernProcessor.process(
+        /** @type {LayoutGlyph[]} */ (glyphRun.glyphs),
+        /** @type {GlyphPositionLike[]} */ (glyphRun.positions)
+      );
       glyphRun.features.kern = true;
     }
   }
 
+  /**
+   * @param {LayoutGlyph[]} glyphs
+   * @param {GlyphPositionLike[]} positions
+   */
   hideDefaultIgnorables(glyphs, positions) {
     let space = this.font.glyphForCodePoint(0x20);
+    if (!space) {
+      return;
+    }
     for (let i = 0; i < glyphs.length; i++) {
       if (this.isDefaultIgnorable(glyphs[i].codePoints[0])) {
         glyphs[i] = space;
@@ -129,6 +188,10 @@ export default class LayoutEngine {
     }
   }
 
+  /**
+   * @param {number} ch
+   * @returns {boolean}
+   */
   isDefaultIgnorable(ch) {
     // From DerivedCoreProperties.txt in the Unicode database,
     // minus U+115F, U+1160, U+3164 and U+FFA0, which is what
@@ -137,27 +200,33 @@ export default class LayoutEngine {
     if (plane === 0) {
       // BMP
       switch (ch >> 8) {
-      	case 0x00: return ch === 0x00AD;
-      	case 0x03: return ch === 0x034F;
-      	case 0x06: return ch === 0x061C;
-      	case 0x17: return 0x17B4 <= ch && ch <= 0x17B5;
-      	case 0x18: return 0x180B <= ch && ch <= 0x180E;
-      	case 0x20: return (0x200B <= ch && ch <= 0x200F) || (0x202A <= ch && ch <= 0x202E) || (0x2060 <= ch && ch <= 0x206F);
-      	case 0xFE: return (0xFE00 <= ch && ch <= 0xFE0F) || ch === 0xFEFF;
-      	case 0xFF: return 0xFFF0 <= ch && ch <= 0xFFF8;
-      	default:   return false;
+        case 0x00: return ch === 0x00AD;
+        case 0x03: return ch === 0x034F;
+        case 0x06: return ch === 0x061C;
+        case 0x17: return 0x17B4 <= ch && ch <= 0x17B5;
+        case 0x18: return 0x180B <= ch && ch <= 0x180E;
+        case 0x20: return (0x200B <= ch && ch <= 0x200F) || (0x202A <= ch && ch <= 0x202E) || (0x2060 <= ch && ch <= 0x206F);
+        case 0xFE: return (0xFE00 <= ch && ch <= 0xFE0F) || ch === 0xFEFF;
+        case 0xFF: return 0xFFF0 <= ch && ch <= 0xFFF8;
+        default: return false;
       }
     } else {
       // Other planes
       switch (plane) {
-      	case 0x01: return (0x1BCA0 <= ch && ch <= 0x1BCA3) || (0x1D173 <= ch && ch <= 0x1D17A);
-      	case 0x0E: return 0xE0000 <= ch && ch <= 0xE0FFF;
-      	default:   return false;
+        case 0x01: return (0x1BCA0 <= ch && ch <= 0x1BCA3) || (0x1D173 <= ch && ch <= 0x1D17A);
+        case 0x0E: return 0xE0000 <= ch && ch <= 0xE0FFF;
+        default: return false;
       }
     }
   }
 
+  /**
+   * @param {ScriptTag | string[] | null | undefined} [script]
+   * @param {LanguageTag | null | undefined} [language]
+   * @returns {string[]}
+   */
   getAvailableFeatures(script, language) {
+    /** @type {string[]} */
     let features = [];
 
     if (this.engine) {
@@ -171,8 +240,12 @@ export default class LayoutEngine {
     return features;
   }
 
+  /**
+   * @param {number} gid
+   * @returns {string[]}
+   */
   stringsForGlyph(gid) {
-    let result = new Set;
+    let result = new Set();
 
     let codePoints = this.font._cmapProcessor.codePointsForGlyph(gid);
     for (let codePoint of codePoints) {

package/src/layout/Script.js

@@ -1,8 +1,11 @@
-import {getScript} from '../packages/unicode-properties/index.js';
+import { getScript } from '../packages/unicode-properties/index.js';
+
+/** @typedef {import('../../types/fontkit').TextDirection} TextDirection */
 
 // This maps the Unicode Script property to an OpenType script tag
 // Data from http://www.microsoft.com/typography/otspec/scripttags.htm
 // and http://www.unicode.org/Public/UNIDATA/PropertyValueAliases.txt.
+/** @type {Record<string, string | string[]>} */
 const UNICODE_SCRIPTS = {
   Caucasian_Albanian: 'aghb',
   Arabic: 'arab',
@@ -133,6 +136,7 @@ const UNICODE_SCRIPTS = {
   Unknown: 'zzzz'
 };
 
+/** @type {Record<string, string>} */
 const OPENTYPE_SCRIPTS = {};
 for (let script in UNICODE_SCRIPTS) {
   let tag = UNICODE_SCRIPTS[script];
@@ -145,14 +149,26 @@ for (let script in UNICODE_SCRIPTS) {
   }
 }
 
+/**
+ * @param {string} script
+ * @returns {string | string[] | undefined}
+ */
 export function fromUnicode(script) {
   return UNICODE_SCRIPTS[script];
 }
 
+/**
+ * @param {string} tag
+ * @returns {string | undefined}
+ */
 export function fromOpenType(tag) {
   return OPENTYPE_SCRIPTS[tag];
 }
 
+/**
+ * @param {string} string
+ * @returns {string | string[]}
+ */
 export function forString(string) {
   let len = string.length;
   let idx = 0;
@@ -179,6 +195,10 @@ export function forString(string) {
   return UNICODE_SCRIPTS.Unknown;
 }
 
+/**
+ * @param {number[]} codePoints
+ * @returns {string | string[]}
+ */
 export function forCodePoints(codePoints) {
   for (let i = 0; i < codePoints.length; i++) {
     let codePoint = codePoints[i];
@@ -192,38 +212,44 @@ export function forCodePoints(codePoints) {
 }
 
 // The scripts in this map are written from right to left
+/** @type {Record<string, boolean>} */
 const RTL = {
-  arab: true,   // Arabic
-  hebr: true,   // Hebrew
-  syrc: true,   // Syriac
-  thaa: true,   // Thaana
-  cprt: true,   // Cypriot Syllabary
-  khar: true,   // Kharosthi
-  phnx: true,   // Phoenician
+  arab: true, // Arabic
+  hebr: true, // Hebrew
+  syrc: true, // Syriac
+  thaa: true, // Thaana
+  cprt: true, // Cypriot Syllabary
+  khar: true, // Kharosthi
+  phnx: true, // Phoenician
   'nko ': true, // N'Ko
-  lydi: true,   // Lydian
-  avst: true,   // Avestan
-  armi: true,   // Imperial Aramaic
-  phli: true,   // Inscriptional Pahlavi
-  prti: true,   // Inscriptional Parthian
-  sarb: true,   // Old South Arabian
-  orkh: true,   // Old Turkic, Orkhon Runic
-  samr: true,   // Samaritan
-  mand: true,   // Mandaic, Mandaean
-  merc: true,   // Meroitic Cursive
-  mero: true,   // Meroitic Hieroglyphs
+  lydi: true, // Lydian
+  avst: true, // Avestan
+  armi: true, // Imperial Aramaic
+  phli: true, // Inscriptional Pahlavi
+  prti: true, // Inscriptional Parthian
+  sarb: true, // Old South Arabian
+  orkh: true, // Old Turkic, Orkhon Runic
+  samr: true, // Samaritan
+  mand: true, // Mandaic, Mandaean
+  merc: true, // Meroitic Cursive
+  mero: true, // Meroitic Hieroglyphs
 
   // Unicode 7.0 (not listed on http://www.microsoft.com/typography/otspec/scripttags.htm)
-  mani: true,   // Manichaean
-  mend: true,   // Mende Kikakui
-  nbat: true,   // Nabataean
-  narb: true,   // Old North Arabian
-  palm: true,   // Palmyrene
-  phlp: true    // Psalter Pahlavi
+  mani: true, // Manichaean
+  mend: true, // Mende Kikakui
+  nbat: true, // Nabataean
+  narb: true, // Old North Arabian
+  palm: true, // Palmyrene
+  phlp: true // Psalter Pahlavi
 };
 
+/**
+ * @param {string | string[] | null | undefined} script
+ * @returns {TextDirection}
+ */
 export function direction(script) {
-  if (RTL[script]) {
+  let tag = Array.isArray(script) ? script[0] : script;
+  if (tag && RTL[tag]) {
     return 'rtl';
   }