@highstate/designer 0.19.1 → 0.20.0

package/.output/server/node_modules/entities/{lib → dist/commonjs}/decode.js

@@ -1,41 +1,15 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.decodeXML = exports.decodeHTMLStrict = exports.decodeHTMLAttribute = exports.decodeHTML = exports.determineBranch = exports.EntityDecoder = exports.DecodingMode = exports.BinTrieFlags = exports.fromCodePoint = exports.replaceCodePoint = exports.decodeCodePoint = exports.xmlDecodeTree = exports.htmlDecodeTree = void 0;
-var decode_data_html_js_1 = __importDefault(require("./generated/decode-data-html.js"));
-exports.htmlDecodeTree = decode_data_html_js_1.default;
-var decode_data_xml_js_1 = __importDefault(require("./generated/decode-data-xml.js"));
-exports.xmlDecodeTree = decode_data_xml_js_1.default;
-var decode_codepoint_js_1 = __importStar(require("./decode_codepoint.js"));
-exports.decodeCodePoint = decode_codepoint_js_1.default;
-var decode_codepoint_js_2 = require("./decode_codepoint.js");
-Object.defineProperty(exports, "replaceCodePoint", { enumerable: true, get: function () { return decode_codepoint_js_2.replaceCodePoint; } });
-Object.defineProperty(exports, "fromCodePoint", { enumerable: true, get: function () { return decode_codepoint_js_2.fromCodePoint; } });
+exports.xmlDecodeTree = exports.htmlDecodeTree = exports.replaceCodePoint = exports.fromCodePoint = exports.decodeCodePoint = exports.EntityDecoder = exports.DecodingMode = void 0;
+exports.determineBranch = determineBranch;
+exports.decodeHTML = decodeHTML;
+exports.decodeHTMLAttribute = decodeHTMLAttribute;
+exports.decodeHTMLStrict = decodeHTMLStrict;
+exports.decodeXML = decodeXML;
+const decode_codepoint_js_1 = require("./decode-codepoint.js");
+const decode_data_html_js_1 = require("./generated/decode-data-html.js");
+const decode_data_xml_js_1 = require("./generated/decode-data-xml.js");
+const bin_trie_flags_js_1 = require("./internal/bin-trie-flags.js");
 var CharCodes;
 (function (CharCodes) {
     CharCodes[CharCodes["NUM"] = 35] = "NUM";
@@ -52,13 +26,7 @@ var CharCodes;
     CharCodes[CharCodes["UPPER_Z"] = 90] = "UPPER_Z";
 })(CharCodes || (CharCodes = {}));
 /** Bit that needs to be set to convert an upper case ASCII character to lower case */
-var TO_LOWER_BIT = 32;
-var BinTrieFlags;
-(function (BinTrieFlags) {
-    BinTrieFlags[BinTrieFlags["VALUE_LENGTH"] = 49152] = "VALUE_LENGTH";
-    BinTrieFlags[BinTrieFlags["BRANCH_LENGTH"] = 16256] = "BRANCH_LENGTH";
-    BinTrieFlags[BinTrieFlags["JUMP_TABLE"] = 127] = "JUMP_TABLE";
-})(BinTrieFlags = exports.BinTrieFlags || (exports.BinTrieFlags = {}));
+const TO_LOWER_BIT = 32;
 function isNumber(code) {
     return code >= CharCodes.ZERO && code <= CharCodes.NINE;
 }
@@ -96,13 +64,14 @@ var DecodingMode;
     DecodingMode[DecodingMode["Strict"] = 1] = "Strict";
     /** Entities in attributes have limitations on ending characters. */
     DecodingMode[DecodingMode["Attribute"] = 2] = "Attribute";
-})(DecodingMode = exports.DecodingMode || (exports.DecodingMode = {}));
+})(DecodingMode || (exports.DecodingMode = DecodingMode = {}));
 /**
  * Token decoder with support of writing partial entities.
  */
