entities 8.0.0 → 8.1.0

package/dist/internal/bin-trie-flags.d.ts

@@ -1,17 +1,48 @@
 /**
  * Bit flags & masks for the binary trie encoding used for entity decoding.
  *
- * Bit layout (16 bits total):
- * 15..14 VALUE_LENGTH   (+1 encoding; 0 => no value)
- * 13     FLAG13.        If valueLength>0: semicolon required flag (implicit ';').
- *                       If valueLength==0: compact run flag.
- * 12..7  BRANCH_LENGTH  Branch length (0 => single branch in 6..0 if jumpOffset==char) OR run length (when compact run)
- * 6..0   JUMP_TABLE     Jump offset (jump table) OR single-branch char code OR first run char
+ * The trie is a flat `Uint16Array`. Every node starts with one header word:
+ *
+ *   15..14 VALUE_LENGTH   Number of words the value occupies, +1.
+ *                         0 = no value; 1 = value inline in bits 12..0;
+ *                         2/3 = value in the 1/2 words after the header.
+ *   13     FLAG13         If VALUE_LENGTH > 0: semicolon required ("strict"
+ *                         entity; `;` is never stored as a branch).
+ *                         If VALUE_LENGTH == 0: this node is a compact run.
+ *   12..7  BRANCH_LENGTH  Number of branches (or run length for runs).
+ *   6..0   JUMP_TABLE     Jump-table offset / single-branch char / first
+ *                         run char (see below).
+ *
+ * Branch data follows the header and any value words. Its shape is selected
+ * by (JUMP_TABLE, BRANCH_LENGTH) in the header:
+ *
+ *   Single branch  JUMP_TABLE = the only child's char, BRANCH_LENGTH = 0.
+ *                  No branch words; the child node follows immediately.
+ *   Jump table     JUMP_TABLE = first covered char (> 0), BRANCH_LENGTH =
+ *                  table length. One word per covered char: 0 = no branch,
+ *                  otherwise the child's offset from the END of the table,
+ *                  +1 (so 0 stays the no-branch sentinel).
+ *   Dictionary     JUMP_TABLE = 0, BRANCH_LENGTH = number of branches.
+ *                  ceil(n/2) words of sorted keys packed two per word
+ *                  (low byte first), then n pointer words storing the
+ *                  child's offset from the END of the branch data.
+ *   Compact run    VALUE_LENGTH = 0, FLAG13 set. BRANCH_LENGTH = run
+ *                  length (3..63), JUMP_TABLE = first char; remaining run
+ *                  chars packed two per word after the header. The target
+ *                  node follows the packed words immediately.
+ *
+ * Pointers are end-relative (rather than relative to the pointer's own
+ * position) because that makes the common "child encoded right after the
+ * branch data" case a small constant, which compresses far better. Offsets
+ * to already-encoded (shared) nodes wrap via uint16 modulo arithmetic; the
+ * decoder masks navigation results with `& 0xff_ff` to match.
  */
