speedy-entities 3.0.1 → 4.0.0

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

@@ -0,0 +1,9 @@
+/**
+ * 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

@@ -0,0 +1,20 @@
+import { createDoubleArrayEntityTrie } from "./createDoubleArrayEntityTrie.js";
+import { createEntityTrieDecoder } from "./createEntityTrieDecoder.js";
+import entities from "./entities.js";
+const entityTrie = createDoubleArrayEntityTrie(entities);
+/**
+ * Decodes HTML entities and numeric references in text.
+ */
+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

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

package/decodeXML.js

@@ -0,0 +1,130 @@
+/**
+ * Decodes numeric references and the five predefined XML entities. References must end with ";", as XML requires.
+ */
+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

@@ -0,0 +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

@@ -0,0 +1,132 @@
+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;
+    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;
+        let nextIndex = index + 1;
+        if (charCode >= 0xd800 && charCode <= 0xdfff) {
+            const codePoint = input.codePointAt(index);
+            if (codePoint > 0xffff) {
+                entity = getNumericReference(codePoint);
+                nextIndex = index + 2;
+            }
+            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) {
+            entity = '&quot;';
+        }
+        else if (charCode === /* & */ 38) {
+            entity = '&amp;';
+        }
+        else if (charCode === /* ' */ 39) {
+            entity = '&apos;';
+        }
+        else if (charCode === /* < */ 60) {
+            entity = '&lt;';
+        }
+        else {
+            entity = '&gt;';
+        }
+        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);
+    }
+    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;