speedy-entities 3.1.0 → 4.0.0

package/createEntityTrie.js

@@ -0,0 +1,69 @@
+import { createDoubleArrayEntityTrie } from "./createDoubleArrayEntityTrie.js";
+/**
+ * An optional "&", a name of ASCII letters, digits and "-.:_", and an optional ";".
+ */
+const entityRegExp = /^&?[a-zA-Z0-9.:_-]+;?$/;
+/**
+ * Builds a trie of entity names. Pass it to {@linkcode createEntityTrieDecoder} to create decoders that share it,
+ * since building a trie takes time and memory.
+ *
+ * @param entities Entity references mapped to their values, or a list of references and values in turn, see
+ * {@linkcode EntityDecoderOptions.entities}.
+ */
+export function createEntityTrie(entities) {
+    if (Array.isArray(entities)) {
+        if (entities.length % 2 !== 0) {
+            throw new Error('entities must list references and values in turn');
+        }
+        return createEntityTrieFromArray(entities);
+    }
+    const uncheckedEntities = [];
+    for (const entity of Object.keys(entities)) {
+        uncheckedEntities.push(entity, entities[entity]);
+    }
+    return createEntityTrieFromArray(uncheckedEntities);
+}
+/**
+ * Builds a trie from references and values in turn. Lists are usually sorted and have no "&", so a list is copied only
+ * if a name has "&" or names aren't sorted.
+ */
+function createEntityTrieFromArray(uncheckedEntities) {
+    let checkedEntities = uncheckedEntities;
+    let isSorted = true;
+    let previousEntity = '';
+    for (let index = 0; index < uncheckedEntities.length; index += 2) {
+        let entity = uncheckedEntities[index];
+        if (typeof entity !== 'string' || !entityRegExp.test(entity)) {
+            throw new Error('Invalid entity reference: ' + JSON.stringify(entity));
+        }
+        if (typeof uncheckedEntities[index + 1] !== 'string') {
+            throw new Error('Value of entity reference must be a string: ' + JSON.stringify(entity));
+        }
+        if (entity.charCodeAt(0) === /* & */ 38) {
+            entity = entity.slice(1);
+            if (checkedEntities === uncheckedEntities) {
+                checkedEntities = uncheckedEntities.slice(0);
+            }
+            checkedEntities[index] = entity;
+        }
+        // Stripping "&" can change the order, so entities are compared without it
+        if (entity < previousEntity) {
+            isSorted = false;
+        }
+        previousEntity = entity;
+    }
+    return createDoubleArrayEntityTrie(isSorted ? checkedEntities : sortByEntityReference(checkedEntities));
+}
+// Sort is stable, so "&lt;" and "lt;" keep their order, and the value of the latter is used
+function sortByEntityReference(entities) {
+    const indexes = new Uint32Array(entities.length / 2);
+    for (let index = 0; index < indexes.length; ++index) {
+        indexes[index] = index * 2;
+    }
+    indexes.sort((a, b) => (entities[a] < entities[b] ? -1 : entities[a] > entities[b] ? 1 : 0));
+    const sortedEntities = [];
+    for (const index of indexes) {
+        sortedEntities.push(entities[index], entities[index + 1]);
+    }
+    return sortedEntities;
+}

package/createEntityTrieDecoder.d.ts