-export declare enum BinTrieFlags {
+export declare const enum BinTrieFlags {
     VALUE_LENGTH = 49152,
     FLAG13 = 8192,
     BRANCH_LENGTH = 8064,
-    JUMP_TABLE = 127
+    JUMP_TABLE = 127,
+    /** Bits 12..0: the inline value of a VALUE_LENGTH = 1 header word. */
+    VALUE_MASK = 8191
 }
 //# sourceMappingURL=bin-trie-flags.d.ts.map

package/dist/internal/bin-trie-flags.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bin-trie-flags.d.ts","sourceRoot":"","sources":["../../src/internal/bin-trie-flags.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,oBAAY,YAAY;IACpB,YAAY,QAAwB;IACpC,MAAM,OAAwB;IAC9B,aAAa,OAAwB;IACrC,UAAU,MAAwB;CACrC"}
+{"version":3,"file":"bin-trie-flags.d.ts","sourceRoot":"","sources":["../../src/internal/bin-trie-flags.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,0BAAkB,YAAY;IAC1B,YAAY,QAAwB;IACpC,MAAM,OAAwB;IAC9B,aAAa,OAAwB;IACrC,UAAU,MAAwB;IAClC,sEAAsE;IACtE,UAAU,OAAwB;CACrC"}

package/dist/internal/bin-trie-flags.js

@@ -1,12 +1,41 @@
 /**
  * Bit flags & masks for the binary trie encoding used for entity decoding.
  *
- * Bit layout (16 bits total):
- * 15..14 VALUE_LENGTH   (+1 encoding; 0 => no value)
- * 13     FLAG13.        If valueLength>0: semicolon required flag (implicit ';').
- *                       If valueLength==0: compact run flag.
- * 12..7  BRANCH_LENGTH  Branch length (0 => single branch in 6..0 if jumpOffset==char) OR run length (when compact run)
- * 6..0   JUMP_TABLE     Jump offset (jump table) OR single-branch char code OR first run char
+ * The trie is a flat `Uint16Array`. Every node starts with one header word:
+ *
+ *   15..14 VALUE_LENGTH   Number of words the value occupies, +1.
+ *                         0 = no value; 1 = value inline in bits 12..0;
+ *                         2/3 = value in the 1/2 words after the header.
+ *   13     FLAG13         If VALUE_LENGTH > 0: semicolon required ("strict"
+ *                         entity; `;` is never stored as a branch).
+ *                         If VALUE_LENGTH == 0: this node is a compact run.
+ *   12..7  BRANCH_LENGTH  Number of branches (or run length for runs).
+ *   6..0   JUMP_TABLE     Jump-table offset / single-branch char / first
+ *                         run char (see below).
+ *
+ * Branch data follows the header and any value words. Its shape is selected
+ * by (JUMP_TABLE, BRANCH_LENGTH) in the header:
+ *
+ *   Single branch  JUMP_TABLE = the only child's char, BRANCH_LENGTH = 0.
+ *                  No branch words; the child node follows immediately.
+ *   Jump table     JUMP_TABLE = first covered char (> 0), BRANCH_LENGTH =
+ *                  table length. One word per covered char: 0 = no branch,
+ *                  otherwise the child's offset from the END of the table,
+ *                  +1 (so 0 stays the no-branch sentinel).
+ *   Dictionary     JUMP_TABLE = 0, BRANCH_LENGTH = number of branches.
+ *                  ceil(n/2) words of sorted keys packed two per word
+ *                  (low byte first), then n pointer words storing the
+ *                  child's offset from the END of the branch data.
+ *   Compact run    VALUE_LENGTH = 0, FLAG13 set. BRANCH_LENGTH = run
+ *                  length (3..63), JUMP_TABLE = first char; remaining run
+ *                  chars packed two per word after the header. The target
+ *                  node follows the packed words immediately.
+ *
+ * Pointers are end-relative (rather than relative to the pointer's own
+ * position) because that makes the common "child encoded right after the
+ * branch data" case a small constant, which compresses far better. Offsets
+ * to already-encoded (shared) nodes wrap via uint16 modulo arithmetic; the
+ * decoder masks navigation results with `& 0xff_ff` to match.
  */
 export var BinTrieFlags;
 (function (BinTrieFlags) {
@@ -14,5 +43,7 @@ export var BinTrieFlags;
     BinTrieFlags[BinTrieFlags["FLAG13"] = 8192] = "FLAG13";
     BinTrieFlags[BinTrieFlags["BRANCH_LENGTH"] = 8064] = "BRANCH_LENGTH";
     BinTrieFlags[BinTrieFlags["JUMP_TABLE"] = 127] = "JUMP_TABLE";
+    /** Bits 12..0: the inline value of a VALUE_LENGTH = 1 header word. */
+    BinTrieFlags[BinTrieFlags["VALUE_MASK"] = 8191] = "VALUE_MASK";
 })(BinTrieFlags || (BinTrieFlags = {}));
 //# sourceMappingURL=bin-trie-flags.js.map

package/dist/internal/bin-trie-flags.js.map

@@ -1 +1 @@
-{"version":3,"file":"bin-trie-flags.js","sourceRoot":"","sources":["../../src/internal/bin-trie-flags.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,CAAN,IAAY,YAKX;AALD,WAAY,YAAY;IACpB,mEAAoC,CAAA;IACpC,sDAA8B,CAAA;IAC9B,oEAAqC,CAAA;IACrC,6DAAkC,CAAA;AACtC,CAAC,EALW,YAAY,KAAZ,YAAY,QAKvB"}
+{"version":3,"file":"bin-trie-flags.js","sourceRoot":"","sources":["../../src/internal/bin-trie-flags.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,MAAM,CAAN,IAAkB,YAOjB;AAPD,WAAkB,YAAY;IAC1B,mEAAoC,CAAA;IACpC,sDAA8B,CAAA;IAC9B,oEAAqC,CAAA;IACrC,6DAAkC,CAAA;IAClC,sEAAsE;IACtE,8DAAkC,CAAA;AACtC,CAAC,EAPiB,YAAY,KAAZ,YAAY,QAO7B"}

package/dist/internal/decode-shared.d.ts

@@ -1,7 +1,38 @@
 /**
- * Shared base64 decode helper for generated decode data.
- * Assumes global atob is available.
- * @param input Input string to encode or decode.
+ * Decode a dictionary-encoded trie string back into its Uint16Array.
+ *
+ * Stream layout (consumed in this order):
+ *   1. dict1 atoms — `dict1AtomCount` uint16 values, delta+RLE encoded.
+ *   2. dict2 atoms — `atomCount - dict1AtomCount` values, delta+RLE.
+ *   3. dict2 ngrams — `ngramCount - (dictSize - dict1AtomCount)` entries,
+ *      each a pair of slot codes that resolve to earlier slots.
+ *   4. dict1 ngrams — `dictSize - dict1AtomCount` entries, same shape.
+ *   5. data — slot codes, each expanding to one or more uint16 values.
+ *
+ * Codes use a 91-char base (printable ASCII minus `"`, `$`, `\`):
+ *   - char1 < dictSize  → 1-char code, slot = char1
+ *   - char1 ≥ dictSize  → 2-char code, slot = dictSize + (char1 - dictSize)*91 + char2
+ *
+ * Slot index → token kind:
+ *   [0, A)                  dict1 atoms     (1-char codes)
+ *   [A, dictSize)           dict1 ngrams    (1-char codes)
+ *   [dictSize, dictSize+D)  dict2 atoms     (2-char codes)
+ *   [dictSize+D, end)       dict2 ngrams    (2-char codes)
+ *
+ * Both atom dicts decode before any ngram, and dict2 ngrams decode before
+ * dict1 ngrams. So every ngram entry references slots whose contents are
+ * already filled — no forward references to handle.
+ *
+ * This runs on library import. Flat typed arrays store each slot as either
+ * a plain value (`single`, covering every atom) or a range in a shared
+ * `pool` (ngrams).
+ * @param input Packed trie string.
+ * @param resultLength Expected number of uint16 values in the output.
+ * @param atomCount Total number of distinct uint16 values in the trie.
+ * @param dict1AtomCount Atoms in the 1-char range (`A` above).
+ * @param ngramCount Total number of ngram entries (dict1 + dict2).
+ * @param dictSize Number of 1-char code slots; the rest of `BASE - dictSize`
+ *   first-byte values are 2-char codes.
  */
-export declare function decodeBase64(input: string): Uint16Array;
+export declare function decodeTrieDict(input: string, resultLength: number, atomCount: number, dict1AtomCount: number, ngramCount: number, dictSize: number): Uint16Array;
 //# sourceMappingURL=decode-shared.d.ts.map

package/dist/internal/decode-shared.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"decode-shared.d.ts","sourceRoot":"","sources":["../../src/internal/decode-shared.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,CAYvD"}
+{"version":3,"file":"decode-shared.d.ts","sourceRoot":"","sources":["../../src/internal/decode-shared.ts"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,cAAc,CAC1B,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,MAAM,EACpB,SAAS,EAAE,MAAM,EACjB,cAAc,EAAE,MAAM,EACtB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,GACjB,WAAW,CAqJb"}

package/dist/internal/decode-shared.js

@@ -1,16 +1,194 @@
+/*
+ * Inverse of the encoder's SAFE alphabet (0x21..0x7E minus 0x22, 0x24, 0x5C),
+ * precomputed once at module load. Entries for excluded chars stay 0 but
+ * are never read.
+ */
+const BASE91_INVERSE = /* #__PURE__ */ (() => {
+    const table = new Uint8Array(127);
+    let code = 0;
+    for (let char = 0x21; char <= 0x7e; char++) {
+        if (char !== 0x22 && char !== 0x24 && char !== 0x5c) {
+            table[char] = code++;
+        }
+    }
+    return table;
+})();
 /**
- * Shared base64 decode helper for generated decode data.
- * Assumes global atob is available.
- * @param input Input string to encode or decode.
+ * Decode a dictionary-encoded trie string back into its Uint16Array.
+ *
+ * Stream layout (consumed in this order):
+ *   1. dict1 atoms — `dict1AtomCount` uint16 values, delta+RLE encoded.
+ *   2. dict2 atoms — `atomCount - dict1AtomCount` values, delta+RLE.
+ *   3. dict2 ngrams — `ngramCount - (dictSize - dict1AtomCount)` entries,
+ *      each a pair of slot codes that resolve to earlier slots.
+ *   4. dict1 ngrams — `dictSize - dict1AtomCount` entries, same shape.
+ *   5. data — slot codes, each expanding to one or more uint16 values.
+ *
+ * Codes use a 91-char base (printable ASCII minus `"`, `$`, `\`):
+ *   - char1 < dictSize  → 1-char code, slot = char1
+ *   - char1 ≥ dictSize  → 2-char code, slot = dictSize + (char1 - dictSize)*91 + char2
+ *
+ * Slot index → token kind:
+ *   [0, A)                  dict1 atoms     (1-char codes)
+ *   [A, dictSize)           dict1 ngrams    (1-char codes)
+ *   [dictSize, dictSize+D)  dict2 atoms     (2-char codes)
+ *   [dictSize+D, end)       dict2 ngrams    (2-char codes)
+ *
+ * Both atom dicts decode before any ngram, and dict2 ngrams decode before
+ * dict1 ngrams. So every ngram entry references slots whose contents are
+ * already filled — no forward references to handle.
+ *
+ * This runs on library import. Flat typed arrays store each slot as either
+ * a plain value (`single`, covering every atom) or a range in a shared
+ * `pool` (ngrams).
+ * @param input Packed trie string.
+ * @param resultLength Expected number of uint16 values in the output.
+ * @param atomCount Total number of distinct uint16 values in the trie.
+ * @param dict1AtomCount Atoms in the 1-char range (`A` above).
+ * @param ngramCount Total number of ngram entries (dict1 + dict2).
+ * @param dictSize Number of 1-char code slots; the rest of `BASE - dictSize`
+ *   first-byte values are 2-char codes.
  */
-export function decodeBase64(input) {
-    const binary = atob(input);
-    const evenLength = binary.length & ~1; // Round down to even length
-    const out = new Uint16Array(evenLength / 2);
-    for (let index = 0, outIndex = 0; index < evenLength; index += 2) {
-        const lo = binary.charCodeAt(index);
-        const hi = binary.charCodeAt(index + 1);
-        out[outIndex++] = lo | (hi << 8);
+export function decodeTrieDict(input, resultLength, atomCount, dict1AtomCount, ngramCount, dictSize) {
+    const base = 91;
+    const inputLength = input.length;
+    // For 2-char codes, slot = char1 * base - twoCharBias + char2.
+    const twoCharBias = dictSize * (base - 1);
+    let pos = 0;
+    /** Read one slot code at `pos` and return its slot index, advancing pos. */
+    const readSlotCode = () => {
+        const c1 = BASE91_INVERSE[input.charCodeAt(pos++)];
+        return c1 < dictSize
+            ? c1
+            : c1 * base - twoCharBias + BASE91_INVERSE[input.charCodeAt(pos++)];
+    };
+    const dict2AtomCount = atomCount - dict1AtomCount;
+    const slotCount = atomCount + ngramCount;
+    /*
+     * Per-slot contents: atoms (always a single value) live directly in
+     * `single`; ngram slots hold -1 there and expand to
+     * `pool[start[slot] .. start[slot] + length[slot])`.
+     */
+    const single = new Int32Array(slotCount);
+    single.fill(-1, dict1AtomCount, dictSize);
+    single.fill(-1, dictSize + dict2AtomCount, slotCount);
+    const start = new Int32Array(slotCount);
+    const length = new Int32Array(slotCount);
+    /**
+     * Decode `count` ascending uint16 values from a delta+RLE stream into
+     * `single[off..off+count)`.
+     *
+     *   code < 89   → delta = code
+     *   code == 89  → run-length: next char encodes runLength-2; emit `runLength` consecutive +1 values
+     *   code == 90, next < 90  → escape: delta = 89 + next * BASE + after-next
+     *   code == 90, next == 90 → double-escape: extra char for very large deltas
+     * @param count
+     * @param off
+     */
+    function decodeDelta(count, off) {
+        let previous = 0;
+        let slot = off;
+        const end = off + count;
+        while (slot < end) {
+            const code = BASE91_INVERSE[input.charCodeAt(pos++)];
+            if (code < 89) {
+                previous += code;
+                single[slot++] = previous;
+            }
+            else if (code === 89) {
+                let runLength = BASE91_INVERSE[input.charCodeAt(pos++)] + 2;
+                while (runLength--)
+                    single[slot++] = ++previous;
+            }
+            else {
+                const next = BASE91_INVERSE[input.charCodeAt(pos++)];
+                previous +=
+                    89 +
+                        // eslint-disable-next-line unicorn/prefer-minimal-ternary -- branches read a different number of side-effecting input bytes
+                        (next < 90
+                            ? next * base + BASE91_INVERSE[input.charCodeAt(pos++)]
+                            : BASE91_INVERSE[input.charCodeAt(pos++)] * 8281 +
+                                BASE91_INVERSE[input.charCodeAt(pos++)] * base +
+                                BASE91_INVERSE[input.charCodeAt(pos++)]);
+                single[slot++] = previous;
+            }
+        }
+    }
+    // Streams 1 & 2: atoms decoded into their slot ranges.
+    decodeDelta(dict1AtomCount, 0);
+    decodeDelta(dict2AtomCount, dictSize);
+    /*
+     * Streams 3 & 4 are read in two passes: first collect every ngram's two
+     * references and derive its expanded length (each ref resolves to an earlier
+     * slot, so lengths are already known), which sizes the shared pool.
+     * Pool ranges are handed out in decode order, so the second pass fills
+     * the pool contiguously with a single write cursor.
+     */
+    const references = new Int32Array(ngramCount * 2);
+    let poolSize = 0;
+    let ngramIndex = 0;
+    /**
+     * Read `count` ngram entries (each = 2 slot-code references) for the slots
+     * starting at `startSlot`, recording references and assigning pool ranges.
+     * @param count
+     * @param startSlot
+     */
+    function readNgramReferences(count, startSlot) {
+        for (let index = 0; index < count; index++) {
+            const slot = startSlot + index;
+            const a = readSlotCode();
+            const b = readSlotCode();
+            references[ngramIndex * 2] = a;
+            references[ngramIndex * 2 + 1] = b;
+            ngramIndex += 1;
+            start[slot] = poolSize;
+            const entryLength = (single[a] < 0 ? length[a] : 1) +
+                (single[b] < 0 ? length[b] : 1);
+            length[slot] = entryLength;
+            poolSize += entryLength;
+        }
+    }
+    readNgramReferences(ngramCount - dictSize + dict1AtomCount, dictSize + dict2AtomCount);
+    readNgramReferences(dictSize - dict1AtomCount, dict1AtomCount);
+    // Second pass: concatenate each ngram's two halves into the pool.
+    const pool = new Uint16Array(poolSize);
+    let write = 0;
+    for (let index = 0; index < ngramIndex; index++) {
+        for (let half = 0; half < 2; half++) {
+            const source = references[index * 2 + half];
+            const value = single[source];
+            if (value < 0) {
+                let read = start[source];
+                const readEnd = read + length[source];
+                while (read < readEnd)
+                    pool[write++] = pool[read++];
+            }
+            else {
+                pool[write++] = value;
+            }
+        }
+    }
+    // Stream 5: data. Each code expands to its slot's stored values.
+    const out = new Uint16Array(resultLength);
+    let outIndex = 0;
+    while (pos < inputLength) {
+        let slot = BASE91_INVERSE[input.charCodeAt(pos++)];
+        if (slot >= dictSize) {
+            slot =
+                slot * base -
+                    twoCharBias +
+                    BASE91_INVERSE[input.charCodeAt(pos++)];
+        }
+        const value = single[slot];
+        if (value < 0) {
+            let read = start[slot];
+            const readEnd = read + length[slot];
+            while (read < readEnd)
+                out[outIndex++] = pool[read++];
+        }
+        else {
+            out[outIndex++] = value;
+        }
     }
     return out;
 }

package/dist/internal/decode-shared.js.map

@@ -1 +1 @@
-{"version":3,"file":"decode-shared.js","sourceRoot":"","sources":["../../src/internal/decode-shared.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,UAAU,YAAY,CAAC,KAAa;IACtC,MAAM,MAAM,GAAW,IAAI,CAAC,KAAK,CAAC,CAAC;IACnC,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,4BAA4B;IACnE,MAAM,GAAG,GAAG,IAAI,WAAW,CAAC,UAAU,GAAG,CAAC,CAAC,CAAC;IAE5C,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,QAAQ,GAAG,CAAC,EAAE,KAAK,GAAG,UAAU,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC;QAC/D,MAAM,EAAE,GAAG,MAAM,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QACpC,MAAM,EAAE,GAAG,MAAM,CAAC,UAAU,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC;QACxC,GAAG,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC;IACrC,CAAC;IAED,OAAO,GAAG,CAAC;AACf,CAAC"}
+{"version":3,"file":"decode-shared.js","sourceRoot":"","sources":["../../src/internal/decode-shared.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "entities",
-    "version": "8.0.0",
+    "version": "8.1.0",
     "description": "Encode & decode XML and HTML entities with ease & speed",
     "keywords": [
         "html entities",
@@ -53,29 +53,29 @@
         "lint": "npm run lint:es && npm run lint:ts && npm run lint:biome",
         "lint:biome": "biome check .",
         "lint:es": "eslint .",
-        "lint:ts": "tsc --noEmit",
+        "lint:ts": "tsc --noEmit -p tsconfig.eslint.json",
         "prepublishOnly": "npm run build",
         "test": "npm run test:vi && npm run lint",
         "test:vi": "vitest run"
     },
     "devDependencies": {
-        "@biomejs/biome": "^2.4.7",
-        "@eslint/compat": "^2.0.3",
-        "@feedic/eslint-config": "^0.3.1",
+        "@biomejs/biome": "^2.5.12",
+        "@eslint/compat": "^2.1.1",
+        "@feedic/eslint-config": "^0.5.0",
         "@types/he": "^1.2.3",
-        "@types/node": "^25.5.0",
-        "eslint": "^10.0.3",
+        "@types/node": "^26.4.1",
+        "eslint": "^10.10.0",
         "eslint-config-biome": "^2.1.3",
-        "globals": "^17.4.0",
+        "globals": "^17.12.0",
         "he": "^1.2.0",
         "html-entities": "^2.6.0",
         "parse-entities": "^4.0.2",
-        "tinybench": "^6.0.0",
-        "tsx": "^4.21.0",
-        "typedoc": "^0.28.17",
-        "typescript": "^5.9.3",
-        "typescript-eslint": "^8.57.1",
-        "vitest": "^4.0.17"
+        "tinybench": "^6.1.5",
+        "tsx": "^4.23.13",
+        "typedoc": "^0.28.20",
+        "typescript": "^6.0.3",
+        "typescript-eslint": "^8.69.0",
+        "vitest": "^5.0.0"
     },
     "engines": {
         "node": ">=20.19.0"

package/src/decode-codepoint.ts

@@ -1,50 +1,69 @@
 // Adapted from https://github.com/mathiasbynens/he/blob/36afe179392226cf1b6ccdb16ebbb7a5a844d93a/src/he.js#L106-L134
 
-const decodeMap = new Map([
-    [0, 65_533],
-    // C1 Unicode control character reference replacements
-    [128, 8364],
-    [130, 8218],
-    [131, 402],
-    [132, 8222],
-    [133, 8230],
-    [134, 8224],
-    [135, 8225],
-    [136, 710],
-    [137, 8240],
-    [138, 352],
-    [139, 8249],
-    [140, 338],
-    [142, 381],
-    [145, 8216],
-    [146, 8217],
-    [147, 8220],
-    [148, 8221],
-    [149, 8226],
-    [150, 8211],
-    [151, 8212],
-    [152, 732],
-    [153, 8482],
-    [154, 353],
-    [155, 8250],
-    [156, 339],
-    [158, 382],
-    [159, 376],
-]);
+/**
+ * C1 Unicode control character reference replacements (code points 128–159).
+ * Index i gives the replacement for code point 128+i; 0 means "no replacement".
+ */
+const c1: number[] = [
+    8364, 0, 8218, 402, 8222, 8230, 8224, 8225, 710, 8240, 352, 8249, 338, 0,
+    381, 0, 0, 8216, 8217, 8220, 8221, 8226, 8211, 8212, 732, 8482, 353, 8250,
+    339, 0, 382, 376,
+];
 
 /**
- * Replace the given code point with a replacement character if it is a
- * surrogate or is outside the valid range. Otherwise return the code
- * point unchanged.
- * @param codePoint Unicode code point to convert.
+ * True for NUL, UTF-16 surrogates, and values past U+10FFFF.
+ * @param codePoint Unicode code point to check.
  */
-export function replaceCodePoint(codePoint: number): number {
-    if (
+function isInvalidCodePoint(codePoint: number): boolean {
+    return (
+        codePoint === 0 ||
         (codePoint >= 0xd8_00 && codePoint <= 0xdf_ff) ||
         codePoint > 0x10_ff_ff
-    ) {
+    );
+}
+
+/**
+ * Replace the given code point with U+FFFD if it is NUL (0), a surrogate, or
+ * outside the valid Unicode range. Code points in the C1 controls range
+ * (128–159) are remapped to their Windows-1252 equivalents, following the
+ * HTML spec. All other code points are returned unchanged.
+ * @param codePoint Unicode code point to convert.
+ */
+export function replaceCodePoint(codePoint: number): number {
+    if (isInvalidCodePoint(codePoint)) {
         return 0xff_fd;
     }
 
-    return decodeMap.get(codePoint) ?? codePoint;
+    if (codePoint >= 128 && codePoint <= 159) {
+        return c1[codePoint - 128] || codePoint;
+    }
+
+    return codePoint;
+}
+
+/**
+ * XML numeric character references are the referenced Unicode code point.
+ * Invalid values still become U+FFFD; the HTML Windows-1252 C1 remap is not
+ * applied.
+ * @see https://www.w3.org/TR/xml/#NT-CharRef
+ * @param codePoint Unicode code point to convert.
+ */
+export function replaceCodePointXML(codePoint: number): number {
+    return isInvalidCodePoint(codePoint) ? 0xff_fd : codePoint;
+}
+
+/**
+ * Convert the code point of a decoded numeric entity to a string, replacing
+ * invalid values.
+ *
+ * Fast path for plain BMP code points: [1..0x7F] and [0xA0..0xD7FF] pass
+ * `replaceCodePoint` unchanged (no NUL, C1 remap, surrogate, or out-of-range
+ * handling) and fit a single charCode. 0xd760 = 0xD800 (the first surrogate)
+ * - 0xA0.
+ * @param codePoint Unicode code point to convert.
+ */
+export function codePointToString(codePoint: number): string {
+    return (codePoint - 1) >>> 0 < 0x7f || (codePoint - 0xa0) >>> 0 < 0xd7_60
+        ? String.fromCharCode(codePoint)
+        : String.fromCodePoint(replaceCodePoint(codePoint));
 }