@cantoo/fontkit 2.0.4 → 2.0.6

package/src/packages/unicode-properties/index.js

@@ -2,6 +2,10 @@ import UnicodeTrie from '../unicode-trie/index.js';
 import data from './data.js';
 import trieBase64 from './data-trie.js';
 
+/**
+ * @param {string} base64
+ * @returns {Uint8Array}
+ */
 function decodeBase64(base64) {
   if (typeof Buffer !== 'undefined') {
     return new Uint8Array(Buffer.from(base64, 'base64'));
@@ -17,8 +21,13 @@ function decodeBase64(base64) {
 
 const trie = new UnicodeTrie(decodeBase64(trieBase64));
 
+/** @type {(n: number) => number} */
 const log2 = Math.log2 || (n => Math.log(n) / Math.LN2);
-const bits = (n) => ((log2(n) + 1) | 0);
+/**
+ * @param {number} n
+ * @returns {number}
+ */
+const bits = n => ((log2(n) + 1) | 0);
 
 // compute the number of bits stored for each field
 const CATEGORY_BITS = bits(data.categories.length - 1);
@@ -38,26 +47,46 @@ const SCRIPT_MASK = (1 << SCRIPT_BITS) - 1;
 const EAW_MASK = (1 << EAW_BITS) - 1;
 const NUMBER_MASK = (1 << NUMBER_BITS) - 1;
 
+/**
+ * @param {number} codePoint
+ * @returns {string}
+ */
 export function getCategory(codePoint) {
   const val = trie.get(codePoint);
   return data.categories[(val >> CATEGORY_SHIFT) & CATEGORY_MASK];
 }
 
+/**
+ * @param {number} codePoint
+ * @returns {string}
+ */
 export function getCombiningClass(codePoint) {
   const val = trie.get(codePoint);
   return data.combiningClasses[(val >> COMBINING_SHIFT) & COMBINING_MASK];
 }
 
+/**
+ * @param {number} codePoint
+ * @returns {string}
+ */
 export function getScript(codePoint) {
   const val = trie.get(codePoint);
   return data.scripts[(val >> SCRIPT_SHIFT) & SCRIPT_MASK];
 }
 
+/**
+ * @param {number} codePoint
+ * @returns {string}
+ */
 export function getEastAsianWidth(codePoint) {
   const val = trie.get(codePoint);
   return data.eaw[(val >> EAW_SHIFT) & EAW_MASK];
 }
 
+/**
+ * @param {number} codePoint
+ * @returns {number | null}
+ */
 export function getNumericValue(codePoint) {
   let val = trie.get(codePoint);
   let num = val & NUMBER_MASK;
@@ -90,78 +119,114 @@ export function getNumericValue(codePoint) {
   }
 }
 
+/**
+ * @param {number} codePoint
+ * @returns {boolean}
+ */
 export function isAlphabetic(codePoint) {
   const category = getCategory(codePoint);
   return (
-    category === 'Lu' ||
-    category === 'Ll' ||
-    category === 'Lt' ||
-    category === 'Lm' ||
-    category === 'Lo' ||
-    category === 'Nl'
+    category === 'Lu'
+    || category === 'Ll'
+    || category === 'Lt'
+    || category === 'Lm'
+    || category === 'Lo'
+    || category === 'Nl'
   );
 }
 
+/**
+ * @param {number} codePoint
+ * @returns {boolean}
+ */
 export function isDigit(codePoint) {
   return getCategory(codePoint) === 'Nd';
 }
 
+/**
+ * @param {number} codePoint
+ * @returns {boolean}
+ */
 export function isPunctuation(codePoint) {
   const category = getCategory(codePoint);
   return (
-    category === 'Pc' ||
-    category === 'Pd' ||
-    category === 'Pe' ||
-    category === 'Pf' ||
-    category === 'Pi' ||
-    category === 'Po' ||
-    category === 'Ps'
+    category === 'Pc'
+    || category === 'Pd'
+    || category === 'Pe'
+    || category === 'Pf'
+    || category === 'Pi'
+    || category === 'Po'
+    || category === 'Ps'
   );
 }
 
+/**
+ * @param {number} codePoint
+ * @returns {boolean}
+ */
 export function isLowerCase(codePoint) {
   return getCategory(codePoint) === 'Ll';
 }
 
+/**
+ * @param {number} codePoint
+ * @returns {boolean}
+ */
 export function isUpperCase(codePoint) {
   return getCategory(codePoint) === 'Lu';
 }
 
+/**
+ * @param {number} codePoint
+ * @returns {boolean}
+ */
 export function isTitleCase(codePoint) {
   return getCategory(codePoint) === 'Lt';
 }
 
+/**
+ * @param {number} codePoint
+ * @returns {boolean}
+ */
 export function isWhiteSpace(codePoint) {
   const category = getCategory(codePoint);
   return (
-    category === 'Zs' ||
-    category === 'Zl' ||
-    category === 'Zp'
+    category === 'Zs'
+    || category === 'Zl'
+    || category === 'Zp'
   );
 }
 
+/**
+ * @param {number} codePoint
+ * @returns {boolean}
+ */
 export function isBaseForm(codePoint) {
   const category = getCategory(codePoint);
   return (
-    category === 'Nd' ||
-    category === 'No' ||
-    category === 'Nl' ||
-    category === 'Lu' ||
-    category === 'Ll' ||
-    category === 'Lt' ||
-    category === 'Lm' ||
-    category === 'Lo' ||
-    category === 'Me' ||
-    category === 'Mc'
+    category === 'Nd'
+    || category === 'No'
+    || category === 'Nl'
+    || category === 'Lu'
+    || category === 'Ll'
+    || category === 'Lt'
+    || category === 'Lm'
+    || category === 'Lo'
+    || category === 'Me'
+    || category === 'Mc'
   );
 }
 
+/**
+ * @param {number} codePoint
+ * @returns {boolean}
+ */
 export function isMark(codePoint) {
   const category = getCategory(codePoint);
   return (
-    category === 'Mn' ||
-    category === 'Me' ||
-    category === 'Mc'
+    category === 'Mn'
+    || category === 'Me'
+    || category === 'Mc'
   );
 }
 

package/src/packages/unicode-properties/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cantoo/unicode-properties",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Fast access to unicode character properties (vendored for @cantoo/fontkit)",
   "type": "module",
   "main": "./dist/index.cjs",

package/src/packages/unicode-trie/builder.js

@@ -1,6 +1,6 @@
-import { deflateSync } from "fflate";
-import UnicodeTrie from "./index.js";
-import { swap32LE } from "./swap.js";
+import { deflateSync } from 'fflate';
+import UnicodeTrie from './index.js';
+import { swap32LE } from './swap.js';
 
 // Shift size for getting the index-1 table offset.
 const SHIFT_1 = 6 + 5;
@@ -57,7 +57,7 @@ const INDEX_2_BMP_LENGTH = LSCP_INDEX_2_OFFSET + LSCP_INDEX_2_LENGTH;
 // The 2-byte UTF-8 version of the index-2 table follows at offset 2080=0x820.
 // Length 32=0x20 for lead bytes C0..DF, regardless of SHIFT_2.
 const UTF8_2B_INDEX_2_OFFSET = INDEX_2_BMP_LENGTH;
-const UTF8_2B_INDEX_2_LENGTH = 0x800 >> 6;  // U+0800 is the first code point after 2-byte UTF-8
+const UTF8_2B_INDEX_2_LENGTH = 0x800 >> 6; // U+0800 is the first code point after 2-byte UTF-8
 
 // The index-1 table, only used for supplementary code points, at offset 2112=0x840.
 // Variable length, for code points up to highStart, where the last single-value range starts.
@@ -139,6 +139,13 @@ const INDEX_2_START_OFFSET = INDEX_2_NULL_OFFSET + INDEX_2_BLOCK_LENGTH;
 // (0x110000>>SHIFT_2)+UTF8_2B_INDEX_2_LENGTH+MAX_INDEX_1_LENGTH.)
 const MAX_INDEX_LENGTH = 0xffff;
 
+/**
+ * @param {ArrayLike<number>} a
+ * @param {number} s
+ * @param {number} t
+ * @param {number} length
+ * @returns {boolean}
+ */
 const equal_int = (a, s, t, length) => {
   for (let i = 0; i < length; i++) {
     if (a[s + i] !== a[t + i]) {
@@ -150,24 +157,37 @@ const equal_int = (a, s, t, length) => {
 };
 
 class UnicodeTrieBuilder {
+  /**
+   * @param {number} [initialValue=0]
+   * @param {number} [errorValue=0]
+   */
   constructor(initialValue, errorValue) {
     let i, j;
     if (initialValue == null) {
       initialValue = 0;
     }
+    /** @type {number} */
     this.initialValue = initialValue;
     if (errorValue == null) {
       errorValue = 0;
     }
+    /** @type {number} */
     this.errorValue = errorValue;
+    /** @type {Int32Array} */
     this.index1 = new Int32Array(INDEX_1_LENGTH);
+    /** @type {Int32Array} */
     this.index2 = new Int32Array(MAX_INDEX_2_LENGTH);
+    /** @type {number} */
     this.highStart = 0x110000;
 
+    /** @type {Uint32Array} */
     this.data = new Uint32Array(INITIAL_DATA_LENGTH);
+    /** @type {number} */
     this.dataCapacity = INITIAL_DATA_LENGTH;
 
+    /** @type {number} */
     this.firstFreeBlock = 0;
+    /** @type {boolean} */
     this.isCompacted = false;
 
     // Multi-purpose per-data-block table.
@@ -183,13 +203,14 @@ class UnicodeTrieBuilder {
     //
     // Map of adjusted indexes, used in compactData() and compactIndex2().
     // Maps from original indexes to new ones.
+    /** @type {Int32Array} */
     this.map = new Int32Array(MAX_DATA_LENGTH_BUILDTIME >> SHIFT_2);
 
     for (i = 0; i < 0x80; i++) {
       this.data[i] = this.initialValue;
     }
 
-    for (i = i; i < 0xc0; i++) {
+    for (; i < 0xc0; i++) {
       this.data[i] = this.errorValue;
     }
 
@@ -197,7 +218,9 @@ class UnicodeTrieBuilder {
       this.data[i] = this.initialValue;
     }
 
+    /** @type {number} */
     this.dataNullOffset = DATA_NULL_OFFSET;
+    /** @type {number} */
     this.dataLength = NEW_DATA_START_OFFSET;
 
     // set the index-2 indexes for the 2=0x80>>SHIFT_2 ASCII data blocks
@@ -208,7 +231,7 @@ class UnicodeTrieBuilder {
     }
 
     // reference counts for the bad-UTF-8-data block
-    for (j = j; j < 0xc0; j += DATA_BLOCK_LENGTH) {
+    for (; j < 0xc0; j += DATA_BLOCK_LENGTH) {
       this.map[i++] = 0;
     }
 
@@ -218,7 +241,7 @@ class UnicodeTrieBuilder {
     // i==newTrie->dataNullOffset
     this.map[i++] = ((0x110000 >> SHIFT_2) - (0x80 >> SHIFT_2)) + 1 + LSCP_INDEX_2_LENGTH;
     j += DATA_BLOCK_LENGTH;
-    for (j = j; j < NEW_DATA_START_OFFSET; j += DATA_BLOCK_LENGTH) {
+    for (; j < NEW_DATA_START_OFFSET; j += DATA_BLOCK_LENGTH) {
       this.map[i++] = 0;
     }
 
@@ -239,7 +262,9 @@ class UnicodeTrieBuilder {
       this.index2[INDEX_2_NULL_OFFSET + i] = DATA_NULL_OFFSET;
     }
 
+    /** @type {number} */
     this.index2NullOffset = INDEX_2_NULL_OFFSET;
+    /** @type {number} */
     this.index2Length = INDEX_2_START_OFFSET;
 
     // set the index-1 indexes for the linear index-2 block
@@ -250,7 +275,7 @@ class UnicodeTrieBuilder {
     }
 
     // set the remaining index-1 indexes to the null index-2 block
-    for (i = i; i < INDEX_1_LENGTH; i++) {
+    for (; i < INDEX_1_LENGTH; i++) {
       this.index1[i] = INDEX_2_NULL_OFFSET;
     }
 
@@ -260,9 +285,13 @@ class UnicodeTrieBuilder {
     for (i = 0x80; i < 0x800; i += DATA_BLOCK_LENGTH) {
       this.set(i, this.initialValue);
     }
-
   }
 
+  /**
+   * @param {number} codePoint
+   * @param {number} value
+   * @returns {this}
+   */
   set(codePoint, value) {
     if ((codePoint < 0) || (codePoint > 0x10ffff)) {
       throw new Error('Invalid code point');
@@ -277,6 +306,13 @@ class UnicodeTrieBuilder {
     return this;
   }
 
+  /**
+   * @param {number} start
+   * @param {number} end
+   * @param {number} value
+   * @param {boolean} [overwrite=true]
+   * @returns {this}
+   */
   setRange(start, end, value, overwrite) {
     let block, repeatBlock;
     if (overwrite == null) {
@@ -346,7 +382,6 @@ class UnicodeTrieBuilder {
           // protected block: just write the values into this block
           this._fillBlock(block, 0, DATA_BLOCK_LENGTH, value, this.initialValue, overwrite);
         }
-
       } else if ((this.data[block] !== value) && (overwrite || (block === this.dataNullOffset))) {
         // Set the repeatBlock instead of the null block or previous repeat block:
         //
@@ -387,6 +422,11 @@ class UnicodeTrieBuilder {
     return this;
   }
 
+  /**
+   * @param {number} c
+   * @param {boolean} [fromLSCP=true]
+   * @returns {number}
+   */
   get(c, fromLSCP) {
     let i2;
     if (fromLSCP == null) {
@@ -410,6 +450,11 @@ class UnicodeTrieBuilder {
     return this.data[block + (c & DATA_MASK)];
   }
 
+  /**
+   * @param {number} c
+   * @param {boolean} forLSCP
+   * @returns {boolean}
+   */
   _isInNullBlock(c, forLSCP) {
     let i2;
     if (((c & 0xfffffc00) === 0xd800) && forLSCP) {
@@ -422,6 +467,9 @@ class UnicodeTrieBuilder {
     return block === this.dataNullOffset;
   }
 
+  /**
+   * @returns {number}
+   */
   _allocIndex2Block() {
     const newBlock = this.index2Length;
     const newTop = newBlock + INDEX_2_BLOCK_LENGTH;
@@ -429,7 +477,7 @@ class UnicodeTrieBuilder {
       // Should never occur.
       // Either MAX_BUILD_TIME_INDEX_LENGTH is incorrect,
       // or the code writes more values than should be possible.
-      throw new Error("Internal error in Trie2 creation.");
+      throw new Error('Internal error in Trie2 creation.');
     }
 
     this.index2Length = newTop;
@@ -438,6 +486,11 @@ class UnicodeTrieBuilder {
     return newBlock;
   }
 
+  /**
+   * @param {number} c
+   * @param {boolean} forLSCP
+   * @returns {number}
+   */
   _getIndex2Block(c, forLSCP) {
     if ((c >= 0xd800) && (c < 0xdc00) && forLSCP) {
       return LSCP_INDEX_2_OFFSET;
@@ -453,10 +506,18 @@ class UnicodeTrieBuilder {
     return i2;
   }
 
+  /**
+   * @param {number} block
+   * @returns {boolean}
+   */
   _isWritableBlock(block) {
     return (block !== this.dataNullOffset) && (this.map[block >> SHIFT_2] === 1);
   }
 
+  /**
+   * @param {number} copyBlock
+   * @returns {number}
+   */
   _allocDataBlock(copyBlock) {
     let newBlock;
     if (this.firstFreeBlock !== 0) {
@@ -478,7 +539,7 @@ class UnicodeTrieBuilder {
           // Should never occur.
           // Either MAX_DATA_LENGTH_BUILDTIME is incorrect,
           // or the code writes more values than should be possible.
-          throw new Error("Internal error in Trie2 creation.");
+          throw new Error('Internal error in Trie2 creation.');
         }
 
         const newData = new Uint32Array(capacity);
@@ -495,14 +556,23 @@ class UnicodeTrieBuilder {
     return newBlock;
   }
 
+  /**
+   * @param {number} block
+   * @returns {void}
+   */
   _releaseDataBlock(block) {
     // put this block at the front of the free-block chain
     this.map[block >> SHIFT_2] = -this.firstFreeBlock;
     this.firstFreeBlock = block;
   }
 
+  /**
+   * @param {number} i2
+   * @param {number} block
+   * @returns {void}
+   */
   _setIndex2Entry(i2, block) {
-    ++this.map[block >> SHIFT_2];  // increment first, in case block == oldBlock!
+    ++this.map[block >> SHIFT_2]; // increment first, in case block == oldBlock!
     const oldBlock = this.index2[i2];
     if (--this.map[oldBlock >> SHIFT_2] === 0) {
       this._releaseDataBlock(oldBlock);
@@ -511,6 +581,11 @@ class UnicodeTrieBuilder {
     this.index2[i2] = block;
   }
 
+  /**
+   * @param {number} c
+   * @param {boolean} forLSCP
+   * @returns {number}
+   */
   _getDataBlock(c, forLSCP) {
     let i2 = this._getIndex2Block(c, forLSCP);
     i2 += (c >> SHIFT_2) & INDEX_2_MASK;
@@ -526,6 +601,15 @@ class UnicodeTrieBuilder {
     return newBlock;
   }
 
+  /**
+   * @param {number} block
+   * @param {number} start
+   * @param {number} limit
+   * @param {number} value
+   * @param {number} initialValue
+   * @param {boolean} overwrite
+   * @returns {void}
+   */
   _fillBlock(block, start, limit, value, initialValue, overwrite) {
     let i;
     if (overwrite) {
@@ -541,6 +625,11 @@ class UnicodeTrieBuilder {
     }
   }
 
+  /**
+   * @param {number} block
+   * @param {number} value
+   * @returns {void}
+   */
   _writeBlock(block, value) {
     const limit = block + DATA_BLOCK_LENGTH;
     while (block < limit) {
@@ -548,6 +637,10 @@ class UnicodeTrieBuilder {
     }
   }
 
+  /**
+   * @param {number} highValue
+   * @returns {number}
+   */
   _findHighStart(highValue) {
     let prevBlock, prevI2Block;
     const data32 = this.data;
@@ -620,6 +713,12 @@ class UnicodeTrieBuilder {
     return 0;
   }
 
+  /**
+   * @param {number} dataLength
+   * @param {number} otherBlock
+   * @param {number} blockLength
+   * @returns {number}
+   */
   _findSameDataBlock(dataLength, otherBlock, blockLength) {
     // ensure that we do not even partially get past dataLength
     dataLength -= blockLength;
@@ -634,6 +733,11 @@ class UnicodeTrieBuilder {
     return -1;
   }
 
+  /**
+   * @param {number} index2Length
+   * @param {number} otherBlock
+   * @returns {number}
+   */
   _findSameIndex2Block(index2Length, otherBlock) {
     // ensure that we do not even partially get past index2Length
     index2Length -= INDEX_2_BLOCK_LENGTH;
@@ -646,6 +750,9 @@ class UnicodeTrieBuilder {
     return -1;
   }
 
+  /**
+   * @returns {void}
+   */
   _compactData() {
     // do not compact linear-ASCII data
     let newStart = DATA_START_OFFSET;
@@ -719,7 +826,6 @@ class UnicodeTrieBuilder {
         for (i = blockLength - overlap; i > 0; i--) {
           this.data[newStart++] = this.data[start++];
         }
-
       } else { // no overlap && newStart==start
         mapIndex = start >> SHIFT_2;
         for (i = blockCount; i > 0; i--) {
@@ -751,6 +857,9 @@ class UnicodeTrieBuilder {
     this.dataLength = newStart;
   }
 
+  /**
+   * @returns {void}
+   */
   _compactIndex2() {
     // do not compact linear-BMP index-2 blocks
     let newStart = INDEX_2_BMP_LENGTH;
@@ -799,7 +908,6 @@ class UnicodeTrieBuilder {
         for (i = INDEX_2_BLOCK_LENGTH - overlap; i > 0; i--) {
           this.index2[newStart++] = this.index2[start++];
         }
-
       } else { // no overlap && newStart==start
         this.map[start >> SHIFT_1_2] = start;
         start += INDEX_2_BLOCK_LENGTH;
@@ -827,6 +935,9 @@ class UnicodeTrieBuilder {
     this.index2Length = newStart;
   }
 
+  /**
+   * @returns {void}
+   */
   _compact() {
     // find highStart and round it up
     let highValue = this.get(0x10ffff);
@@ -861,6 +972,9 @@ class UnicodeTrieBuilder {
     this.isCompacted = true;
   }
 
+  /**
+   * @returns {import('./index.js').default}
+   */
   freeze() {
     let allIndexesLength, i;
     if (!this.isCompacted) {
@@ -876,11 +990,11 @@ class UnicodeTrieBuilder {
     const dataMove = allIndexesLength;
 
     // are indexLength and dataLength within limits?
-    if ((allIndexesLength > MAX_INDEX_LENGTH) || // for unshifted indexLength
-      ((dataMove + this.dataNullOffset) > 0xffff) || // for unshifted dataNullOffset
-      ((dataMove + DATA_0800_OFFSET) > 0xffff) || // for unshifted 2-byte UTF-8 index-2 values
-      ((dataMove + this.dataLength) > MAX_DATA_LENGTH_RUNTIME)) { // for shiftedDataLength
-      throw new Error("Trie data is too large.");
+    if ((allIndexesLength > MAX_INDEX_LENGTH) // for unshifted indexLength
+      || ((dataMove + this.dataNullOffset) > 0xffff) // for unshifted dataNullOffset
+      || ((dataMove + DATA_0800_OFFSET) > 0xffff) // for unshifted 2-byte UTF-8 index-2 values
+      || ((dataMove + this.dataLength) > MAX_DATA_LENGTH_RUNTIME)) { // for shiftedDataLength
+      throw new Error('Trie data is too large.');
     }
 
     // calculate the sizes of, and allocate, the index and data arrays
@@ -898,7 +1012,7 @@ class UnicodeTrieBuilder {
       data[destIdx++] = (dataMove + BAD_UTF8_DATA_OFFSET);
     }
 
-    for (i = i; i < 0xe0 - 0xc0; i++) { // C2..DF
+    for (; i < 0xe0 - 0xc0; i++) { // C2..DF
       data[destIdx++] = (dataMove + this.index2[i << (6 - SHIFT_2)]);
     }
 
@@ -932,13 +1046,16 @@ class UnicodeTrieBuilder {
     return dest;
   }
 
-  // Generates a Buffer containing the serialized and compressed trie.
-  // Trie data is compressed once with raw deflate (a second pass does not help).
-  // Format:
-  //   uint32_t highStart;
-  //   uint32_t errorValue;
-  //   uint32_t uncompressedDataLength;
-  //   uint8_t trieData[dataLength];
+  /**
+   * Generates a Buffer containing the serialized and compressed trie.
+   * Trie data is compressed once with raw deflate (a second pass does not help).
+   * Format:
+   *   uint32_t highStart;
+   *   uint32_t errorValue;
+   *   uint32_t uncompressedDataLength;
+   *   uint8_t trieData[dataLength];
+   * @returns {Buffer}
+   */
   toBuffer() {
     const trie = this.freeze();
 
@@ -962,4 +1079,4 @@ class UnicodeTrieBuilder {
   }
 }
 
-export default UnicodeTrieBuilder;
+export default UnicodeTrieBuilder;