@cantoo/fontkit 2.0.7 → 2.0.9

package/dist/unicode-trie/builder.cjs

@@ -0,0 +1,821 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// builder.js
+var builder_exports = {};
+__export(builder_exports, {
+  default: () => builder_default
+});
+module.exports = __toCommonJS(builder_exports);
+var import_fflate2 = require("fflate");
+
+// index.js
+var import_fflate = require("fflate");
+
+// swap.js
+var isBigEndian = new Uint8Array(new Uint32Array([305419896]).buffer)[0] === 18;
+var swap = (b, n, m) => {
+  let i = b[n];
+  b[n] = b[m];
+  b[m] = i;
+};
+var swap32 = (array) => {
+  const len = array.length;
+  for (let i = 0; i < len; i += 4) {
+    swap(array, i, i + 3);
+    swap(array, i + 1, i + 2);
+  }
+};
+var swap32LE = (array) => {
+  if (isBigEndian) {
+    swap32(array);
+  }
+};
+
+// index.js
+function isNodeBuffer(value) {
+  return typeof value === "object" && value !== null && "readUInt32BE" in value && "readUInt32LE" in value && "slice" in value && typeof value.readUInt32BE === "function" && typeof value.readUInt32LE === "function" && typeof value.slice === "function";
+}
+var SHIFT_1 = 6 + 5;
+var SHIFT_2 = 5;
+var SHIFT_1_2 = SHIFT_1 - SHIFT_2;
+var OMITTED_BMP_INDEX_1_LENGTH = 65536 >> SHIFT_1;
+var INDEX_2_BLOCK_LENGTH = 1 << SHIFT_1_2;
+var INDEX_2_MASK = INDEX_2_BLOCK_LENGTH - 1;
+var INDEX_SHIFT = 2;
+var DATA_BLOCK_LENGTH = 1 << SHIFT_2;
+var DATA_MASK = DATA_BLOCK_LENGTH - 1;
+var LSCP_INDEX_2_OFFSET = 65536 >> SHIFT_2;
+var LSCP_INDEX_2_LENGTH = 1024 >> SHIFT_2;
+var INDEX_2_BMP_LENGTH = LSCP_INDEX_2_OFFSET + LSCP_INDEX_2_LENGTH;
+var UTF8_2B_INDEX_2_OFFSET = INDEX_2_BMP_LENGTH;
+var UTF8_2B_INDEX_2_LENGTH = 2048 >> 6;
+var INDEX_1_OFFSET = UTF8_2B_INDEX_2_OFFSET + UTF8_2B_INDEX_2_LENGTH;
+var DATA_GRANULARITY = 1 << INDEX_SHIFT;
+var UnicodeTrie = class {
+  /**
+   * @param {Uint8Array | Buffer | UnicodeTrieInit} data
+   */
+  constructor(data) {
+    if (isNodeBuffer(data) || data instanceof Uint8Array) {
+      let bytes;
+      let uncompressedLength;
+      if (isNodeBuffer(data)) {
+        this.highStart = data.readUInt32LE(0);
+        this.errorValue = data.readUInt32LE(4);
+        uncompressedLength = data.readUInt32LE(8);
+        bytes = new Uint8Array(data.buffer, data.byteOffset + 12, data.byteLength - 12);
+      } else {
+        const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+        this.highStart = view.getUint32(0, true);
+        this.errorValue = view.getUint32(4, true);
+        uncompressedLength = view.getUint32(8, true);
+        bytes = data.subarray(12);
+      }
+      bytes = (0, import_fflate.inflateSync)(bytes, { out: new Uint8Array(uncompressedLength) });
+      swap32LE(bytes);
+      this.data = new Uint32Array(bytes.buffer, bytes.byteOffset, bytes.byteLength >> 2);
+    } else {
+      this.data = data.data;
+      this.highStart = data.highStart;
+      this.errorValue = data.errorValue;
+    }
+  }
+  /**
+   * @param {number} codePoint
+   * @returns {number}
+   */
+  get(codePoint) {
+    let index;
+    if (codePoint < 0 || codePoint > 1114111) {
+      return this.errorValue;
+    }
+    if (codePoint < 55296 || codePoint > 56319 && codePoint <= 65535) {
+      index = (this.data[codePoint >> SHIFT_2] << INDEX_SHIFT) + (codePoint & DATA_MASK);
+      return this.data[index];
+    }
+    if (codePoint <= 65535) {
+      index = (this.data[LSCP_INDEX_2_OFFSET + (codePoint - 55296 >> SHIFT_2)] << INDEX_SHIFT) + (codePoint & DATA_MASK);
+      return this.data[index];
+    }
+    if (codePoint < this.highStart) {
+      index = this.data[INDEX_1_OFFSET - OMITTED_BMP_INDEX_1_LENGTH + (codePoint >> SHIFT_1)];
+      index = this.data[index + (codePoint >> SHIFT_2 & INDEX_2_MASK)];
+      index = (index << INDEX_SHIFT) + (codePoint & DATA_MASK);
+      return this.data[index];
+    }
+    return this.data[this.data.length - DATA_GRANULARITY];
+  }
+};
+var index_default = UnicodeTrie;
+
+// builder.js
+var SHIFT_12 = 6 + 5;
+var SHIFT_22 = 5;
+var SHIFT_1_22 = SHIFT_12 - SHIFT_22;
+var OMITTED_BMP_INDEX_1_LENGTH2 = 65536 >> SHIFT_12;
+var CP_PER_INDEX_1_ENTRY = 1 << SHIFT_12;
+var INDEX_2_BLOCK_LENGTH2 = 1 << SHIFT_1_22;
+var INDEX_2_MASK2 = INDEX_2_BLOCK_LENGTH2 - 1;
+var DATA_BLOCK_LENGTH2 = 1 << SHIFT_22;
+var DATA_MASK2 = DATA_BLOCK_LENGTH2 - 1;
+var INDEX_SHIFT2 = 2;
+var DATA_GRANULARITY2 = 1 << INDEX_SHIFT2;
+var INDEX_2_OFFSET = 0;
+var LSCP_INDEX_2_OFFSET2 = 65536 >> SHIFT_22;
+var LSCP_INDEX_2_LENGTH2 = 1024 >> SHIFT_22;
+var INDEX_2_BMP_LENGTH2 = LSCP_INDEX_2_OFFSET2 + LSCP_INDEX_2_LENGTH2;
+var UTF8_2B_INDEX_2_OFFSET2 = INDEX_2_BMP_LENGTH2;
+var UTF8_2B_INDEX_2_LENGTH2 = 2048 >> 6;
+var INDEX_1_OFFSET2 = UTF8_2B_INDEX_2_OFFSET2 + UTF8_2B_INDEX_2_LENGTH2;
+var MAX_INDEX_1_LENGTH = 1048576 >> SHIFT_12;
+var BAD_UTF8_DATA_OFFSET = 128;
+var DATA_START_OFFSET = 192;
+var DATA_NULL_OFFSET = DATA_START_OFFSET;
+var NEW_DATA_START_OFFSET = DATA_NULL_OFFSET + 64;
+var DATA_0800_OFFSET = NEW_DATA_START_OFFSET + 1920;
+var INITIAL_DATA_LENGTH = 1 << 14;
+var MEDIUM_DATA_LENGTH = 1 << 17;
+var MAX_DATA_LENGTH_RUNTIME = 65535 << INDEX_SHIFT2;
+var INDEX_1_LENGTH = 1114112 >> SHIFT_12;
+var MAX_DATA_LENGTH_BUILDTIME = 1114112 + 64 + 64 + 1024;
+var INDEX_GAP_OFFSET = INDEX_2_BMP_LENGTH2;
+var INDEX_GAP_LENGTH = UTF8_2B_INDEX_2_LENGTH2 + MAX_INDEX_1_LENGTH + INDEX_2_MASK2 & ~INDEX_2_MASK2;
+var MAX_INDEX_2_LENGTH = (1114112 >> SHIFT_22) + LSCP_INDEX_2_LENGTH2 + INDEX_GAP_LENGTH + INDEX_2_BLOCK_LENGTH2;
+var INDEX_2_NULL_OFFSET = INDEX_GAP_OFFSET + INDEX_GAP_LENGTH;
+var INDEX_2_START_OFFSET = INDEX_2_NULL_OFFSET + INDEX_2_BLOCK_LENGTH2;
+var MAX_INDEX_LENGTH = 65535;
+var equal_int = (a, s, t, length) => {
+  for (let i = 0; i < length; i++) {
+    if (a[s + i] !== a[t + i]) {
+      return false;
+    }
+  }
+  return true;
+};
+var UnicodeTrieBuilder = class {
+  /**
+   * @param {number} [initialValue=0]
+   * @param {number} [errorValue=0]
+   */
+  constructor(initialValue, errorValue) {
+    let i, j;
+    if (initialValue == null) {
+      initialValue = 0;
+    }
+    this.initialValue = initialValue;
+    if (errorValue == null) {
+      errorValue = 0;
+    }
+    this.errorValue = errorValue;
+    this.index1 = new Int32Array(INDEX_1_LENGTH);
+    this.index2 = new Int32Array(MAX_INDEX_2_LENGTH);
+    this.highStart = 1114112;
+    this.data = new Uint32Array(INITIAL_DATA_LENGTH);
+    this.dataCapacity = INITIAL_DATA_LENGTH;
+    this.firstFreeBlock = 0;
+    this.isCompacted = false;
+    this.map = new Int32Array(MAX_DATA_LENGTH_BUILDTIME >> SHIFT_22);
+    for (i = 0; i < 128; i++) {
+      this.data[i] = this.initialValue;
+    }
+    for (; i < 192; i++) {
+      this.data[i] = this.errorValue;
+    }
+    for (i = DATA_NULL_OFFSET; i < NEW_DATA_START_OFFSET; i++) {
+      this.data[i] = this.initialValue;
+    }
+    this.dataNullOffset = DATA_NULL_OFFSET;
+    this.dataLength = NEW_DATA_START_OFFSET;
+    i = 0;
+    for (j = 0; j < 128; j += DATA_BLOCK_LENGTH2) {
+      this.index2[i] = j;
+      this.map[i++] = 1;
+    }
+    for (; j < 192; j += DATA_BLOCK_LENGTH2) {
+      this.map[i++] = 0;
+    }
+    this.map[i++] = (1114112 >> SHIFT_22) - (128 >> SHIFT_22) + 1 + LSCP_INDEX_2_LENGTH2;
+    j += DATA_BLOCK_LENGTH2;
+    for (; j < NEW_DATA_START_OFFSET; j += DATA_BLOCK_LENGTH2) {
+      this.map[i++] = 0;
+    }
+    for (i = 128 >> SHIFT_22; i < INDEX_2_BMP_LENGTH2; i++) {
+      this.index2[i] = DATA_NULL_OFFSET;
+    }
+    for (i = 0; i < INDEX_GAP_LENGTH; i++) {
+      this.index2[INDEX_GAP_OFFSET + i] = -1;
+    }
+    for (i = 0; i < INDEX_2_BLOCK_LENGTH2; i++) {
+      this.index2[INDEX_2_NULL_OFFSET + i] = DATA_NULL_OFFSET;
+    }
+    this.index2NullOffset = INDEX_2_NULL_OFFSET;
+    this.index2Length = INDEX_2_START_OFFSET;
+    j = 0;
+    for (i = 0; i < OMITTED_BMP_INDEX_1_LENGTH2; i++) {
+      this.index1[i] = j;
+      j += INDEX_2_BLOCK_LENGTH2;
+    }
+    for (; i < INDEX_1_LENGTH; i++) {
+      this.index1[i] = INDEX_2_NULL_OFFSET;
+    }
+    for (i = 128; i < 2048; i += DATA_BLOCK_LENGTH2) {
+      this.set(i, this.initialValue);
+    }
+  }
+  /**
+   * @param {number} codePoint
+   * @param {number} value
+   * @returns {this}
+   */
+  set(codePoint, value) {
+    if (codePoint < 0 || codePoint > 1114111) {
+      throw new Error("Invalid code point");
+    }
+    if (this.isCompacted) {
+      throw new Error("Already compacted");
+    }
+    const block = this._getDataBlock(codePoint, true);
+    this.data[block + (codePoint & DATA_MASK2)] = value;
+    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) {
+      overwrite = true;
+    }
+    if (start > 1114111 || end > 1114111 || start > end) {
+      throw new Error("Invalid code point");
+    }
+    if (this.isCompacted) {
+      throw new Error("Already compacted");
+    }
+    if (!overwrite && value === this.initialValue) {
+      return this;
+    }
+    let limit = end + 1;
+    if ((start & DATA_MASK2) !== 0) {
+      block = this._getDataBlock(start, true);
+      const nextStart = start + DATA_BLOCK_LENGTH2 & ~DATA_MASK2;
+      if (nextStart <= limit) {
+        this._fillBlock(block, start & DATA_MASK2, DATA_BLOCK_LENGTH2, value, this.initialValue, overwrite);
+        start = nextStart;
+      } else {
+        this._fillBlock(block, start & DATA_MASK2, limit & DATA_MASK2, value, this.initialValue, overwrite);
+        return this;
+      }
+    }
+    const rest = limit & DATA_MASK2;
+    limit &= ~DATA_MASK2;
+    if (value === this.initialValue) {
+      repeatBlock = this.dataNullOffset;
+    } else {
+      repeatBlock = -1;
+    }
+    while (start < limit) {
+      let setRepeatBlock = false;
+      if (value === this.initialValue && this._isInNullBlock(start, true)) {
+        start += DATA_BLOCK_LENGTH2;
+        continue;
+      }
+      let i2 = this._getIndex2Block(start, true);
+      i2 += start >> SHIFT_22 & INDEX_2_MASK2;
+      block = this.index2[i2];
+      if (this._isWritableBlock(block)) {
+        if (overwrite && block >= DATA_0800_OFFSET) {
+          setRepeatBlock = true;
+        } else {
+          this._fillBlock(block, 0, DATA_BLOCK_LENGTH2, value, this.initialValue, overwrite);
+        }
+      } else if (this.data[block] !== value && (overwrite || block === this.dataNullOffset)) {
+        setRepeatBlock = true;
+      }
+      if (setRepeatBlock) {
+        if (repeatBlock >= 0) {
+          this._setIndex2Entry(i2, repeatBlock);
+        } else {
+          repeatBlock = this._getDataBlock(start, true);
+          this._writeBlock(repeatBlock, value);
+        }
+      }
+      start += DATA_BLOCK_LENGTH2;
+    }
+    if (rest > 0) {
+      block = this._getDataBlock(start, true);
+      this._fillBlock(block, 0, rest, value, this.initialValue, overwrite);
+    }
+    return this;
+  }
+  /**
+   * @param {number} c
+   * @param {boolean} [fromLSCP=true]
+   * @returns {number}
+   */
+  get(c, fromLSCP) {
+    let i2;
+    if (fromLSCP == null) {
+      fromLSCP = true;
+    }
+    if (c < 0 || c > 1114111) {
+      return this.errorValue;
+    }
+    if (c >= this.highStart && (!(c >= 55296 && c < 56320) || fromLSCP)) {
+      return this.data[this.dataLength - DATA_GRANULARITY2];
+    }
+    if (c >= 55296 && c < 56320 && fromLSCP) {
+      i2 = LSCP_INDEX_2_OFFSET2 - (55296 >> SHIFT_22) + (c >> SHIFT_22);
+    } else {
+      i2 = this.index1[c >> SHIFT_12] + (c >> SHIFT_22 & INDEX_2_MASK2);
+    }
+    const block = this.index2[i2];
+    return this.data[block + (c & DATA_MASK2)];
+  }
+  /**
+   * @param {number} c
+   * @param {boolean} forLSCP
+   * @returns {boolean}
+   */
+  _isInNullBlock(c, forLSCP) {
+    let i2;
+    if ((c & 4294966272) === 55296 && forLSCP) {
+      i2 = LSCP_INDEX_2_OFFSET2 - (55296 >> SHIFT_22) + (c >> SHIFT_22);
+    } else {
+      i2 = this.index1[c >> SHIFT_12] + (c >> SHIFT_22 & INDEX_2_MASK2);
+    }
+    const block = this.index2[i2];
+    return block === this.dataNullOffset;
+  }
+  /**
+   * @returns {number}
+   */
+  _allocIndex2Block() {
+    const newBlock = this.index2Length;
+    const newTop = newBlock + INDEX_2_BLOCK_LENGTH2;
+    if (newTop > this.index2.length) {
+      throw new Error("Internal error in Trie2 creation.");
+    }
+    this.index2Length = newTop;
+    this.index2.set(this.index2.subarray(this.index2NullOffset, this.index2NullOffset + INDEX_2_BLOCK_LENGTH2), newBlock);
+    return newBlock;
+  }
+  /**
+   * @param {number} c
+   * @param {boolean} forLSCP
+   * @returns {number}
+   */
+  _getIndex2Block(c, forLSCP) {
+    if (c >= 55296 && c < 56320 && forLSCP) {
+      return LSCP_INDEX_2_OFFSET2;
+    }
+    const i1 = c >> SHIFT_12;
+    let i2 = this.index1[i1];
+    if (i2 === this.index2NullOffset) {
+      i2 = this._allocIndex2Block();
+      this.index1[i1] = i2;
+    }
+    return i2;
+  }
+  /**
+   * @param {number} block
+   * @returns {boolean}
+   */
+  _isWritableBlock(block) {
+    return block !== this.dataNullOffset && this.map[block >> SHIFT_22] === 1;
+  }
+  /**
+   * @param {number} copyBlock
+   * @returns {number}
+   */
+  _allocDataBlock(copyBlock) {
+    let newBlock;
+    if (this.firstFreeBlock !== 0) {
+      newBlock = this.firstFreeBlock;
+      this.firstFreeBlock = -this.map[newBlock >> SHIFT_22];
+    } else {
+      newBlock = this.dataLength;
+      const newTop = newBlock + DATA_BLOCK_LENGTH2;
+      if (newTop > this.dataCapacity) {
+        let capacity;
+        if (this.dataCapacity < MEDIUM_DATA_LENGTH) {
+          capacity = MEDIUM_DATA_LENGTH;
+        } else if (this.dataCapacity < MAX_DATA_LENGTH_BUILDTIME) {
+          capacity = MAX_DATA_LENGTH_BUILDTIME;
+        } else {
+          throw new Error("Internal error in Trie2 creation.");
+        }
+        const newData = new Uint32Array(capacity);
+        newData.set(this.data.subarray(0, this.dataLength));
+        this.data = newData;
+        this.dataCapacity = capacity;
+      }
+      this.dataLength = newTop;
+    }
+    this.data.set(this.data.subarray(copyBlock, copyBlock + DATA_BLOCK_LENGTH2), newBlock);
+    this.map[newBlock >> SHIFT_22] = 0;
+    return newBlock;
+  }
+  /**
+   * @param {number} block
+   * @returns {void}
+   */
+  _releaseDataBlock(block) {
+    this.map[block >> SHIFT_22] = -this.firstFreeBlock;
+    this.firstFreeBlock = block;
+  }
+  /**
+   * @param {number} i2
+   * @param {number} block
+   * @returns {void}
+   */
+  _setIndex2Entry(i2, block) {
+    ++this.map[block >> SHIFT_22];
+    const oldBlock = this.index2[i2];
+    if (--this.map[oldBlock >> SHIFT_22] === 0) {
+      this._releaseDataBlock(oldBlock);
+    }
+    this.index2[i2] = block;
+  }
+  /**
+   * @param {number} c
+   * @param {boolean} forLSCP
+   * @returns {number}
+   */
+  _getDataBlock(c, forLSCP) {
+    let i2 = this._getIndex2Block(c, forLSCP);
+    i2 += c >> SHIFT_22 & INDEX_2_MASK2;
+    const oldBlock = this.index2[i2];
+    if (this._isWritableBlock(oldBlock)) {
+      return oldBlock;
+    }
+    const newBlock = this._allocDataBlock(oldBlock);
+    this._setIndex2Entry(i2, newBlock);
+    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) {
+      for (i = block + start; i < block + limit; i++) {
+        this.data[i] = value;
+      }
+    } else {
+      for (i = block + start; i < block + limit; i++) {
+        if (this.data[i] === initialValue) {
+          this.data[i] = value;
+        }
+      }
+    }
+  }
+  /**
+   * @param {number} block
+   * @param {number} value
+   * @returns {void}
+   */
+  _writeBlock(block, value) {
+    const limit = block + DATA_BLOCK_LENGTH2;
+    while (block < limit) {
+      this.data[block++] = value;
+    }
+  }
+  /**
+   * @param {number} highValue
+   * @returns {number}
+   */
+  _findHighStart(highValue) {
+    let prevBlock, prevI2Block;
+    const data32 = this.data;
+    const { initialValue } = this;
+    const { index2NullOffset } = this;
+    const nullBlock = this.dataNullOffset;
+    if (highValue === initialValue) {
+      prevI2Block = index2NullOffset;
+      prevBlock = nullBlock;
+    } else {
+      prevI2Block = -1;
+      prevBlock = -1;
+    }
+    const prev = 1114112;
+    let i1 = INDEX_1_LENGTH;
+    let c = prev;
+    while (c > 0) {
+      const i2Block = this.index1[--i1];
+      if (i2Block === prevI2Block) {
+        c -= CP_PER_INDEX_1_ENTRY;
+        continue;
+      }
+      prevI2Block = i2Block;
+      if (i2Block === index2NullOffset) {
+        if (highValue !== initialValue) {
+          return c;
+        }
+        c -= CP_PER_INDEX_1_ENTRY;
+      } else {
+        let i2 = INDEX_2_BLOCK_LENGTH2;
+        while (i2 > 0) {
+          const block = this.index2[i2Block + --i2];
+          if (block === prevBlock) {
+            c -= DATA_BLOCK_LENGTH2;
+            continue;
+          }
+          prevBlock = block;
+          if (block === nullBlock) {
+            if (highValue !== initialValue) {
+              return c;
+            }
+            c -= DATA_BLOCK_LENGTH2;
+          } else {
+            let j = DATA_BLOCK_LENGTH2;
+            while (j > 0) {
+              const value = data32[block + --j];
+              if (value !== highValue) {
+                return c;
+              }
+              --c;
+            }
+          }
+        }
+      }
+    }
+    return 0;
+  }
+  /**
+   * @param {number} dataLength
+   * @param {number} otherBlock
+   * @param {number} blockLength
+   * @returns {number}
+   */
+  _findSameDataBlock(dataLength, otherBlock, blockLength) {
+    dataLength -= blockLength;
+    let block = 0;
+    while (block <= dataLength) {
+      if (equal_int(this.data, block, otherBlock, blockLength)) {
+        return block;
+      }
+      block += DATA_GRANULARITY2;
+    }
+    return -1;
+  }
+  /**
+   * @param {number} index2Length
+   * @param {number} otherBlock
+   * @returns {number}
+   */
+  _findSameIndex2Block(index2Length, otherBlock) {
+    index2Length -= INDEX_2_BLOCK_LENGTH2;
+    for (let block = 0; block <= index2Length; block++) {
+      if (equal_int(this.index2, block, otherBlock, INDEX_2_BLOCK_LENGTH2)) {
+        return block;
+      }
+    }
+    return -1;
+  }
+  /**
+   * @returns {void}
+   */
+  _compactData() {
+    let newStart = DATA_START_OFFSET;
+    let start = 0;
+    let i = 0;
+    while (start < newStart) {
+      this.map[i++] = start;
+      start += DATA_BLOCK_LENGTH2;
+    }
+    let blockLength = 64;
+    let blockCount = blockLength >> SHIFT_22;
+    start = newStart;
+    while (start < this.dataLength) {
+      var mapIndex, movedStart;
+      if (start === DATA_0800_OFFSET) {
+        blockLength = DATA_BLOCK_LENGTH2;
+        blockCount = 1;
+      }
+      if (this.map[start >> SHIFT_22] <= 0) {
+        start += blockLength;
+        continue;
+      }
+      if ((movedStart = this._findSameDataBlock(newStart, start, blockLength)) >= 0) {
+        mapIndex = start >> SHIFT_22;
+        for (i = blockCount; i > 0; i--) {
+          this.map[mapIndex++] = movedStart;
+          movedStart += DATA_BLOCK_LENGTH2;
+        }
+        start += blockLength;
+        continue;
+      }
+      let overlap = blockLength - DATA_GRANULARITY2;
+      while (overlap > 0 && !equal_int(this.data, newStart - overlap, start, overlap)) {
+        overlap -= DATA_GRANULARITY2;
+      }
+      if (overlap > 0 || newStart < start) {
+        movedStart = newStart - overlap;
+        mapIndex = start >> SHIFT_22;
+        for (i = blockCount; i > 0; i--) {
+          this.map[mapIndex++] = movedStart;
+          movedStart += DATA_BLOCK_LENGTH2;
+        }
+        start += overlap;
+        for (i = blockLength - overlap; i > 0; i--) {
+          this.data[newStart++] = this.data[start++];
+        }
+      } else {
+        mapIndex = start >> SHIFT_22;
+        for (i = blockCount; i > 0; i--) {
+          this.map[mapIndex++] = start;
+          start += DATA_BLOCK_LENGTH2;
+        }
+        newStart = start;
+      }
+    }
+    i = 0;
+    while (i < this.index2Length) {
+      if (i === INDEX_GAP_OFFSET) {
+        i += INDEX_GAP_LENGTH;
+      }
+      this.index2[i] = this.map[this.index2[i] >> SHIFT_22];
+      ++i;
+    }
+    this.dataNullOffset = this.map[this.dataNullOffset >> SHIFT_22];
+    while ((newStart & DATA_GRANULARITY2 - 1) !== 0) {
+      this.data[newStart++] = this.initialValue;
+    }
+    this.dataLength = newStart;
+  }
+  /**
+   * @returns {void}
+   */
+  _compactIndex2() {
+    let newStart = INDEX_2_BMP_LENGTH2;
+    let start = 0;
+    let i = 0;
+    while (start < newStart) {
+      this.map[i++] = start;
+      start += INDEX_2_BLOCK_LENGTH2;
+    }
+    newStart += UTF8_2B_INDEX_2_LENGTH2 + (this.highStart - 65536 >> SHIFT_12);
+    start = INDEX_2_NULL_OFFSET;
+    while (start < this.index2Length) {
+      var movedStart;
+      if ((movedStart = this._findSameIndex2Block(newStart, start)) >= 0) {
+        this.map[start >> SHIFT_1_22] = movedStart;
+        start += INDEX_2_BLOCK_LENGTH2;
+        continue;
+      }
+      let overlap = INDEX_2_BLOCK_LENGTH2 - 1;
+      while (overlap > 0 && !equal_int(this.index2, newStart - overlap, start, overlap)) {
+        --overlap;
+      }
+      if (overlap > 0 || newStart < start) {
+        this.map[start >> SHIFT_1_22] = newStart - overlap;
+        start += overlap;
+        for (i = INDEX_2_BLOCK_LENGTH2 - overlap; i > 0; i--) {
+          this.index2[newStart++] = this.index2[start++];
+        }
+      } else {
+        this.map[start >> SHIFT_1_22] = start;
+        start += INDEX_2_BLOCK_LENGTH2;
+        newStart = start;
+      }
+    }
+    for (i = 0; i < INDEX_1_LENGTH; i++) {
+      this.index1[i] = this.map[this.index1[i] >> SHIFT_1_22];
+    }
+    this.index2NullOffset = this.map[this.index2NullOffset >> SHIFT_1_22];
+    while ((newStart & (DATA_GRANULARITY2 - 1 | 1)) !== 0) {
+      this.index2[newStart++] = 65535 << INDEX_SHIFT2;
+    }
+    this.index2Length = newStart;
+  }
+  /**
+   * @returns {void}
+   */
+  _compact() {
+    let highValue = this.get(1114111);
+    let highStart = this._findHighStart(highValue);
+    highStart = highStart + (CP_PER_INDEX_1_ENTRY - 1) & ~(CP_PER_INDEX_1_ENTRY - 1);
+    if (highStart === 1114112) {
+      highValue = this.errorValue;
+    }
+    this.highStart = highStart;
+    if (this.highStart < 1114112) {
+      const suppHighStart = this.highStart <= 65536 ? 65536 : this.highStart;
+      this.setRange(suppHighStart, 1114111, this.initialValue, true);
+    }
+    this._compactData();
+    if (this.highStart > 65536) {
+      this._compactIndex2();
+    }
+    this.data[this.dataLength++] = highValue;
+    while ((this.dataLength & DATA_GRANULARITY2 - 1) !== 0) {
+      this.data[this.dataLength++] = this.initialValue;
+    }
+    this.isCompacted = true;
+  }
+  /**
+   * @returns {import('./index.js').default}
+   */
+  freeze() {
+    let allIndexesLength, i;
+    if (!this.isCompacted) {
+      this._compact();
+    }
+    if (this.highStart <= 65536) {
+      allIndexesLength = INDEX_1_OFFSET2;
+    } else {
+      allIndexesLength = this.index2Length;
+    }
+    const dataMove = allIndexesLength;
+    if (allIndexesLength > MAX_INDEX_LENGTH || dataMove + this.dataNullOffset > 65535 || dataMove + DATA_0800_OFFSET > 65535 || dataMove + this.dataLength > MAX_DATA_LENGTH_RUNTIME) {
+      throw new Error("Trie data is too large.");
+    }
+    const indexLength = allIndexesLength + this.dataLength;
+    const data = new Int32Array(indexLength);
+    let destIdx = 0;
+    for (i = 0; i < INDEX_2_BMP_LENGTH2; i++) {
+      data[destIdx++] = this.index2[i] + dataMove >> INDEX_SHIFT2;
+    }
+    for (i = 0; i < 194 - 192; i++) {
+      data[destIdx++] = dataMove + BAD_UTF8_DATA_OFFSET;
+    }
+    for (; i < 224 - 192; i++) {
+      data[destIdx++] = dataMove + this.index2[i << 6 - SHIFT_22];
+    }
+    if (this.highStart > 65536) {
+      const index1Length = this.highStart - 65536 >> SHIFT_12;
+      const index2Offset = INDEX_2_BMP_LENGTH2 + UTF8_2B_INDEX_2_LENGTH2 + index1Length;
+      for (i = 0; i < index1Length; i++) {
+        data[destIdx++] = INDEX_2_OFFSET + this.index1[i + OMITTED_BMP_INDEX_1_LENGTH2];
+      }
+      for (i = 0; i < this.index2Length - index2Offset; i++) {
+        data[destIdx++] = dataMove + this.index2[index2Offset + i] >> INDEX_SHIFT2;
+      }
+    }
+    for (i = 0; i < this.dataLength; i++) {
+      data[destIdx++] = this.data[i];
+    }
+    const dest = new index_default({
+      data,
+      highStart: this.highStart,
+      errorValue: this.errorValue
+    });
+    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];
+   * @returns {Buffer}
+   */
+  toBuffer() {
+    const trie = this.freeze();
+    const data = new Uint8Array(trie.data.buffer);
+    swap32LE(data);
+    const compressed = (0, import_fflate2.deflateSync)(data);
+    const buf = Buffer.alloc(compressed.length + 12);
+    buf.writeUInt32LE(trie.highStart, 0);
+    buf.writeUInt32LE(trie.errorValue, 4);
+    buf.writeUInt32LE(data.length, 8);
+    for (let i = 0; i < compressed.length; i++) {
+      const b = compressed[i];
+      buf[i + 12] = b;
+    }
+    return buf;
+  }
+};
+var builder_default = UnicodeTrieBuilder;
+module.exports = module.exports.default ?? module.exports;
+//# sourceMappingURL=builder.cjs.map