-var EntityDecoder = /** @class */ (function () {
-    function EntityDecoder(
+class EntityDecoder {
+    constructor(
     /** The tree used to decode entities. */
+    // biome-ignore lint/correctness/noUnusedPrivateClassMembers: False positive
     decodeTree, 
     /**
      * The function that is called when a codepoint is decoded.
@@ -136,16 +105,19 @@ var EntityDecoder = /** @class */ (function () {
         this.excess = 1;
         /** The mode in which the decoder is operating. */
         this.decodeMode = DecodingMode.Strict;
+        /** The number of characters that have been consumed in the current run. */
+        this.runConsumed = 0;
     }
     /** Resets the instance to make it reusable. */
-    EntityDecoder.prototype.startEntity = function (decodeMode) {
+    startEntity(decodeMode) {
         this.decodeMode = decodeMode;
         this.state = EntityDecoderState.EntityStart;
         this.result = 0;
         this.treeIndex = 0;
         this.excess = 1;
         this.consumed = 1;
-    };
+        this.runConsumed = 0;
+    }
     /**
      * Write an entity to the decoder. This can be called multiple times with partial entities.
      * If the entity is incomplete, the decoder will return -1.
@@ -153,113 +125,106 @@ var EntityDecoder = /** @class */ (function () {
      * Mirrors the implementation of `getDecoder`, but with the ability to stop decoding if the
      * entity is incomplete, and resume when the next string is written.
      *
-     * @param string The string containing the entity (or a continuation of the entity).
+     * @param input The string containing the entity (or a continuation of the entity).
      * @param offset The offset at which the entity begins. Should be 0 if this is not the first call.
      * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
      */
-    EntityDecoder.prototype.write = function (str, offset) {
+    write(input, offset) {
         switch (this.state) {
             case EntityDecoderState.EntityStart: {
-                if (str.charCodeAt(offset) === CharCodes.NUM) {
+                if (input.charCodeAt(offset) === CharCodes.NUM) {
                     this.state = EntityDecoderState.NumericStart;
                     this.consumed += 1;
-                    return this.stateNumericStart(str, offset + 1);
+                    return this.stateNumericStart(input, offset + 1);
                 }
                 this.state = EntityDecoderState.NamedEntity;
-                return this.stateNamedEntity(str, offset);
+                return this.stateNamedEntity(input, offset);
             }
             case EntityDecoderState.NumericStart: {
-                return this.stateNumericStart(str, offset);
+                return this.stateNumericStart(input, offset);
             }
             case EntityDecoderState.NumericDecimal: {
-                return this.stateNumericDecimal(str, offset);
+                return this.stateNumericDecimal(input, offset);
             }
             case EntityDecoderState.NumericHex: {
-                return this.stateNumericHex(str, offset);
+                return this.stateNumericHex(input, offset);
             }
             case EntityDecoderState.NamedEntity: {
-                return this.stateNamedEntity(str, offset);
+                return this.stateNamedEntity(input, offset);
             }
         }
-    };
+    }
     /**
      * Switches between the numeric decimal and hexadecimal states.
      *
      * Equivalent to the `Numeric character reference state` in the HTML spec.
      *
-     * @param str The string containing the entity (or a continuation of the entity).
+     * @param input The string containing the entity (or a continuation of the entity).
      * @param offset The current offset.
      * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
      */
-    EntityDecoder.prototype.stateNumericStart = function (str, offset) {
-        if (offset >= str.length) {
+    stateNumericStart(input, offset) {
+        if (offset >= input.length) {
             return -1;
         }
-        if ((str.charCodeAt(offset) | TO_LOWER_BIT) === CharCodes.LOWER_X) {
+        if ((input.charCodeAt(offset) | TO_LOWER_BIT) === CharCodes.LOWER_X) {
             this.state = EntityDecoderState.NumericHex;
             this.consumed += 1;
-            return this.stateNumericHex(str, offset + 1);
+            return this.stateNumericHex(input, offset + 1);
         }
         this.state = EntityDecoderState.NumericDecimal;
-        return this.stateNumericDecimal(str, offset);
-    };
-    EntityDecoder.prototype.addToNumericResult = function (str, start, end, base) {
-        if (start !== end) {
-            var digitCount = end - start;
-            this.result =
-                this.result * Math.pow(base, digitCount) +
-                    parseInt(str.substr(start, digitCount), base);
-            this.consumed += digitCount;
-        }
-    };
+        return this.stateNumericDecimal(input, offset);
+    }
     /**
      * Parses a hexadecimal numeric entity.
      *
      * Equivalent to the `Hexademical character reference state` in the HTML spec.
      *
-     * @param str The string containing the entity (or a continuation of the entity).
+     * @param input The string containing the entity (or a continuation of the entity).
      * @param offset The current offset.
      * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
      */
-    EntityDecoder.prototype.stateNumericHex = function (str, offset) {
-        var startIdx = offset;
-        while (offset < str.length) {
-            var char = str.charCodeAt(offset);
+    stateNumericHex(input, offset) {
+        while (offset < input.length) {
+            const char = input.charCodeAt(offset);
             if (isNumber(char) || isHexadecimalCharacter(char)) {
-                offset += 1;
+                // Convert hex digit to value (0-15); 'a'/'A' -> 10.
+                const digit = char <= CharCodes.NINE
+                    ? char - CharCodes.ZERO
+                    : (char | TO_LOWER_BIT) - CharCodes.LOWER_A + 10;
+                this.result = this.result * 16 + digit;
+                this.consumed++;
+                offset++;
             }
             else {
-                this.addToNumericResult(str, startIdx, offset, 16);
                 return this.emitNumericEntity(char, 3);
             }
         }
-        this.addToNumericResult(str, startIdx, offset, 16);
-        return -1;
-    };
+        return -1; // Incomplete entity
+    }
     /**
      * Parses a decimal numeric entity.
      *
      * Equivalent to the `Decimal character reference state` in the HTML spec.
      *
-     * @param str The string containing the entity (or a continuation of the entity).
+     * @param input The string containing the entity (or a continuation of the entity).
      * @param offset The current offset.
      * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
      */
-    EntityDecoder.prototype.stateNumericDecimal = function (str, offset) {
-        var startIdx = offset;
-        while (offset < str.length) {
-            var char = str.charCodeAt(offset);
+    stateNumericDecimal(input, offset) {
+        while (offset < input.length) {
+            const char = input.charCodeAt(offset);
             if (isNumber(char)) {
-                offset += 1;
+                this.result = this.result * 10 + (char - CharCodes.ZERO);
+                this.consumed++;
+                offset++;
             }
             else {
-                this.addToNumericResult(str, startIdx, offset, 10);
                 return this.emitNumericEntity(char, 2);
             }
         }
-        this.addToNumericResult(str, startIdx, offset, 10);
-        return -1;
-    };
+        return -1; // Incomplete entity
+    }
     /**
      * Validate and emit a numeric entity.
      *
@@ -273,7 +238,7 @@ var EntityDecoder = /** @class */ (function () {
      *                       was consumed.
      * @returns The number of characters that were consumed.
      */
-    EntityDecoder.prototype.emitNumericEntity = function (lastCp, expectedLength) {
+    emitNumericEntity(lastCp, expectedLength) {
         var _a;
         // Ensure we consumed at least one digit.
         if (this.consumed <= expectedLength) {
@@ -295,23 +260,77 @@ var EntityDecoder = /** @class */ (function () {
             this.errors.validateNumericCharacterReference(this.result);
         }
         return this.consumed;
-    };
+    }
     /**
      * Parses a named entity.
      *
      * Equivalent to the `Named character reference state` in the HTML spec.
      *
-     * @param str The string containing the entity (or a continuation of the entity).
+     * @param input The string containing the entity (or a continuation of the entity).
      * @param offset The current offset.
      * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
      */
-    EntityDecoder.prototype.stateNamedEntity = function (str, offset) {
-        var decodeTree = this.decodeTree;
-        var current = decodeTree[this.treeIndex];
-        // The mask is the number of bytes of the value, including the current byte.
-        var valueLength = (current & BinTrieFlags.VALUE_LENGTH) >> 14;
-        for (; offset < str.length; offset++, this.excess++) {
-            var char = str.charCodeAt(offset);
+    stateNamedEntity(input, offset) {
+        const { decodeTree } = this;
+        let current = decodeTree[this.treeIndex];
+        // The length is the number of bytes of the value, including the current byte.
+        let valueLength = (current & bin_trie_flags_js_1.BinTrieFlags.VALUE_LENGTH) >> 14;
+        while (offset < input.length) {
+            // Handle compact runs (possibly inline): valueLength == 0 and SEMI_REQUIRED bit set.
+            if (valueLength === 0 && (current & bin_trie_flags_js_1.BinTrieFlags.FLAG13) !== 0) {
+                const runLength = (current & bin_trie_flags_js_1.BinTrieFlags.BRANCH_LENGTH) >> 7; /* 2..63 */
+                // If we are starting a run, check the first char.
+                if (this.runConsumed === 0) {
+                    const firstChar = current & bin_trie_flags_js_1.BinTrieFlags.JUMP_TABLE;
+                    if (input.charCodeAt(offset) !== firstChar) {
+                        return this.result === 0
+                            ? 0
+                            : this.emitNotTerminatedNamedEntity();
+                    }
+                    offset++;
+                    this.excess++;
+                    this.runConsumed++;
+                }
+                // Check remaining characters in the run.
+                while (this.runConsumed < runLength) {
+                    if (offset >= input.length) {
+                        return -1;
+                    }
+                    const charIndexInPacked = this.runConsumed - 1;
+                    const packedWord = decodeTree[this.treeIndex + 1 + (charIndexInPacked >> 1)];
+                    const expectedChar = charIndexInPacked % 2 === 0
+                        ? packedWord & 0xff
+                        : (packedWord >> 8) & 0xff;
+                    if (input.charCodeAt(offset) !== expectedChar) {
+                        this.runConsumed = 0;
+                        return this.result === 0
+                            ? 0
+                            : this.emitNotTerminatedNamedEntity();
+                    }
+                    offset++;
+                    this.excess++;
+                    this.runConsumed++;
+                }
+                this.runConsumed = 0;
+                this.treeIndex += 1 + (runLength >> 1);
+                current = decodeTree[this.treeIndex];
+                valueLength = (current & bin_trie_flags_js_1.BinTrieFlags.VALUE_LENGTH) >> 14;
+            }
+            if (offset >= input.length)
+                break;
+            const char = input.charCodeAt(offset);
+            /*
+             * Implicit semicolon handling for nodes that require a semicolon but
+             * don't have an explicit ';' branch stored in the trie. If we have
+             * a value on the current node, it requires a semicolon, and the
+             * current input character is a semicolon, emit the entity using the
+             * current node (without descending further).
+             */
+            if (char === CharCodes.SEMI &&
+                valueLength !== 0 &&
+                (current & bin_trie_flags_js_1.BinTrieFlags.FLAG13) !== 0) {
+                return this.emitNamedEntityData(this.treeIndex, valueLength, this.consumed + this.excess);
+            }
             this.treeIndex = determineBranch(decodeTree, current, this.treeIndex + Math.max(1, valueLength), char);
             if (this.treeIndex < 0) {
                 return this.result === 0 ||
@@ -325,7 +344,7 @@ var EntityDecoder = /** @class */ (function () {
                     : this.emitNotTerminatedNamedEntity();
             }
             current = decodeTree[this.treeIndex];
-            valueLength = (current & BinTrieFlags.VALUE_LENGTH) >> 14;
+            valueLength = (current & bin_trie_flags_js_1.BinTrieFlags.VALUE_LENGTH) >> 14;
             // If the branch is a value, store it and continue
             if (valueLength !== 0) {
                 // If the entity is terminated by a semicolon, we are done.
@@ -333,28 +352,32 @@ var EntityDecoder = /** @class */ (function () {
                     return this.emitNamedEntityData(this.treeIndex, valueLength, this.consumed + this.excess);
                 }
                 // If we encounter a non-terminated (legacy) entity while parsing strictly, then ignore it.
-                if (this.decodeMode !== DecodingMode.Strict) {
+                if (this.decodeMode !== DecodingMode.Strict &&
+                    (current & bin_trie_flags_js_1.BinTrieFlags.FLAG13) === 0) {
                     this.result = this.treeIndex;
                     this.consumed += this.excess;
                     this.excess = 0;
                 }
             }
+            // Increment offset & excess for next iteration
+            offset++;
+            this.excess++;
         }
         return -1;
-    };
+    }
     /**
      * Emit a named entity that was not terminated with a semicolon.
      *
      * @returns The number of characters consumed.
      */
-    EntityDecoder.prototype.emitNotTerminatedNamedEntity = function () {
+    emitNotTerminatedNamedEntity() {
         var _a;
-        var _b = this, result = _b.result, decodeTree = _b.decodeTree;
-        var valueLength = (decodeTree[result] & BinTrieFlags.VALUE_LENGTH) >> 14;
+        const { result, decodeTree } = this;
+        const valueLength = (decodeTree[result] & bin_trie_flags_js_1.BinTrieFlags.VALUE_LENGTH) >> 14;
         this.emitNamedEntityData(result, valueLength, this.consumed);
         (_a = this.errors) === null || _a === void 0 ? void 0 : _a.missingSemicolonAfterCharacterReference();
         return this.consumed;
-    };
+    }
     /**
      * Emit a named entity.
      *
@@ -364,17 +387,18 @@ var EntityDecoder = /** @class */ (function () {
      *
      * @returns The number of characters consumed.
      */
-    EntityDecoder.prototype.emitNamedEntityData = function (result, valueLength, consumed) {
-        var decodeTree = this.decodeTree;
+    emitNamedEntityData(result, valueLength, consumed) {
+        const { decodeTree } = this;
         this.emitCodePoint(valueLength === 1
-            ? decodeTree[result] & ~BinTrieFlags.VALUE_LENGTH
+            ? decodeTree[result] &
+                ~(bin_trie_flags_js_1.BinTrieFlags.VALUE_LENGTH | bin_trie_flags_js_1.BinTrieFlags.FLAG13)
             : decodeTree[result + 1], consumed);
         if (valueLength === 3) {
             // For multi-byte values, we need to emit the second byte.
             this.emitCodePoint(decodeTree[result + 2], consumed);
         }
         return consumed;
-    };
+    }
     /**
      * Signal to the parser that the end of the input was reached.
      *
@@ -382,7 +406,7 @@ var EntityDecoder = /** @class */ (function () {
      *
      * @returns The number of characters consumed.
      */
-    EntityDecoder.prototype.end = function () {
+    end() {
         var _a;
         switch (this.state) {
             case EntityDecoderState.NamedEntity: {
@@ -409,9 +433,8 @@ var EntityDecoder = /** @class */ (function () {
                 return 0;
             }
         }
-    };
-    return EntityDecoder;
-}());
+    }
+}
 exports.EntityDecoder = EntityDecoder;
 /**
  * Creates a function that decodes entities in a string.
@@ -420,28 +443,28 @@ exports.EntityDecoder = EntityDecoder;
  * @returns A function that decodes entities in a string.
  */
 function getDecoder(decodeTree) {
-    var ret = "";
-    var decoder = new EntityDecoder(decodeTree, function (str) { return (ret += (0, decode_codepoint_js_1.fromCodePoint)(str)); });
-    return function decodeWithTrie(str, decodeMode) {
-        var lastIndex = 0;
-        var offset = 0;
-        while ((offset = str.indexOf("&", offset)) >= 0) {
-            ret += str.slice(lastIndex, offset);
+    let returnValue = "";
+    const decoder = new EntityDecoder(decodeTree, (data) => (returnValue += (0, decode_codepoint_js_1.fromCodePoint)(data)));
+    return function decodeWithTrie(input, decodeMode) {
+        let lastIndex = 0;
+        let offset = 0;
+        while ((offset = input.indexOf("&", offset)) >= 0) {
+            returnValue += input.slice(lastIndex, offset);
             decoder.startEntity(decodeMode);
-            var len = decoder.write(str, 
+            const length = decoder.write(input, 
             // Skip the "&"
             offset + 1);
-            if (len < 0) {
+            if (length < 0) {
                 lastIndex = offset + decoder.end();
                 break;
             }
-            lastIndex = offset + len;
-            // If `len` is 0, skip the current `&` and continue.
-            offset = len === 0 ? lastIndex + 1 : lastIndex;
+            lastIndex = offset + length;
+            // If `length` is 0, skip the current `&` and continue.
+            offset = length === 0 ? lastIndex + 1 : lastIndex;
         }
-        var result = ret + str.slice(lastIndex);
+        const result = returnValue + input.slice(lastIndex);
         // Make sure we don't keep a reference to the final string.
-        ret = "";
+        returnValue = "";
         return result;
     };
 }
@@ -455,82 +478,91 @@ function getDecoder(decodeTree) {
  * @param char The current character.
  * @returns The index of the next node, or -1 if no branch is taken.
  */
-function determineBranch(decodeTree, current, nodeIdx, char) {
-    var branchCount = (current & BinTrieFlags.BRANCH_LENGTH) >> 7;
-    var jumpOffset = current & BinTrieFlags.JUMP_TABLE;
+function determineBranch(decodeTree, current, nodeIndex, char) {
+    const branchCount = (current & bin_trie_flags_js_1.BinTrieFlags.BRANCH_LENGTH) >> 7;
+    const jumpOffset = current & bin_trie_flags_js_1.BinTrieFlags.JUMP_TABLE;
     // Case 1: Single branch encoded in jump offset
     if (branchCount === 0) {
-        return jumpOffset !== 0 && char === jumpOffset ? nodeIdx : -1;
+        return jumpOffset !== 0 && char === jumpOffset ? nodeIndex : -1;
     }
     // Case 2: Multiple branches encoded in jump table
     if (jumpOffset) {
-        var value = char - jumpOffset;
+        const value = char - jumpOffset;
         return value < 0 || value >= branchCount
             ? -1
-            : decodeTree[nodeIdx + value] - 1;
+            : decodeTree[nodeIndex + value] - 1;
     }
-    // Case 3: Multiple branches encoded in dictionary
-    // Binary search for the character.
-    var lo = nodeIdx;
-    var hi = lo + branchCount - 1;
+    // Case 3: Multiple branches encoded in packed dictionary (two keys per uint16)
+    const packedKeySlots = (branchCount + 1) >> 1;
+    /*
+     * Treat packed keys as a virtual sorted array of length `branchCount`.
+     * Key(i) = low byte for even i, high byte for odd i in slot i>>1.
+     */
+    let lo = 0;
+    let hi = branchCount - 1;
     while (lo <= hi) {
-        var mid = (lo + hi) >>> 1;
-        var midVal = decodeTree[mid];
-        if (midVal < char) {
+        const mid = (lo + hi) >>> 1;
+        const slot = mid >> 1;
+        const packed = decodeTree[nodeIndex + slot];
+        const midKey = (packed >> ((mid & 1) * 8)) & 0xff;
+        if (midKey < char) {
             lo = mid + 1;
         }
-        else if (midVal > char) {
+        else if (midKey > char) {
             hi = mid - 1;
         }
         else {
-            return decodeTree[mid + branchCount];
+            return decodeTree[nodeIndex + packedKeySlots + mid];
         }
     }
     return -1;
 }
-exports.determineBranch = determineBranch;
-var htmlDecoder = getDecoder(decode_data_html_js_1.default);
-var xmlDecoder = getDecoder(decode_data_xml_js_1.default);
+const htmlDecoder = /* #__PURE__ */ getDecoder(decode_data_html_js_1.htmlDecodeTree);
+const xmlDecoder = /* #__PURE__ */ getDecoder(decode_data_xml_js_1.xmlDecodeTree);
 /**
  * Decodes an HTML string.
  *
- * @param str The string to decode.
+ * @param htmlString The string to decode.
  * @param mode The decoding mode.
  * @returns The decoded string.
  */
-function decodeHTML(str, mode) {
-    if (mode === void 0) { mode = DecodingMode.Legacy; }
-    return htmlDecoder(str, mode);
+function decodeHTML(htmlString, mode = DecodingMode.Legacy) {
+    return htmlDecoder(htmlString, mode);
 }
-exports.decodeHTML = decodeHTML;
 /**
  * Decodes an HTML string in an attribute.
  *
- * @param str The string to decode.
+ * @param htmlAttribute The string to decode.
  * @returns The decoded string.
  */
-function decodeHTMLAttribute(str) {
-    return htmlDecoder(str, DecodingMode.Attribute);
+function decodeHTMLAttribute(htmlAttribute) {
+    return htmlDecoder(htmlAttribute, DecodingMode.Attribute);
 }
-exports.decodeHTMLAttribute = decodeHTMLAttribute;
 /**
  * Decodes an HTML string, requiring all entities to be terminated by a semicolon.
  *
- * @param str The string to decode.
+ * @param htmlString The string to decode.
  * @returns The decoded string.
  */
-function decodeHTMLStrict(str) {
-    return htmlDecoder(str, DecodingMode.Strict);
+function decodeHTMLStrict(htmlString) {
+    return htmlDecoder(htmlString, DecodingMode.Strict);
 }
-exports.decodeHTMLStrict = decodeHTMLStrict;
 /**
  * Decodes an XML string, requiring all entities to be terminated by a semicolon.
  *
- * @param str The string to decode.
+ * @param xmlString The string to decode.
  * @returns The decoded string.
  */
-function decodeXML(str) {
-    return xmlDecoder(str, DecodingMode.Strict);
+function decodeXML(xmlString) {
+    return xmlDecoder(xmlString, DecodingMode.Strict);
 }
-exports.decodeXML = decodeXML;
+var decode_codepoint_js_2 = require("./decode-codepoint.js");
+Object.defineProperty(exports, "decodeCodePoint", { enumerable: true, get: function () { return decode_codepoint_js_2.decodeCodePoint; } });
+Object.defineProperty(exports, "fromCodePoint", { enumerable: true, get: function () { return decode_codepoint_js_2.fromCodePoint; } });
+Object.defineProperty(exports, "replaceCodePoint", { enumerable: true, get: function () { return decode_codepoint_js_2.replaceCodePoint; } });
+// Re-export for use by eg. htmlparser2
+var decode_data_html_js_2 = require("./generated/decode-data-html.js");
+Object.defineProperty(exports, "htmlDecodeTree", { enumerable: true, get: function () { return decode_data_html_js_2.htmlDecodeTree; } });
+var decode_data_xml_js_2 = require("./generated/decode-data-xml.js");
+Object.defineProperty(exports, "xmlDecodeTree", { enumerable: true, get: function () { return decode_data_xml_js_2.xmlDecodeTree; } });
 //# sourceMappingURL=decode.js.map