@@ -0,0 +1,33 @@
+import { type EntityTrie } from './createDoubleArrayEntityTrie.ts';
+/**
+ * Options of {@linkcode createEntityTrieDecoder}.
+ */
+export interface EntityTrieDecoderOptions {
+    /**
+     * If `true`, numeric references are decoded only if they end with ";", as XML requires.
+     *
+     * @default false
+     */
+    isNumericReferenceSemicolonRequired?: boolean;
+    /**
+     * If `true`, numeric references to C1 controls (U+0080 to U+009F) are decoded as Windows-1252 chars,
+     * [as HTML does](https://html.spec.whatwg.org/multipage/parsing.html#numeric-character-reference-end-state). For
+     * example, "€" is decoded as the euro sign instead of U+0080.
+     *
+     * @default true
+     */
+    areC1ControlsRemapped?: boolean;
+    /**
+     * If `true`, a named reference without ";" isn't decoded if "=" or an ASCII letter or digit follows it,
+     * [as HTML does in attribute values](https://html.spec.whatwg.org/multipage/parsing.html#named-character-reference-state).
+     * This keeps URL query strings like "?a=1&copy=2" intact.
+     *
+     * @default false
+     */
+    isAttributeValue?: boolean;
+}
+/**
+ * Creates a decoder that uses a trie from {@linkcode createEntityTrie}, so decoders that differ only in options can
+ * share a trie.
+ */
+export declare function createEntityTrieDecoder(entityTrie: EntityTrie, options?: EntityTrieDecoderOptions): (input: string) => string;

package/createEntityTrieDecoder.js

@@ -0,0 +1,159 @@
+import {} from "./createDoubleArrayEntityTrie.js";
+/**
+ * Creates a decoder that uses a trie from {@linkcode createEntityTrie}, so decoders that differ only in options can
+ * share a trie.
+ */
+export function createEntityTrieDecoder(entityTrie, options = {}) {
+    const { isNumericReferenceSemicolonRequired = false, areC1ControlsRemapped = true, isAttributeValue = false, } = options;
+    const { nodeBases, nodeChecks, nodeValueIndexes, values } = entityTrie;
+    return input => {
+        let output = '';
+        let textIndex = 0;
+        const inputLength = input.length;
+        // A reference is "&" followed by at least one char, so it can't start at the last char
+        let charIndex = inputLength > 1 ? input.indexOf('&') : -1;
+        while (charIndex !== -1 && charIndex < inputLength - 1) {
+            let startIndex = charIndex + 1;
+            let value;
+            let endIndex = startIndex;
+            // Both reads below must stay in bounds: reading past the end of the input makes V8 deoptimize this function,
+            // and it stays about twice as slow on short inputs afterwards
+            if (startIndex < inputLength - 1 && input.charCodeAt(startIndex) === /* # */ 35) {
+                // Numeric character reference
+                // All digits are consumed, out-of-range code points (Infinity included) are replaced with U+FFFD below
+                let codePoint = 0;
+                if ((input.charCodeAt(++startIndex) | 32) === /* x */ 120) {
+                    endIndex = ++startIndex;
+                    // parseInt of a hexadecimal number
+                    while (endIndex < inputLength) {
+                        const charCode = input.charCodeAt(endIndex);
+                        // Convert alpha to lower case
+                        const lowerCharCode = charCode | 32;
+                        if (charCode >= /* 0 */ 48 && charCode <= /* 9 */ 57) {
+                            codePoint = codePoint * 16 + charCode - 48;
+                        }
+                        else if (lowerCharCode >= /* a */ 97 && lowerCharCode <= /* f */ 102) {
+                            codePoint = codePoint * 16 + lowerCharCode - 87;
+                        }
+                        else {
+                            break;
+                        }
+                        ++endIndex;
+                    }
+                }
+                else {
+                    endIndex = startIndex;
+                    // parseInt of a decimal number
+                    while (endIndex < inputLength) {
+                        const charCode = input.charCodeAt(endIndex);
+                        if (charCode >= /* 0 */ 48 && charCode <= /* 9 */ 57) {
+                            codePoint = codePoint * 10 + charCode - 48;
+                        }
+                        else {
+                            break;
+                        }
+                        ++endIndex;
+                    }
+                }
+                if (endIndex !== startIndex) {
+                    // At least one digit must be present
+                    const isTerminated = endIndex < inputLength && input.charCodeAt(endIndex) === /* ; */ 59;
+                    if (isTerminated || !isNumericReferenceSemicolonRequired) {
+                        // Convert a code point to a string
+                        if (codePoint === 0 || (codePoint >= 0xd800 && codePoint <= 0xdfff) || codePoint > 0x10ffff) {
+                            // Null char code, or character reference is outside the permissible Unicode range
+                            value = '\uFFFD';
+                        }
+                        else if (areC1ControlsRemapped && codePoint >= 0x80 && codePoint <= 0x9f) {
+                            value = c1ControlValues[codePoint - 0x80];
+                        }
+                        else {
+                            value = String.fromCodePoint(codePoint);
+                        }
+                    }
+                    if (isTerminated) {
+                        ++endIndex;
+                    }
+                }
+            }
+            else {
+                // Character entity reference
+                let index = startIndex;
+                let node = 0;
+                // The node where the longest entity name read so far ends, or 0. Its value is read once, after the loop, since
+                // reading the value at each node where a name ends makes decoding a few percent slower.
+                let valueNode = 0;
+                while (index < inputLength) {
+                    const charCode = input.charCodeAt(index);
+                    // Only ASCII chars have nodes, and bases keep base + charCode in bounds for them
+                    if (charCode > 127) {
+                        break;
+                    }
+                    const childNode = nodeBases[node] + charCode;
+                    const childCheck = nodeChecks[childNode];
+                    if (childCheck >> 1 !== node) {
+                        // No entity name starts with chars read so far
+                        break;
+                    }
+                    node = childNode;
+                    ++index;
+                    if ((childCheck & 1) === 1) {
+                        // An entity name ends at the node
+                        valueNode = node;
+                        endIndex = index;
+                    }
+                }
+                if (valueNode !== 0) {
+                    value = values[nodeValueIndexes[valueNode]];
+                }
+                if (isAttributeValue &&
+                    value !== undefined &&
+                    endIndex < inputLength &&
+                    input.charCodeAt(endIndex - 1) !== /* ; */ 59) {
+                    const charCode = input.charCodeAt(endIndex);
+                    // An unterminated reference followed by "=" or an alphanumeric char is likely a URL query parameter
+                    if (charCode === /* = */ 61 || isAlphanumericCharCode(charCode)) {
+                        value = undefined;
+                    }
+                }
+            }
+            if (value !== undefined) {
+                // Appending the preceding text and the value separately avoids joining them into a new string first. Once
+                // the output is long enough to be a rope, each append only adds a node, even if the encodings differ.
+                if (textIndex !== charIndex) {
+                    output += input.slice(textIndex, charIndex);
+                }
+                output += value;
+                textIndex = endIndex;
+            }
+            if (endIndex >= inputLength - 1) {
+                break;
+            }
+            // Entities often follow each other, and checking the next char is cheaper than calling indexOf
+            if (value === undefined || input.charCodeAt(endIndex) !== /* & */ 38) {
+                charIndex = input.indexOf('&', endIndex);
+            }
+            else {
+                charIndex = endIndex;
+            }
+        }
+        return textIndex === 0 ? input : textIndex === inputLength ? output : output + input.slice(textIndex);
+    };
+}
+/**
+ * Windows-1252 chars for U+0080 to U+009F. Code points that Windows-1252 leaves undefined map to themselves.
+ *
+ * @see https://github.com/mathiasbynens/he/blob/master/data/decode-map-overrides.json
+ */
+// prettier-ignore
+const c1ControlValues = [
+    '\u20AC', '\u0081', '\u201A', '\u0192', '\u201E', '\u2026', '\u2020', '\u2021',
+    '\u02C6', '\u2030', '\u0160', '\u2039', '\u0152', '\u008D', '\u017D', '\u008F',
+    '\u0090', '\u2018', '\u2019', '\u201C', '\u201D', '\u2022', '\u2013', '\u2014',
+    '\u02DC', '\u2122', '\u0161', '\u203A', '\u0153', '\u009D', '\u017E', '\u0178',
+];
+function isAlphanumericCharCode(charCode) {
+    return ((charCode >= /* a */ 97 && charCode <= /* z */ 122) ||
+        (charCode >= /* A */ 65 && charCode <= /* Z */ 90) ||
+        (charCode >= /* 0 */ 48 && charCode <= /* 9 */ 57));
+}

package/decodeHTML.d.ts

@@ -1,4 +1,9 @@
 /**
- * Decodes all known HTML entities and numeric character references in the input.
+ * Decodes HTML entities and numeric references in text.
  */
 export declare const decodeHTML: (input: string) => string;
+/**
+ * Same as {@linkcode decodeHTML}, but for attribute values: like browsers, it doesn't decode a named reference without
+ * ";" if "=" or an ASCII letter or digit follows it, so "?a=1&copy=2" stays intact.
+ */
+export declare const decodeHTMLAttribute: (input: string) => string;

package/decodeHTML.js

@@ -1,9 +1,20 @@
-import { createEntityDecoder } from './createEntityDecoder.js';
-import htmlEntities from './html-entities.js';
+import { createDoubleArrayEntityTrie } from "./createDoubleArrayEntityTrie.js";
+import { createEntityTrieDecoder } from "./createEntityTrieDecoder.js";
+import entities from "./entities.js";
+const entityTrie = createDoubleArrayEntityTrie(entities);
 /**
- * Decodes all known HTML entities and numeric character references in the input.
+ * Decodes HTML entities and numeric references in text.
  */
-export const decodeHTML = createEntityDecoder({
-    entities: htmlEntities,
+export const decodeHTML = createEntityTrieDecoder(entityTrie, {
     isNumericReferenceSemicolonRequired: false,
+    areC1ControlsRemapped: true,
+});
+/**
+ * Same as {@linkcode decodeHTML}, but for attribute values: like browsers, it doesn't decode a named reference without
+ * ";" if "=" or an ASCII letter or digit follows it, so "?a=1&copy=2" stays intact.
+ */
+export const decodeHTMLAttribute = createEntityTrieDecoder(entityTrie, {
+    isNumericReferenceSemicolonRequired: false,
+    areC1ControlsRemapped: true,
+    isAttributeValue: true,
 });

package/decodeXML.d.ts

@@ -1,4 +1,4 @@
 /**
- * Decodes XML entities and numeric character references in the input.
+ * Decodes numeric references and the five predefined XML entities. References must end with ";", as XML requires.
  */
-export declare const decodeXML: (input: string) => string;
+export declare function decodeXML(input: string): string;

package/decodeXML.js

@@ -1,9 +1,130 @@
-import { createEntityDecoder } from './createEntityDecoder.js';
-import xmlEntities from './xml-entities.js';
 /**
- * Decodes XML entities and numeric character references in the input.
+ * Decodes numeric references and the five predefined XML entities. References must end with ";", as XML requires.
  */
-export const decodeXML = createEntityDecoder({
-    entities: xmlEntities,
-    isNumericReferenceSemicolonRequired: true,
-});
+export function decodeXML(input) {
+    let charIndex = input.indexOf('&');
+    if (charIndex === -1) {
+        // Most text has no references
+        return input;
+    }
+    let output = '';
+    let textIndex = 0;
+    const inputLength = input.length;
+    while (charIndex !== -1 && charIndex < inputLength - 1) {
+        let startIndex = charIndex + 1;
+        let value;
+        let endIndex = startIndex;
+        const charCode = input.charCodeAt(startIndex);
+        if (charCode === /* # */ 35) {
+            // Numeric character reference
+            if (startIndex < inputLength - 1) {
+                // All digits are consumed, out-of-range code points (Infinity included) are replaced with U+FFFD below
+                let codePoint = 0;
+                // The char after the digits, or -1 at the end of the input
+                let terminatorCharCode = -1;
+                if ((input.charCodeAt(++startIndex) | 32) === /* x */ 120) {
+                    endIndex = ++startIndex;
+                    // parseInt of a hexadecimal number
+                    while (endIndex < inputLength) {
+                        const digitCharCode = input.charCodeAt(endIndex);
+                        // Convert alpha to lower case
+                        const lowerCharCode = digitCharCode | 32;
+                        if (digitCharCode >= /* 0 */ 48 && digitCharCode <= /* 9 */ 57) {
+                            codePoint = codePoint * 16 + digitCharCode - 48;
+                        }
+                        else if (lowerCharCode >= /* a */ 97 && lowerCharCode <= /* f */ 102) {
+                            codePoint = codePoint * 16 + lowerCharCode - 87;
+                        }
+                        else {
+                            terminatorCharCode = digitCharCode;
+                            break;
+                        }
+                        ++endIndex;
+                    }
+                }
+                else {
+                    endIndex = startIndex;
+                    // parseInt of a decimal number
+                    while (endIndex < inputLength) {
+                        const digitCharCode = input.charCodeAt(endIndex);
+                        if (digitCharCode >= /* 0 */ 48 && digitCharCode <= /* 9 */ 57) {
+                            codePoint = codePoint * 10 + digitCharCode - 48;
+                        }
+                        else {
+                            terminatorCharCode = digitCharCode;
+                            break;
+                        }
+                        ++endIndex;
+                    }
+                }
+                // At least one digit and ";" must be present
+                if (endIndex !== startIndex && terminatorCharCode === /* ; */ 59) {
+                    ++endIndex;
+                    if (codePoint === 0 || (codePoint >= 0xd800 && codePoint <= 0xdfff) || codePoint > 0x10ffff) {
+                        // Null char code, or character reference is outside the permissible Unicode range
+                        value = '\uFFFD';
+                    }
+                    else {
+                        value = String.fromCodePoint(codePoint);
+                    }
+                }
+            }
+        }
+        else if (charCode === /* l */ 108 || charCode === /* g */ 103) {
+            // "&lt;" or "&gt;"
+            if (startIndex + 2 < inputLength &&
+                input.charCodeAt(startIndex + 1) === /* t */ 116 &&
+                input.charCodeAt(startIndex + 2) === /* ; */ 59) {
+                value = charCode === /* l */ 108 ? '<' : '>';
+                endIndex = startIndex + 3;
+            }
+        }
+        else if (charCode === /* a */ 97) {
+            // "&amp;" or "&apos;"
+            if (startIndex + 3 < inputLength) {
+                const nextCharCode = input.charCodeAt(startIndex + 1);
+                if (nextCharCode === /* m */ 109 &&
+                    input.charCodeAt(startIndex + 2) === /* p */ 112 &&
+                    input.charCodeAt(startIndex + 3) === /* ; */ 59) {
+                    value = '&';
+                    endIndex = startIndex + 4;
+                }
+                else if (nextCharCode === /* p */ 112 &&
+                    startIndex + 4 < inputLength &&
+                    input.charCodeAt(startIndex + 2) === /* o */ 111 &&
+                    input.charCodeAt(startIndex + 3) === /* s */ 115 &&
+                    input.charCodeAt(startIndex + 4) === /* ; */ 59) {
+                    value = "'";
+                    endIndex = startIndex + 5;
+                }
+            }
+        }
+        else if (charCode === /* q */ 113) {
+            // "&quot;"
+            if (startIndex + 4 < inputLength &&
+                input.charCodeAt(startIndex + 1) === /* u */ 117 &&
+                input.charCodeAt(startIndex + 2) === /* o */ 111 &&
+                input.charCodeAt(startIndex + 3) === /* t */ 116 &&
+                input.charCodeAt(startIndex + 4) === /* ; */ 59) {
+                value = '"';
+                endIndex = startIndex + 5;
+            }
+        }
+        if (value === undefined) {
+            charIndex = endIndex < inputLength - 1 ? input.indexOf('&', endIndex) : -1;
+            continue;
+        }
+        // Appending the preceding text and the value separately avoids joining them into a new string first
+        if (textIndex !== charIndex) {
+            output += input.slice(textIndex, charIndex);
+        }
+        output += value;
+        textIndex = endIndex;
+        if (endIndex >= inputLength - 1) {
+            break;
+        }
+        // References often follow each other, and checking the next char is cheaper than calling indexOf
+        charIndex = input.charCodeAt(endIndex) === /* & */ 38 ? endIndex : input.indexOf('&', endIndex);
+    }
+    return textIndex === 0 ? input : textIndex === inputLength ? output : output + input.slice(textIndex);
+}

package/encodeXML.d.ts

@@ -1 +1,5 @@
+/**
+ * Same as {@linkcode escapeXML}, but also encodes non-ASCII chars as numeric references, so the output is ASCII and
+ * safe for any document encoding. A lone surrogate is encoded as `�`.
+ */
 export declare function encodeXML(input: string): string;

package/encodeXML.js

@@ -1,38 +1,132 @@
-const re = /["&'<>\u0080-\uffff]/g;
+const encodedCharRegExp = /["&'<>\u0080-\uFFFF]/g;
+/**
+ * 1 for ASCII chars that are encoded.
+ */
+const encodedAsciiFlags = new Uint8Array(128);
+for (const char of '"&\'<>') {
+    encodedAsciiFlags[char.charCodeAt(0)] = 1;
+}
+/**
+ * References for U+0080 to U+07FF, formatted in advance, since text in Latin, Greek, Cyrillic, Hebrew or Arabic script
+ * reuses a few dozen of them.
+ */
+const numericReferences = [];
+for (let codePoint = 0x80; codePoint < 0x800; ++codePoint) {
+    numericReferences.push('&#x' + codePoint.toString(16) + ';');
+}
+const hexDigitCharCodes = Uint8Array.from('0123456789abcdef', char => char.charCodeAt(0));
+/**
+ * Same as {@linkcode escapeXML}, but also encodes non-ASCII chars as numeric references, so the output is ASCII and
+ * safe for any document encoding. A lone surrogate is encoded as `&#xfffd;`.
+ */
 export function encodeXML(input) {
+    const inputLength = input.length;
     let output = '';
     let textIndex = 0;
-    while (re.test(input)) {
-        let lastIndex = re.lastIndex;
-        const startIndex = lastIndex - 1;
-        const charCode = input.charCodeAt(startIndex);
+    let index = 0;
+    while (index < inputLength) {
+        const charCode = input.charCodeAt(index);
+        if (!isEncodedCharCode(charCode)) {
+            // Encoded chars are often close to each other, so a short run of plain chars is read inline
+            const scanEndIndex = Math.min(index + 24, inputLength);
+            do {
+                ++index;
+            } while (index < scanEndIndex && !isEncodedCharCode(input.charCodeAt(index)));
+            if (index < scanEndIndex) {
+                continue;
+            }
+            if (index === inputLength) {
+                break;
+            }
+            // In a longer run, the regexp finds the next encoded char faster than reading chars one by one
+            encodedCharRegExp.lastIndex = index;
+            if (!encodedCharRegExp.test(input)) {
+                break;
+            }
+            index = encodedCharRegExp.lastIndex - 1;
+            continue;
+        }
         let entity;
-        if (charCode >= 0x80 && charCode <= 0xffff) {
-            let codePoint = charCode;
-            if ((charCode & 0xfc00) === 0xd800) {
-                // Surrogate pair
-                codePoint = charCode * 0x400 + input.charCodeAt(lastIndex) - 0x35fdc00;
-                re.lastIndex = ++lastIndex;
+        let nextIndex = index + 1;
+        if (charCode >= 0xd800 && charCode <= 0xdfff) {
+            const codePoint = input.codePointAt(index);
+            if (codePoint > 0xffff) {
+                entity = getNumericReference(codePoint);
+                nextIndex = index + 2;
             }
-            entity = '&#x' + codePoint.toString(16) + ';';
+            else {
+                // A lone surrogate isn't a Unicode scalar value, so HTML parsers, decodeHTML and decodeXML decode a reference
+                // to it as U+FFFD anyway
+                entity = '&#xfffd;';
+            }
+        }
+        else if (charCode >= 0x80) {
+            entity = getNumericReference(charCode);
         }
-        else if (charCode === 34) {
+        else if (charCode === /* " */ 34) {
             entity = '&quot;';
         }
-        else if (charCode === 38) {
+        else if (charCode === /* & */ 38) {
             entity = '&amp;';
         }
-        else if (charCode === 39) {
+        else if (charCode === /* ' */ 39) {
             entity = '&apos;';
         }
-        else if (charCode === 60) {
+        else if (charCode === /* < */ 60) {
             entity = '&lt;';
         }
         else {
             entity = '&gt;';
         }
-        output += textIndex === startIndex ? entity : input.slice(textIndex, startIndex) + entity;
-        textIndex = lastIndex;
+        if (textIndex !== index) {
+            output += input.slice(textIndex, index);
+        }
+        output += entity;
+        textIndex = nextIndex;
+        index = nextIndex;
+    }
+    return textIndex === 0 ? input : textIndex === inputLength ? output : output + input.slice(textIndex);
+}
+function isEncodedCharCode(charCode) {
+    return charCode >= 0x80 || encodedAsciiFlags[charCode] === 1;
+}
+// The code point must be at least 0x80
+function getNumericReference(codePoint) {
+    return codePoint < 0x800 ? numericReferences[codePoint - 0x80] : formatNumericReference(codePoint);
+}
+/**
+ * Formats a reference like "&#x1f600;". Building it from char codes in one call is about twice as fast as toString(16)
+ * and concatenation. The code point must be at least 0x100.
+ */
+function formatNumericReference(codePoint) {
+    if (codePoint < 0x1000) {
+        return String.fromCharCode(
+        /* & */ 38, 
+        /* # */ 35, 
+        /* x */ 120, getHexDigitCharCode(codePoint, 8), getHexDigitCharCode(codePoint, 4), getHexDigitCharCode(codePoint, 0), 
+        /* ; */ 59);
+    }
+    if (codePoint < 0x10000) {
+        return String.fromCharCode(
+        /* & */ 38, 
+        /* # */ 35, 
+        /* x */ 120, getHexDigitCharCode(codePoint, 12), getHexDigitCharCode(codePoint, 8), getHexDigitCharCode(codePoint, 4), getHexDigitCharCode(codePoint, 0), 
+        /* ; */ 59);
     }
-    return textIndex === 0 ? input : textIndex === input.length ? output : output + input.slice(textIndex);
+    if (codePoint < 0x100000) {
+        return String.fromCharCode(
+        /* & */ 38, 
+        /* # */ 35, 
+        /* x */ 120, getHexDigitCharCode(codePoint, 16), getHexDigitCharCode(codePoint, 12), getHexDigitCharCode(codePoint, 8), getHexDigitCharCode(codePoint, 4), getHexDigitCharCode(codePoint, 0), 
+        /* ; */ 59);
+    }
+    return String.fromCharCode(
+    /* & */ 38, 
+    /* # */ 35, 
+    /* x */ 120, getHexDigitCharCode(codePoint, 20), getHexDigitCharCode(codePoint, 16), getHexDigitCharCode(codePoint, 12), getHexDigitCharCode(codePoint, 8), getHexDigitCharCode(codePoint, 4), getHexDigitCharCode(codePoint, 0), 
+    /* ; */ 59);
+}
+// The char code of the hex digit at the given bit offset
+function getHexDigitCharCode(codePoint, offset) {
+    return hexDigitCharCodes[(codePoint >> offset) & 15];
 }

package/entities.d.ts

@@ -0,0 +1,5 @@
+/**
+ * HTML entity references without "&" and their values in turn, sorted by reference.
+ */
+declare const _default: string[];
+export default _default;