@websolutespa/bom-next 3.0.0 → 3.0.2

package/dist/node_modules/domhandler/lib/esm/node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.js","names":["isTagRaw"],"sources":["../../../../../../../node_modules/domhandler/lib/esm/node.js"],"sourcesContent":["import { ElementType, isTag as isTagRaw } from \"domelementtype\";\n/**\n * This object will be used as the prototype for Nodes when creating a\n * DOM-Level-1-compliant structure.\n */\nexport class Node {\n    constructor() {\n        /** Parent of the node */\n        this.parent = null;\n        /** Previous sibling */\n        this.prev = null;\n        /** Next sibling */\n        this.next = null;\n        /** The start index of the node. Requires `withStartIndices` on the handler to be `true. */\n        this.startIndex = null;\n        /** The end index of the node. Requires `withEndIndices` on the handler to be `true. */\n        this.endIndex = null;\n    }\n    // Read-write aliases for properties\n    /**\n     * Same as {@link parent}.\n     * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.\n     */\n    get parentNode() {\n        return this.parent;\n    }\n    set parentNode(parent) {\n        this.parent = parent;\n    }\n    /**\n     * Same as {@link prev}.\n     * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.\n     */\n    get previousSibling() {\n        return this.prev;\n    }\n    set previousSibling(prev) {\n        this.prev = prev;\n    }\n    /**\n     * Same as {@link next}.\n     * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.\n     */\n    get nextSibling() {\n        return this.next;\n    }\n    set nextSibling(next) {\n        this.next = next;\n    }\n    /**\n     * Clone this node, and optionally its children.\n     *\n     * @param recursive Clone child nodes as well.\n     * @returns A clone of the node.\n     */\n    cloneNode(recursive = false) {\n        return cloneNode(this, recursive);\n    }\n}\n/**\n * A node that contains some data.\n */\nexport class DataNode extends Node {\n    /**\n     * @param data The content of the data node\n     */\n    constructor(data) {\n        super();\n        this.data = data;\n    }\n    /**\n     * Same as {@link data}.\n     * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.\n     */\n    get nodeValue() {\n        return this.data;\n    }\n    set nodeValue(data) {\n        this.data = data;\n    }\n}\n/**\n * Text within the document.\n */\nexport class Text extends DataNode {\n    constructor() {\n        super(...arguments);\n        this.type = ElementType.Text;\n    }\n    get nodeType() {\n        return 3;\n    }\n}\n/**\n * Comments within the document.\n */\nexport class Comment extends DataNode {\n    constructor() {\n        super(...arguments);\n        this.type = ElementType.Comment;\n    }\n    get nodeType() {\n        return 8;\n    }\n}\n/**\n * Processing instructions, including doc types.\n */\nexport class ProcessingInstruction extends DataNode {\n    constructor(name, data) {\n        super(data);\n        this.name = name;\n        this.type = ElementType.Directive;\n    }\n    get nodeType() {\n        return 1;\n    }\n}\n/**\n * A `Node` that can have children.\n */\nexport class NodeWithChildren extends Node {\n    /**\n     * @param children Children of the node. Only certain node types can have children.\n     */\n    constructor(children) {\n        super();\n        this.children = children;\n    }\n    // Aliases\n    /** First child of the node. */\n    get firstChild() {\n        var _a;\n        return (_a = this.children[0]) !== null && _a !== void 0 ? _a : null;\n    }\n    /** Last child of the node. */\n    get lastChild() {\n        return this.children.length > 0\n            ? this.children[this.children.length - 1]\n            : null;\n    }\n    /**\n     * Same as {@link children}.\n     * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.\n     */\n    get childNodes() {\n        return this.children;\n    }\n    set childNodes(children) {\n        this.children = children;\n    }\n}\nexport class CDATA extends NodeWithChildren {\n    constructor() {\n        super(...arguments);\n        this.type = ElementType.CDATA;\n    }\n    get nodeType() {\n        return 4;\n    }\n}\n/**\n * The root node of the document.\n */\nexport class Document extends NodeWithChildren {\n    constructor() {\n        super(...arguments);\n        this.type = ElementType.Root;\n    }\n    get nodeType() {\n        return 9;\n    }\n}\n/**\n * An element within the DOM.\n */\nexport class Element extends NodeWithChildren {\n    /**\n     * @param name Name of the tag, eg. `div`, `span`.\n     * @param attribs Object mapping attribute names to attribute values.\n     * @param children Children of the node.\n     */\n    constructor(name, attribs, children = [], type = name === \"script\"\n        ? ElementType.Script\n        : name === \"style\"\n            ? ElementType.Style\n            : ElementType.Tag) {\n        super(children);\n        this.name = name;\n        this.attribs = attribs;\n        this.type = type;\n    }\n    get nodeType() {\n        return 1;\n    }\n    // DOM Level 1 aliases\n    /**\n     * Same as {@link name}.\n     * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.\n     */\n    get tagName() {\n        return this.name;\n    }\n    set tagName(name) {\n        this.name = name;\n    }\n    get attributes() {\n        return Object.keys(this.attribs).map((name) => {\n            var _a, _b;\n            return ({\n                name,\n                value: this.attribs[name],\n                namespace: (_a = this[\"x-attribsNamespace\"]) === null || _a === void 0 ? void 0 : _a[name],\n                prefix: (_b = this[\"x-attribsPrefix\"]) === null || _b === void 0 ? void 0 : _b[name],\n            });\n        });\n    }\n}\n/**\n * @param node Node to check.\n * @returns `true` if the node is a `Element`, `false` otherwise.\n */\nexport function isTag(node) {\n    return isTagRaw(node);\n}\n/**\n * @param node Node to check.\n * @returns `true` if the node has the type `CDATA`, `false` otherwise.\n */\nexport function isCDATA(node) {\n    return node.type === ElementType.CDATA;\n}\n/**\n * @param node Node to check.\n * @returns `true` if the node has the type `Text`, `false` otherwise.\n */\nexport function isText(node) {\n    return node.type === ElementType.Text;\n}\n/**\n * @param node Node to check.\n * @returns `true` if the node has the type `Comment`, `false` otherwise.\n */\nexport function isComment(node) {\n    return node.type === ElementType.Comment;\n}\n/**\n * @param node Node to check.\n * @returns `true` if the node has the type `ProcessingInstruction`, `false` otherwise.\n */\nexport function isDirective(node) {\n    return node.type === ElementType.Directive;\n}\n/**\n * @param node Node to check.\n * @returns `true` if the node has the type `ProcessingInstruction`, `false` otherwise.\n */\nexport function isDocument(node) {\n    return node.type === ElementType.Root;\n}\n/**\n * @param node Node to check.\n * @returns `true` if the node has children, `false` otherwise.\n */\nexport function hasChildren(node) {\n    return Object.prototype.hasOwnProperty.call(node, \"children\");\n}\n/**\n * Clone a node, and optionally its children.\n *\n * @param recursive Clone child nodes as well.\n * @returns A clone of the node.\n */\nexport function cloneNode(node, recursive = false) {\n    let result;\n    if (isText(node)) {\n        result = new Text(node.data);\n    }\n    else if (isComment(node)) {\n        result = new Comment(node.data);\n    }\n    else if (isTag(node)) {\n        const children = recursive ? cloneChildren(node.children) : [];\n        const clone = new Element(node.name, { ...node.attribs }, children);\n        children.forEach((child) => (child.parent = clone));\n        if (node.namespace != null) {\n            clone.namespace = node.namespace;\n        }\n        if (node[\"x-attribsNamespace\"]) {\n            clone[\"x-attribsNamespace\"] = { ...node[\"x-attribsNamespace\"] };\n        }\n        if (node[\"x-attribsPrefix\"]) {\n            clone[\"x-attribsPrefix\"] = { ...node[\"x-attribsPrefix\"] };\n        }\n        result = clone;\n    }\n    else if (isCDATA(node)) {\n        const children = recursive ? cloneChildren(node.children) : [];\n        const clone = new CDATA(children);\n        children.forEach((child) => (child.parent = clone));\n        result = clone;\n    }\n    else if (isDocument(node)) {\n        const children = recursive ? cloneChildren(node.children) : [];\n        const clone = new Document(children);\n        children.forEach((child) => (child.parent = clone));\n        if (node[\"x-mode\"]) {\n            clone[\"x-mode\"] = node[\"x-mode\"];\n        }\n        result = clone;\n    }\n    else if (isDirective(node)) {\n        const instruction = new ProcessingInstruction(node.name, node.data);\n        if (node[\"x-name\"] != null) {\n            instruction[\"x-name\"] = node[\"x-name\"];\n            instruction[\"x-publicId\"] = node[\"x-publicId\"];\n            instruction[\"x-systemId\"] = node[\"x-systemId\"];\n        }\n        result = instruction;\n    }\n    else {\n        throw new Error(`Not implemented yet: ${node.type}`);\n    }\n    result.startIndex = node.startIndex;\n    result.endIndex = node.endIndex;\n    if (node.sourceCodeLocation != null) {\n        result.sourceCodeLocation = node.sourceCodeLocation;\n    }\n    return result;\n}\nfunction cloneChildren(childs) {\n    const children = childs.map((child) => cloneNode(child, true));\n    for (let i = 1; i < children.length; i++) {\n        children[i].prev = children[i - 1];\n        children[i - 1].next = children[i];\n    }\n    return children;\n}\n"],"x_google_ignoreList":[0],"mappings":"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"}

package/dist/node_modules/entities/lib/esm/decode.js

@@ -0,0 +1,363 @@
+import decode_data_html_default from "./generated/decode-data-html.js";
+import decode_data_xml_default from "./generated/decode-data-xml.js";
+import { fromCodePoint, replaceCodePoint } from "./decode_codepoint.js";
+//#region ../../node_modules/entities/lib/esm/decode.js
+var CharCodes;
+(function(CharCodes) {
+	CharCodes[CharCodes["NUM"] = 35] = "NUM";
+	CharCodes[CharCodes["SEMI"] = 59] = "SEMI";
+	CharCodes[CharCodes["EQUALS"] = 61] = "EQUALS";
+	CharCodes[CharCodes["ZERO"] = 48] = "ZERO";
+	CharCodes[CharCodes["NINE"] = 57] = "NINE";
+	CharCodes[CharCodes["LOWER_A"] = 97] = "LOWER_A";
+	CharCodes[CharCodes["LOWER_F"] = 102] = "LOWER_F";
+	CharCodes[CharCodes["LOWER_X"] = 120] = "LOWER_X";
+	CharCodes[CharCodes["LOWER_Z"] = 122] = "LOWER_Z";
+	CharCodes[CharCodes["UPPER_A"] = 65] = "UPPER_A";
+	CharCodes[CharCodes["UPPER_F"] = 70] = "UPPER_F";
+	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 */
+const 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 || (BinTrieFlags = {}));
+function isNumber(code) {
+	return code >= CharCodes.ZERO && code <= CharCodes.NINE;
+}
+function isHexadecimalCharacter(code) {
+	return code >= CharCodes.UPPER_A && code <= CharCodes.UPPER_F || code >= CharCodes.LOWER_A && code <= CharCodes.LOWER_F;
+}
+function isAsciiAlphaNumeric(code) {
+	return code >= CharCodes.UPPER_A && code <= CharCodes.UPPER_Z || code >= CharCodes.LOWER_A && code <= CharCodes.LOWER_Z || isNumber(code);
+}
+/**
+* Checks if the given character is a valid end character for an entity in an attribute.
+*
+* Attribute values that aren't terminated properly aren't parsed, and shouldn't lead to a parser error.
+* See the example in https://html.spec.whatwg.org/multipage/parsing.html#named-character-reference-state
+*/
+function isEntityInAttributeInvalidEnd(code) {
+	return code === CharCodes.EQUALS || isAsciiAlphaNumeric(code);
+}
+var EntityDecoderState;
+(function(EntityDecoderState) {
+	EntityDecoderState[EntityDecoderState["EntityStart"] = 0] = "EntityStart";
+	EntityDecoderState[EntityDecoderState["NumericStart"] = 1] = "NumericStart";
+	EntityDecoderState[EntityDecoderState["NumericDecimal"] = 2] = "NumericDecimal";
+	EntityDecoderState[EntityDecoderState["NumericHex"] = 3] = "NumericHex";
+	EntityDecoderState[EntityDecoderState["NamedEntity"] = 4] = "NamedEntity";
+})(EntityDecoderState || (EntityDecoderState = {}));
+var DecodingMode;
+(function(DecodingMode) {
+	/** Entities in text nodes that can end with any character. */
+	DecodingMode[DecodingMode["Legacy"] = 0] = "Legacy";
+	/** Only allow entities terminated with a semicolon. */
+	DecodingMode[DecodingMode["Strict"] = 1] = "Strict";
+	/** Entities in attributes have limitations on ending characters. */
+	DecodingMode[DecodingMode["Attribute"] = 2] = "Attribute";
+})(DecodingMode || (DecodingMode = {}));
+/**
+* Token decoder with support of writing partial entities.
+*/
+var EntityDecoder = class {
+	constructor(decodeTree, emitCodePoint, errors) {
+		this.decodeTree = decodeTree;
+		this.emitCodePoint = emitCodePoint;
+		this.errors = errors;
+		/** The current state of the decoder. */
+		this.state = EntityDecoderState.EntityStart;
+		/** Characters that were consumed while parsing an entity. */
+		this.consumed = 1;
+		/**
+		* The result of the entity.
+		*
+		* Either the result index of a numeric entity, or the codepoint of a
+		* numeric entity.
+		*/
+		this.result = 0;
+		/** The current index in the decode tree. */
+		this.treeIndex = 0;
+		/** The number of characters that were consumed in excess. */
+		this.excess = 1;
+		/** The mode in which the decoder is operating. */
+		this.decodeMode = DecodingMode.Strict;
+	}
+	/** Resets the instance to make it reusable. */
+	startEntity(decodeMode) {
+		this.decodeMode = decodeMode;
+		this.state = EntityDecoderState.EntityStart;
+		this.result = 0;
+		this.treeIndex = 0;
+		this.excess = 1;
+		this.consumed = 1;
+	}
+	/**
+	* 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.
+	*
+	* 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 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.
+	*/
+	write(str, offset) {
+		switch (this.state) {
+			case EntityDecoderState.EntityStart:
+				if (str.charCodeAt(offset) === CharCodes.NUM) {
+					this.state = EntityDecoderState.NumericStart;
+					this.consumed += 1;
+					return this.stateNumericStart(str, offset + 1);
+				}
+				this.state = EntityDecoderState.NamedEntity;
+				return this.stateNamedEntity(str, offset);
+			case EntityDecoderState.NumericStart: return this.stateNumericStart(str, offset);
+			case EntityDecoderState.NumericDecimal: return this.stateNumericDecimal(str, offset);
+			case EntityDecoderState.NumericHex: return this.stateNumericHex(str, offset);
+			case EntityDecoderState.NamedEntity: return this.stateNamedEntity(str, 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 offset The current offset.
+	* @returns The number of characters that were consumed, or -1 if the entity is incomplete.
+	*/
+	stateNumericStart(str, offset) {
+		if (offset >= str.length) return -1;
+		if ((str.charCodeAt(offset) | TO_LOWER_BIT) === CharCodes.LOWER_X) {
+			this.state = EntityDecoderState.NumericHex;
+			this.consumed += 1;
+			return this.stateNumericHex(str, offset + 1);
+		}
+		this.state = EntityDecoderState.NumericDecimal;
+		return this.stateNumericDecimal(str, offset);
+	}
+	addToNumericResult(str, start, end, base) {
+		if (start !== end) {
+			const digitCount = end - start;
+			this.result = this.result * Math.pow(base, digitCount) + parseInt(str.substr(start, digitCount), base);
+			this.consumed += digitCount;
+		}
+	}
+	/**
+	* 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 offset The current offset.
+	* @returns The number of characters that were consumed, or -1 if the entity is incomplete.
+	*/
+	stateNumericHex(str, offset) {
+		const startIdx = offset;
+		while (offset < str.length) {
+			const char = str.charCodeAt(offset);
+			if (isNumber(char) || isHexadecimalCharacter(char)) offset += 1;
+			else {
+				this.addToNumericResult(str, startIdx, offset, 16);
+				return this.emitNumericEntity(char, 3);
+			}
+		}
+		this.addToNumericResult(str, startIdx, offset, 16);
+		return -1;
+	}
+	/**
+	* 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 offset The current offset.
+	* @returns The number of characters that were consumed, or -1 if the entity is incomplete.
+	*/
+	stateNumericDecimal(str, offset) {
+		const startIdx = offset;
+		while (offset < str.length) {
+			const char = str.charCodeAt(offset);
+			if (isNumber(char)) offset += 1;
+			else {
+				this.addToNumericResult(str, startIdx, offset, 10);
+				return this.emitNumericEntity(char, 2);
+			}
+		}
+		this.addToNumericResult(str, startIdx, offset, 10);
+		return -1;
+	}
+	/**
+	* Validate and emit a numeric entity.
+	*
+	* Implements the logic from the `Hexademical character reference start
+	* state` and `Numeric character reference end state` in the HTML spec.
+	*
+	* @param lastCp The last code point of the entity. Used to see if the
+	*               entity was terminated with a semicolon.
+	* @param expectedLength The minimum number of characters that should be
+	*                       consumed. Used to validate that at least one digit
+	*                       was consumed.
+	* @returns The number of characters that were consumed.
+	*/
+	emitNumericEntity(lastCp, expectedLength) {
+		var _a;
+		if (this.consumed <= expectedLength) {
+			(_a = this.errors) === null || _a === void 0 || _a.absenceOfDigitsInNumericCharacterReference(this.consumed);
+			return 0;
+		}
+		if (lastCp === CharCodes.SEMI) this.consumed += 1;
+		else if (this.decodeMode === DecodingMode.Strict) return 0;
+		this.emitCodePoint(replaceCodePoint(this.result), this.consumed);
+		if (this.errors) {
+			if (lastCp !== CharCodes.SEMI) this.errors.missingSemicolonAfterCharacterReference();
+			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 offset The current offset.
+	* @returns The number of characters that were consumed, or -1 if the entity is incomplete.
+	*/
+	stateNamedEntity(str, offset) {
+		const { decodeTree } = this;
+		let current = decodeTree[this.treeIndex];
+		let valueLength = (current & BinTrieFlags.VALUE_LENGTH) >> 14;
+		for (; offset < str.length; offset++, this.excess++) {
+			const char = str.charCodeAt(offset);
+			this.treeIndex = determineBranch(decodeTree, current, this.treeIndex + Math.max(1, valueLength), char);
+			if (this.treeIndex < 0) return this.result === 0 || this.decodeMode === DecodingMode.Attribute && (valueLength === 0 || isEntityInAttributeInvalidEnd(char)) ? 0 : this.emitNotTerminatedNamedEntity();
+			current = decodeTree[this.treeIndex];
+			valueLength = (current & BinTrieFlags.VALUE_LENGTH) >> 14;
+			if (valueLength !== 0) {
+				if (char === CharCodes.SEMI) return this.emitNamedEntityData(this.treeIndex, valueLength, this.consumed + this.excess);
+				if (this.decodeMode !== DecodingMode.Strict) {
+					this.result = this.treeIndex;
+					this.consumed += this.excess;
+					this.excess = 0;
+				}
+			}
+		}
+		return -1;
+	}
+	/**
+	* Emit a named entity that was not terminated with a semicolon.
+	*
+	* @returns The number of characters consumed.
+	*/
+	emitNotTerminatedNamedEntity() {
+		var _a;
+		const { result, decodeTree } = this;
+		const valueLength = (decodeTree[result] & BinTrieFlags.VALUE_LENGTH) >> 14;
+		this.emitNamedEntityData(result, valueLength, this.consumed);
+		(_a = this.errors) === null || _a === void 0 || _a.missingSemicolonAfterCharacterReference();
+		return this.consumed;
+	}
+	/**
+	* Emit a named entity.
+	*
+	* @param result The index of the entity in the decode tree.
+	* @param valueLength The number of bytes in the entity.
+	* @param consumed The number of characters consumed.
+	*
+	* @returns The number of characters consumed.
+	*/
+	emitNamedEntityData(result, valueLength, consumed) {
+		const { decodeTree } = this;
+		this.emitCodePoint(valueLength === 1 ? decodeTree[result] & ~BinTrieFlags.VALUE_LENGTH : decodeTree[result + 1], consumed);
+		if (valueLength === 3) this.emitCodePoint(decodeTree[result + 2], consumed);
+		return consumed;
+	}
+	/**
+	* Signal to the parser that the end of the input was reached.
+	*
+	* Remaining data will be emitted and relevant errors will be produced.
+	*
+	* @returns The number of characters consumed.
+	*/
+	end() {
+		var _a;
+		switch (this.state) {
+			case EntityDecoderState.NamedEntity: return this.result !== 0 && (this.decodeMode !== DecodingMode.Attribute || this.result === this.treeIndex) ? this.emitNotTerminatedNamedEntity() : 0;
+			case EntityDecoderState.NumericDecimal: return this.emitNumericEntity(0, 2);
+			case EntityDecoderState.NumericHex: return this.emitNumericEntity(0, 3);
+			case EntityDecoderState.NumericStart:
+				(_a = this.errors) === null || _a === void 0 || _a.absenceOfDigitsInNumericCharacterReference(this.consumed);
+				return 0;
+			case EntityDecoderState.EntityStart: return 0;
+		}
+	}
+};
+/**
+* Creates a function that decodes entities in a string.
+*
+* @param decodeTree The decode tree.
+* @returns A function that decodes entities in a string.
+*/
+function getDecoder(decodeTree) {
+	let ret = "";
+	const decoder = new EntityDecoder(decodeTree, (str) => ret += fromCodePoint(str));
+	return function decodeWithTrie(str, decodeMode) {
+		let lastIndex = 0;
+		let offset = 0;
+		while ((offset = str.indexOf("&", offset)) >= 0) {
+			ret += str.slice(lastIndex, offset);
+			decoder.startEntity(decodeMode);
+			const len = decoder.write(str, offset + 1);
+			if (len < 0) {
+				lastIndex = offset + decoder.end();
+				break;
+			}
+			lastIndex = offset + len;
+			offset = len === 0 ? lastIndex + 1 : lastIndex;
+		}
+		const result = ret + str.slice(lastIndex);
+		ret = "";
+		return result;
+	};
+}
+/**
+* Determines the branch of the current node that is taken given the current
+* character. This function is used to traverse the trie.
+*
+* @param decodeTree The trie.
+* @param current The current node.
+* @param nodeIdx The index right after the current node and its value.
+* @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) {
+	const branchCount = (current & BinTrieFlags.BRANCH_LENGTH) >> 7;
+	const jumpOffset = current & BinTrieFlags.JUMP_TABLE;
+	if (branchCount === 0) return jumpOffset !== 0 && char === jumpOffset ? nodeIdx : -1;
+	if (jumpOffset) {
+		const value = char - jumpOffset;
+		return value < 0 || value >= branchCount ? -1 : decodeTree[nodeIdx + value] - 1;
+	}
+	let lo = nodeIdx;
+	let hi = lo + branchCount - 1;
+	while (lo <= hi) {
+		const mid = lo + hi >>> 1;
+		const midVal = decodeTree[mid];
+		if (midVal < char) lo = mid + 1;
+		else if (midVal > char) hi = mid - 1;
+		else return decodeTree[mid + branchCount];
+	}
+	return -1;
+}
+getDecoder(decode_data_html_default);
+getDecoder(decode_data_xml_default);
+//#endregion
+export { BinTrieFlags, DecodingMode, EntityDecoder, determineBranch, fromCodePoint, decode_data_html_default as htmlDecodeTree, replaceCodePoint, decode_data_xml_default as xmlDecodeTree };
+
+//# sourceMappingURL=decode.js.map

package/dist/node_modules/entities/lib/esm/decode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode.js","names":["htmlDecodeTree","xmlDecodeTree"],"sources":["../../../../../../../node_modules/entities/lib/esm/decode.js"],"sourcesContent":["import htmlDecodeTree from \"./generated/decode-data-html.js\";\nimport xmlDecodeTree from \"./generated/decode-data-xml.js\";\nimport decodeCodePoint, { replaceCodePoint, fromCodePoint, } from \"./decode_codepoint.js\";\n// Re-export for use by eg. htmlparser2\nexport { htmlDecodeTree, xmlDecodeTree, decodeCodePoint };\nexport { replaceCodePoint, fromCodePoint } from \"./decode_codepoint.js\";\nvar CharCodes;\n(function (CharCodes) {\n    CharCodes[CharCodes[\"NUM\"] = 35] = \"NUM\";\n    CharCodes[CharCodes[\"SEMI\"] = 59] = \"SEMI\";\n    CharCodes[CharCodes[\"EQUALS\"] = 61] = \"EQUALS\";\n    CharCodes[CharCodes[\"ZERO\"] = 48] = \"ZERO\";\n    CharCodes[CharCodes[\"NINE\"] = 57] = \"NINE\";\n    CharCodes[CharCodes[\"LOWER_A\"] = 97] = \"LOWER_A\";\n    CharCodes[CharCodes[\"LOWER_F\"] = 102] = \"LOWER_F\";\n    CharCodes[CharCodes[\"LOWER_X\"] = 120] = \"LOWER_X\";\n    CharCodes[CharCodes[\"LOWER_Z\"] = 122] = \"LOWER_Z\";\n    CharCodes[CharCodes[\"UPPER_A\"] = 65] = \"UPPER_A\";\n    CharCodes[CharCodes[\"UPPER_F\"] = 70] = \"UPPER_F\";\n    CharCodes[CharCodes[\"UPPER_Z\"] = 90] = \"UPPER_Z\";\n})(CharCodes || (CharCodes = {}));\n/** Bit that needs to be set to convert an upper case ASCII character to lower case */\nconst TO_LOWER_BIT = 0b100000;\nexport var BinTrieFlags;\n(function (BinTrieFlags) {\n    BinTrieFlags[BinTrieFlags[\"VALUE_LENGTH\"] = 49152] = \"VALUE_LENGTH\";\n    BinTrieFlags[BinTrieFlags[\"BRANCH_LENGTH\"] = 16256] = \"BRANCH_LENGTH\";\n    BinTrieFlags[BinTrieFlags[\"JUMP_TABLE\"] = 127] = \"JUMP_TABLE\";\n})(BinTrieFlags || (BinTrieFlags = {}));\nfunction isNumber(code) {\n    return code >= CharCodes.ZERO && code <= CharCodes.NINE;\n}\nfunction isHexadecimalCharacter(code) {\n    return ((code >= CharCodes.UPPER_A && code <= CharCodes.UPPER_F) ||\n        (code >= CharCodes.LOWER_A && code <= CharCodes.LOWER_F));\n}\nfunction isAsciiAlphaNumeric(code) {\n    return ((code >= CharCodes.UPPER_A && code <= CharCodes.UPPER_Z) ||\n        (code >= CharCodes.LOWER_A && code <= CharCodes.LOWER_Z) ||\n        isNumber(code));\n}\n/**\n * Checks if the given character is a valid end character for an entity in an attribute.\n *\n * Attribute values that aren't terminated properly aren't parsed, and shouldn't lead to a parser error.\n * See the example in https://html.spec.whatwg.org/multipage/parsing.html#named-character-reference-state\n */\nfunction isEntityInAttributeInvalidEnd(code) {\n    return code === CharCodes.EQUALS || isAsciiAlphaNumeric(code);\n}\nvar EntityDecoderState;\n(function (EntityDecoderState) {\n    EntityDecoderState[EntityDecoderState[\"EntityStart\"] = 0] = \"EntityStart\";\n    EntityDecoderState[EntityDecoderState[\"NumericStart\"] = 1] = \"NumericStart\";\n    EntityDecoderState[EntityDecoderState[\"NumericDecimal\"] = 2] = \"NumericDecimal\";\n    EntityDecoderState[EntityDecoderState[\"NumericHex\"] = 3] = \"NumericHex\";\n    EntityDecoderState[EntityDecoderState[\"NamedEntity\"] = 4] = \"NamedEntity\";\n})(EntityDecoderState || (EntityDecoderState = {}));\nexport var DecodingMode;\n(function (DecodingMode) {\n    /** Entities in text nodes that can end with any character. */\n    DecodingMode[DecodingMode[\"Legacy\"] = 0] = \"Legacy\";\n    /** Only allow entities terminated with a semicolon. */\n    DecodingMode[DecodingMode[\"Strict\"] = 1] = \"Strict\";\n    /** Entities in attributes have limitations on ending characters. */\n    DecodingMode[DecodingMode[\"Attribute\"] = 2] = \"Attribute\";\n})(DecodingMode || (DecodingMode = {}));\n/**\n * Token decoder with support of writing partial entities.\n */\nexport class EntityDecoder {\n    constructor(\n    /** The tree used to decode entities. */\n    decodeTree, \n    /**\n     * The function that is called when a codepoint is decoded.\n     *\n     * For multi-byte named entities, this will be called multiple times,\n     * with the second codepoint, and the same `consumed` value.\n     *\n     * @param codepoint The decoded codepoint.\n     * @param consumed The number of bytes consumed by the decoder.\n     */\n    emitCodePoint, \n    /** An object that is used to produce errors. */\n    errors) {\n        this.decodeTree = decodeTree;\n        this.emitCodePoint = emitCodePoint;\n        this.errors = errors;\n        /** The current state of the decoder. */\n        this.state = EntityDecoderState.EntityStart;\n        /** Characters that were consumed while parsing an entity. */\n        this.consumed = 1;\n        /**\n         * The result of the entity.\n         *\n         * Either the result index of a numeric entity, or the codepoint of a\n         * numeric entity.\n         */\n        this.result = 0;\n        /** The current index in the decode tree. */\n        this.treeIndex = 0;\n        /** The number of characters that were consumed in excess. */\n        this.excess = 1;\n        /** The mode in which the decoder is operating. */\n        this.decodeMode = DecodingMode.Strict;\n    }\n    /** Resets the instance to make it reusable. */\n    startEntity(decodeMode) {\n        this.decodeMode = decodeMode;\n        this.state = EntityDecoderState.EntityStart;\n        this.result = 0;\n        this.treeIndex = 0;\n        this.excess = 1;\n        this.consumed = 1;\n    }\n    /**\n     * Write an entity to the decoder. This can be called multiple times with partial entities.\n     * If the entity is incomplete, the decoder will return -1.\n     *\n     * Mirrors the implementation of `getDecoder`, but with the ability to stop decoding if the\n     * entity is incomplete, and resume when the next string is written.\n     *\n     * @param string The string containing the entity (or a continuation of the entity).\n     * @param offset The offset at which the entity begins. Should be 0 if this is not the first call.\n     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.\n     */\n    write(str, offset) {\n        switch (this.state) {\n            case EntityDecoderState.EntityStart: {\n                if (str.charCodeAt(offset) === CharCodes.NUM) {\n                    this.state = EntityDecoderState.NumericStart;\n                    this.consumed += 1;\n                    return this.stateNumericStart(str, offset + 1);\n                }\n                this.state = EntityDecoderState.NamedEntity;\n                return this.stateNamedEntity(str, offset);\n            }\n            case EntityDecoderState.NumericStart: {\n                return this.stateNumericStart(str, offset);\n            }\n            case EntityDecoderState.NumericDecimal: {\n                return this.stateNumericDecimal(str, offset);\n            }\n            case EntityDecoderState.NumericHex: {\n                return this.stateNumericHex(str, offset);\n            }\n            case EntityDecoderState.NamedEntity: {\n                return this.stateNamedEntity(str, offset);\n            }\n        }\n    }\n    /**\n     * Switches between the numeric decimal and hexadecimal states.\n     *\n     * Equivalent to the `Numeric character reference state` in the HTML spec.\n     *\n     * @param str The string containing the entity (or a continuation of the entity).\n     * @param offset The current offset.\n     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.\n     */\n    stateNumericStart(str, offset) {\n        if (offset >= str.length) {\n            return -1;\n        }\n        if ((str.charCodeAt(offset) | TO_LOWER_BIT) === CharCodes.LOWER_X) {\n            this.state = EntityDecoderState.NumericHex;\n            this.consumed += 1;\n            return this.stateNumericHex(str, offset + 1);\n        }\n        this.state = EntityDecoderState.NumericDecimal;\n        return this.stateNumericDecimal(str, offset);\n    }\n    addToNumericResult(str, start, end, base) {\n        if (start !== end) {\n            const digitCount = end - start;\n            this.result =\n                this.result * Math.pow(base, digitCount) +\n                    parseInt(str.substr(start, digitCount), base);\n            this.consumed += digitCount;\n        }\n    }\n    /**\n     * Parses a hexadecimal numeric entity.\n     *\n     * Equivalent to the `Hexademical character reference state` in the HTML spec.\n     *\n     * @param str The string containing the entity (or a continuation of the entity).\n     * @param offset The current offset.\n     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.\n     */\n    stateNumericHex(str, offset) {\n        const startIdx = offset;\n        while (offset < str.length) {\n            const char = str.charCodeAt(offset);\n            if (isNumber(char) || isHexadecimalCharacter(char)) {\n                offset += 1;\n            }\n            else {\n                this.addToNumericResult(str, startIdx, offset, 16);\n                return this.emitNumericEntity(char, 3);\n            }\n        }\n        this.addToNumericResult(str, startIdx, offset, 16);\n        return -1;\n    }\n    /**\n     * Parses a decimal numeric entity.\n     *\n     * Equivalent to the `Decimal character reference state` in the HTML spec.\n     *\n     * @param str The string containing the entity (or a continuation of the entity).\n     * @param offset The current offset.\n     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.\n     */\n    stateNumericDecimal(str, offset) {\n        const startIdx = offset;\n        while (offset < str.length) {\n            const char = str.charCodeAt(offset);\n            if (isNumber(char)) {\n                offset += 1;\n            }\n            else {\n                this.addToNumericResult(str, startIdx, offset, 10);\n                return this.emitNumericEntity(char, 2);\n            }\n        }\n        this.addToNumericResult(str, startIdx, offset, 10);\n        return -1;\n    }\n    /**\n     * Validate and emit a numeric entity.\n     *\n     * Implements the logic from the `Hexademical character reference start\n     * state` and `Numeric character reference end state` in the HTML spec.\n     *\n     * @param lastCp The last code point of the entity. Used to see if the\n     *               entity was terminated with a semicolon.\n     * @param expectedLength The minimum number of characters that should be\n     *                       consumed. Used to validate that at least one digit\n     *                       was consumed.\n     * @returns The number of characters that were consumed.\n     */\n    emitNumericEntity(lastCp, expectedLength) {\n        var _a;\n        // Ensure we consumed at least one digit.\n        if (this.consumed <= expectedLength) {\n            (_a = this.errors) === null || _a === void 0 ? void 0 : _a.absenceOfDigitsInNumericCharacterReference(this.consumed);\n            return 0;\n        }\n        // Figure out if this is a legit end of the entity\n        if (lastCp === CharCodes.SEMI) {\n            this.consumed += 1;\n        }\n        else if (this.decodeMode === DecodingMode.Strict) {\n            return 0;\n        }\n        this.emitCodePoint(replaceCodePoint(this.result), this.consumed);\n        if (this.errors) {\n            if (lastCp !== CharCodes.SEMI) {\n                this.errors.missingSemicolonAfterCharacterReference();\n            }\n            this.errors.validateNumericCharacterReference(this.result);\n        }\n        return this.consumed;\n    }\n    /**\n     * Parses a named entity.\n     *\n     * Equivalent to the `Named character reference state` in the HTML spec.\n     *\n     * @param str The string containing the entity (or a continuation of the entity).\n     * @param offset The current offset.\n     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.\n     */\n    stateNamedEntity(str, offset) {\n        const { decodeTree } = this;\n        let current = decodeTree[this.treeIndex];\n        // The mask is the number of bytes of the value, including the current byte.\n        let valueLength = (current & BinTrieFlags.VALUE_LENGTH) >> 14;\n        for (; offset < str.length; offset++, this.excess++) {\n            const char = str.charCodeAt(offset);\n            this.treeIndex = determineBranch(decodeTree, current, this.treeIndex + Math.max(1, valueLength), char);\n            if (this.treeIndex < 0) {\n                return this.result === 0 ||\n                    // If we are parsing an attribute\n                    (this.decodeMode === DecodingMode.Attribute &&\n                        // We shouldn't have consumed any characters after the entity,\n                        (valueLength === 0 ||\n                            // And there should be no invalid characters.\n                            isEntityInAttributeInvalidEnd(char)))\n                    ? 0\n                    : this.emitNotTerminatedNamedEntity();\n            }\n            current = decodeTree[this.treeIndex];\n            valueLength = (current & BinTrieFlags.VALUE_LENGTH) >> 14;\n            // If the branch is a value, store it and continue\n            if (valueLength !== 0) {\n                // If the entity is terminated by a semicolon, we are done.\n                if (char === CharCodes.SEMI) {\n                    return this.emitNamedEntityData(this.treeIndex, valueLength, this.consumed + this.excess);\n                }\n                // If we encounter a non-terminated (legacy) entity while parsing strictly, then ignore it.\n                if (this.decodeMode !== DecodingMode.Strict) {\n                    this.result = this.treeIndex;\n                    this.consumed += this.excess;\n                    this.excess = 0;\n                }\n            }\n        }\n        return -1;\n    }\n    /**\n     * Emit a named entity that was not terminated with a semicolon.\n     *\n     * @returns The number of characters consumed.\n     */\n    emitNotTerminatedNamedEntity() {\n        var _a;\n        const { result, decodeTree } = this;\n        const valueLength = (decodeTree[result] & BinTrieFlags.VALUE_LENGTH) >> 14;\n        this.emitNamedEntityData(result, valueLength, this.consumed);\n        (_a = this.errors) === null || _a === void 0 ? void 0 : _a.missingSemicolonAfterCharacterReference();\n        return this.consumed;\n    }\n    /**\n     * Emit a named entity.\n     *\n     * @param result The index of the entity in the decode tree.\n     * @param valueLength The number of bytes in the entity.\n     * @param consumed The number of characters consumed.\n     *\n     * @returns The number of characters consumed.\n     */\n    emitNamedEntityData(result, valueLength, consumed) {\n        const { decodeTree } = this;\n        this.emitCodePoint(valueLength === 1\n            ? decodeTree[result] & ~BinTrieFlags.VALUE_LENGTH\n            : decodeTree[result + 1], consumed);\n        if (valueLength === 3) {\n            // For multi-byte values, we need to emit the second byte.\n            this.emitCodePoint(decodeTree[result + 2], consumed);\n        }\n        return consumed;\n    }\n    /**\n     * Signal to the parser that the end of the input was reached.\n     *\n     * Remaining data will be emitted and relevant errors will be produced.\n     *\n     * @returns The number of characters consumed.\n     */\n    end() {\n        var _a;\n        switch (this.state) {\n            case EntityDecoderState.NamedEntity: {\n                // Emit a named entity if we have one.\n                return this.result !== 0 &&\n                    (this.decodeMode !== DecodingMode.Attribute ||\n                        this.result === this.treeIndex)\n                    ? this.emitNotTerminatedNamedEntity()\n                    : 0;\n            }\n            // Otherwise, emit a numeric entity if we have one.\n            case EntityDecoderState.NumericDecimal: {\n                return this.emitNumericEntity(0, 2);\n            }\n            case EntityDecoderState.NumericHex: {\n                return this.emitNumericEntity(0, 3);\n            }\n            case EntityDecoderState.NumericStart: {\n                (_a = this.errors) === null || _a === void 0 ? void 0 : _a.absenceOfDigitsInNumericCharacterReference(this.consumed);\n                return 0;\n            }\n            case EntityDecoderState.EntityStart: {\n                // Return 0 if we have no entity.\n                return 0;\n            }\n        }\n    }\n}\n/**\n * Creates a function that decodes entities in a string.\n *\n * @param decodeTree The decode tree.\n * @returns A function that decodes entities in a string.\n */\nfunction getDecoder(decodeTree) {\n    let ret = \"\";\n    const decoder = new EntityDecoder(decodeTree, (str) => (ret += fromCodePoint(str)));\n    return function decodeWithTrie(str, decodeMode) {\n        let lastIndex = 0;\n        let offset = 0;\n        while ((offset = str.indexOf(\"&\", offset)) >= 0) {\n            ret += str.slice(lastIndex, offset);\n            decoder.startEntity(decodeMode);\n            const len = decoder.write(str, \n            // Skip the \"&\"\n            offset + 1);\n            if (len < 0) {\n                lastIndex = offset + decoder.end();\n                break;\n            }\n            lastIndex = offset + len;\n            // If `len` is 0, skip the current `&` and continue.\n            offset = len === 0 ? lastIndex + 1 : lastIndex;\n        }\n        const result = ret + str.slice(lastIndex);\n        // Make sure we don't keep a reference to the final string.\n        ret = \"\";\n        return result;\n    };\n}\n/**\n * Determines the branch of the current node that is taken given the current\n * character. This function is used to traverse the trie.\n *\n * @param decodeTree The trie.\n * @param current The current node.\n * @param nodeIdx The index right after the current node and its value.\n * @param char The current character.\n * @returns The index of the next node, or -1 if no branch is taken.\n */\nexport function determineBranch(decodeTree, current, nodeIdx, char) {\n    const branchCount = (current & BinTrieFlags.BRANCH_LENGTH) >> 7;\n    const jumpOffset = current & BinTrieFlags.JUMP_TABLE;\n    // Case 1: Single branch encoded in jump offset\n    if (branchCount === 0) {\n        return jumpOffset !== 0 && char === jumpOffset ? nodeIdx : -1;\n    }\n    // Case 2: Multiple branches encoded in jump table\n    if (jumpOffset) {\n        const value = char - jumpOffset;\n        return value < 0 || value >= branchCount\n            ? -1\n            : decodeTree[nodeIdx + value] - 1;\n    }\n    // Case 3: Multiple branches encoded in dictionary\n    // Binary search for the character.\n    let lo = nodeIdx;\n    let hi = lo + branchCount - 1;\n    while (lo <= hi) {\n        const mid = (lo + hi) >>> 1;\n        const midVal = decodeTree[mid];\n        if (midVal < char) {\n            lo = mid + 1;\n        }\n        else if (midVal > char) {\n            hi = mid - 1;\n        }\n        else {\n            return decodeTree[mid + branchCount];\n        }\n    }\n    return -1;\n}\nconst htmlDecoder = getDecoder(htmlDecodeTree);\nconst xmlDecoder = getDecoder(xmlDecodeTree);\n/**\n * Decodes an HTML string.\n *\n * @param str The string to decode.\n * @param mode The decoding mode.\n * @returns The decoded string.\n */\nexport function decodeHTML(str, mode = DecodingMode.Legacy) {\n    return htmlDecoder(str, mode);\n}\n/**\n * Decodes an HTML string in an attribute.\n *\n * @param str The string to decode.\n * @returns The decoded string.\n */\nexport function decodeHTMLAttribute(str) {\n    return htmlDecoder(str, DecodingMode.Attribute);\n}\n/**\n * Decodes an HTML string, requiring all entities to be terminated by a semicolon.\n *\n * @param str The string to decode.\n * @returns The decoded string.\n */\nexport function decodeHTMLStrict(str) {\n    return htmlDecoder(str, DecodingMode.Strict);\n}\n/**\n * Decodes an XML string, requiring all entities to be terminated by a semicolon.\n *\n * @param str The string to decode.\n * @returns The decoded string.\n */\nexport function decodeXML(str) {\n    return xmlDecoder(str, DecodingMode.Strict);\n}\n//# sourceMappingURL=decode.js.map"],"x_google_ignoreList":[0],"mappings":"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"}

package/dist/node_modules/entities/lib/esm/decode_codepoint.js

@@ -0,0 +1,59 @@
+//#region ../../node_modules/entities/lib/esm/decode_codepoint.js
+var _a;
+const decodeMap = /* @__PURE__ */ new Map([
+	[0, 65533],
+	[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]
+]);
+/**
+* Polyfill for `String.fromCodePoint`. It is used to create a string from a Unicode code point.
+*/
+const fromCodePoint = (_a = String.fromCodePoint) !== null && _a !== void 0 ? _a : function(codePoint) {
+	let output = "";
+	if (codePoint > 65535) {
+		codePoint -= 65536;
+		output += String.fromCharCode(codePoint >>> 10 & 1023 | 55296);
+		codePoint = 56320 | codePoint & 1023;
+	}
+	output += String.fromCharCode(codePoint);
+	return output;
+};
+/**
+* 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.
+*/
+function replaceCodePoint(codePoint) {
+	var _a;
+	if (codePoint >= 55296 && codePoint <= 57343 || codePoint > 1114111) return 65533;
+	return (_a = decodeMap.get(codePoint)) !== null && _a !== void 0 ? _a : codePoint;
+}
+//#endregion
+export { fromCodePoint, replaceCodePoint };
+
+//# sourceMappingURL=decode_codepoint.js.map

package/dist/node_modules/entities/lib/esm/decode_codepoint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode_codepoint.js","names":[],"sources":["../../../../../../../node_modules/entities/lib/esm/decode_codepoint.js"],"sourcesContent":["// Adapted from https://github.com/mathiasbynens/he/blob/36afe179392226cf1b6ccdb16ebbb7a5a844d93a/src/he.js#L106-L134\nvar _a;\nconst decodeMap = new Map([\n    [0, 65533],\n    // C1 Unicode control character reference replacements\n    [128, 8364],\n    [130, 8218],\n    [131, 402],\n    [132, 8222],\n    [133, 8230],\n    [134, 8224],\n    [135, 8225],\n    [136, 710],\n    [137, 8240],\n    [138, 352],\n    [139, 8249],\n    [140, 338],\n    [142, 381],\n    [145, 8216],\n    [146, 8217],\n    [147, 8220],\n    [148, 8221],\n    [149, 8226],\n    [150, 8211],\n    [151, 8212],\n    [152, 732],\n    [153, 8482],\n    [154, 353],\n    [155, 8250],\n    [156, 339],\n    [158, 382],\n    [159, 376],\n]);\n/**\n * Polyfill for `String.fromCodePoint`. It is used to create a string from a Unicode code point.\n */\nexport const fromCodePoint = \n// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition, node/no-unsupported-features/es-builtins\n(_a = String.fromCodePoint) !== null && _a !== void 0 ? _a : function (codePoint) {\n    let output = \"\";\n    if (codePoint > 0xffff) {\n        codePoint -= 0x10000;\n        output += String.fromCharCode(((codePoint >>> 10) & 0x3ff) | 0xd800);\n        codePoint = 0xdc00 | (codePoint & 0x3ff);\n    }\n    output += String.fromCharCode(codePoint);\n    return output;\n};\n/**\n * Replace the given code point with a replacement character if it is a\n * surrogate or is outside the valid range. Otherwise return the code\n * point unchanged.\n */\nexport function replaceCodePoint(codePoint) {\n    var _a;\n    if ((codePoint >= 0xd800 && codePoint <= 0xdfff) || codePoint > 0x10ffff) {\n        return 0xfffd;\n    }\n    return (_a = decodeMap.get(codePoint)) !== null && _a !== void 0 ? _a : codePoint;\n}\n/**\n * Replace the code point if relevant, then convert it to a string.\n *\n * @deprecated Use `fromCodePoint(replaceCodePoint(codePoint))` instead.\n * @param codePoint The code point to decode.\n * @returns The decoded code point.\n */\nexport default function decodeCodePoint(codePoint) {\n    return fromCodePoint(replaceCodePoint(codePoint));\n}\n//# sourceMappingURL=decode_codepoint.js.map"],"x_google_ignoreList":[0],"mappings":";AACA,IAAI;AACJ,MAAM,4BAAY,IAAI,IAAI;CACtB,CAAC,GAAG,KAAK;CAET,CAAC,KAAK,IAAI;CACV,CAAC,KAAK,IAAI;CACV,CAAC,KAAK,GAAG;CACT,CAAC,KAAK,IAAI;CACV,CAAC,KAAK,IAAI;CACV,CAAC,KAAK,IAAI;CACV,CAAC,KAAK,IAAI;CACV,CAAC,KAAK,GAAG;CACT,CAAC,KAAK,IAAI;CACV,CAAC,KAAK,GAAG;CACT,CAAC,KAAK,IAAI;CACV,CAAC,KAAK,GAAG;CACT,CAAC,KAAK,GAAG;CACT,CAAC,KAAK,IAAI;CACV,CAAC,KAAK,IAAI;CACV,CAAC,KAAK,IAAI;CACV,CAAC,KAAK,IAAI;CACV,CAAC,KAAK,IAAI;CACV,CAAC,KAAK,IAAI;CACV,CAAC,KAAK,IAAI;CACV,CAAC,KAAK,GAAG;CACT,CAAC,KAAK,IAAI;CACV,CAAC,KAAK,GAAG;CACT,CAAC,KAAK,IAAI;CACV,CAAC,KAAK,GAAG;CACT,CAAC,KAAK,GAAG;CACT,CAAC,KAAK,GAAG;AACb,CAAC;;;;AAID,MAAa,iBAEZ,KAAK,OAAO,mBAAmB,QAAQ,OAAO,KAAK,IAAI,KAAK,SAAU,WAAW;CAC9E,IAAI,SAAS;CACb,IAAI,YAAY,OAAQ;EACpB,aAAa;EACb,UAAU,OAAO,aAAe,cAAc,KAAM,OAAS,KAAM;EACnE,YAAY,QAAU,YAAY;CACtC;CACA,UAAU,OAAO,aAAa,SAAS;CACvC,OAAO;AACX;;;;;;AAMA,SAAgB,iBAAiB,WAAW;CACxC,IAAI;CACJ,IAAK,aAAa,SAAU,aAAa,SAAW,YAAY,SAC5D,OAAO;CAEX,QAAQ,KAAK,UAAU,IAAI,SAAS,OAAO,QAAQ,OAAO,KAAK,IAAI,KAAK;AAC5E"}

package/dist/node_modules/entities/lib/esm/escape.js

@@ -0,0 +1,85 @@
+//#region ../../node_modules/entities/lib/esm/escape.js
+const xmlReplacer = /["&'<>$\x80-\uFFFF]/g;
+const xmlCodeMap = /* @__PURE__ */ new Map([
+	[34, "&quot;"],
+	[38, "&amp;"],
+	[39, "&apos;"],
+	[60, "&lt;"],
+	[62, "&gt;"]
+]);
+const getCodePoint = String.prototype.codePointAt != null ? (str, index) => str.codePointAt(index) : (c, index) => (c.charCodeAt(index) & 64512) === 55296 ? (c.charCodeAt(index) - 55296) * 1024 + c.charCodeAt(index + 1) - 56320 + 65536 : c.charCodeAt(index);
+/**
+* Encodes all non-ASCII characters, as well as characters not valid in XML
+* documents using XML entities.
+*
+* If a character has no equivalent entity, a
+* numeric hexadecimal reference (eg. `&#xfc;`) will be used.
+*/
+function encodeXML(str) {
+	let ret = "";
+	let lastIdx = 0;
+	let match;
+	while ((match = xmlReplacer.exec(str)) !== null) {
+		const i = match.index;
+		const char = str.charCodeAt(i);
+		const next = xmlCodeMap.get(char);
+		if (next !== void 0) {
+			ret += str.substring(lastIdx, i) + next;
+			lastIdx = i + 1;
+		} else {
+			ret += `${str.substring(lastIdx, i)}&#x${getCodePoint(str, i).toString(16)};`;
+			lastIdx = xmlReplacer.lastIndex += Number((char & 64512) === 55296);
+		}
+	}
+	return ret + str.substr(lastIdx);
+}
+/**
+* Creates a function that escapes all characters matched by the given regular
+* expression using the given map of characters to escape to their entities.
+*
+* @param regex Regular expression to match characters to escape.
+* @param map Map of characters to escape to their entities.
+*
+* @returns Function that escapes all characters matched by the given regular
+* expression using the given map of characters to escape to their entities.
+*/
+function getEscaper(regex, map) {
+	return function escape(data) {
+		let match;
+		let lastIdx = 0;
+		let result = "";
+		while (match = regex.exec(data)) {
+			if (lastIdx !== match.index) result += data.substring(lastIdx, match.index);
+			result += map.get(match[0].charCodeAt(0));
+			lastIdx = match.index + 1;
+		}
+		return result + data.substring(lastIdx);
+	};
+}
+/**
+* Encodes all characters that have to be escaped in HTML attributes,
+* following {@link https://html.spec.whatwg.org/multipage/parsing.html#escapingString}.
+*
+* @param data String to escape.
+*/
+const escapeAttribute = getEscaper(/["&\u00A0]/g, /* @__PURE__ */ new Map([
+	[34, "&quot;"],
+	[38, "&amp;"],
+	[160, "&nbsp;"]
+]));
+/**
+* Encodes all characters that have to be escaped in HTML text,
+* following {@link https://html.spec.whatwg.org/multipage/parsing.html#escapingString}.
+*
+* @param data String to escape.
+*/
+const escapeText = getEscaper(/[&<>\u00A0]/g, /* @__PURE__ */ new Map([
+	[38, "&amp;"],
+	[60, "&lt;"],
+	[62, "&gt;"],
+	[160, "&nbsp;"]
+]));
+//#endregion
+export { encodeXML, escapeAttribute, escapeText, getCodePoint, xmlReplacer };
+
+//# sourceMappingURL=escape.js.map

package/dist/node_modules/entities/lib/esm/escape.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"escape.js","names":[],"sources":["../../../../../../../node_modules/entities/lib/esm/escape.js"],"sourcesContent":["export const xmlReplacer = /[\"&'<>$\\x80-\\uFFFF]/g;\nconst xmlCodeMap = new Map([\n    [34, \"&quot;\"],\n    [38, \"&amp;\"],\n    [39, \"&apos;\"],\n    [60, \"&lt;\"],\n    [62, \"&gt;\"],\n]);\n// For compatibility with node < 4, we wrap `codePointAt`\nexport const getCodePoint = \n// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\nString.prototype.codePointAt != null\n    ? (str, index) => str.codePointAt(index)\n    : // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae\n        (c, index) => (c.charCodeAt(index) & 0xfc00) === 0xd800\n            ? (c.charCodeAt(index) - 0xd800) * 0x400 +\n                c.charCodeAt(index + 1) -\n                0xdc00 +\n                0x10000\n            : c.charCodeAt(index);\n/**\n * Encodes all non-ASCII characters, as well as characters not valid in XML\n * documents using XML entities.\n *\n * If a character has no equivalent entity, a\n * numeric hexadecimal reference (eg. `&#xfc;`) will be used.\n */\nexport function encodeXML(str) {\n    let ret = \"\";\n    let lastIdx = 0;\n    let match;\n    while ((match = xmlReplacer.exec(str)) !== null) {\n        const i = match.index;\n        const char = str.charCodeAt(i);\n        const next = xmlCodeMap.get(char);\n        if (next !== undefined) {\n            ret += str.substring(lastIdx, i) + next;\n            lastIdx = i + 1;\n        }\n        else {\n            ret += `${str.substring(lastIdx, i)}&#x${getCodePoint(str, i).toString(16)};`;\n            // Increase by 1 if we have a surrogate pair\n            lastIdx = xmlReplacer.lastIndex += Number((char & 0xfc00) === 0xd800);\n        }\n    }\n    return ret + str.substr(lastIdx);\n}\n/**\n * Encodes all non-ASCII characters, as well as characters not valid in XML\n * documents using numeric hexadecimal reference (eg. `&#xfc;`).\n *\n * Have a look at `escapeUTF8` if you want a more concise output at the expense\n * of reduced transportability.\n *\n * @param data String to escape.\n */\nexport const escape = encodeXML;\n/**\n * Creates a function that escapes all characters matched by the given regular\n * expression using the given map of characters to escape to their entities.\n *\n * @param regex Regular expression to match characters to escape.\n * @param map Map of characters to escape to their entities.\n *\n * @returns Function that escapes all characters matched by the given regular\n * expression using the given map of characters to escape to their entities.\n */\nfunction getEscaper(regex, map) {\n    return function escape(data) {\n        let match;\n        let lastIdx = 0;\n        let result = \"\";\n        while ((match = regex.exec(data))) {\n            if (lastIdx !== match.index) {\n                result += data.substring(lastIdx, match.index);\n            }\n            // We know that this character will be in the map.\n            result += map.get(match[0].charCodeAt(0));\n            // Every match will be of length 1\n            lastIdx = match.index + 1;\n        }\n        return result + data.substring(lastIdx);\n    };\n}\n/**\n * Encodes all characters not valid in XML documents using XML entities.\n *\n * Note that the output will be character-set dependent.\n *\n * @param data String to escape.\n */\nexport const escapeUTF8 = getEscaper(/[&<>'\"]/g, xmlCodeMap);\n/**\n * Encodes all characters that have to be escaped in HTML attributes,\n * following {@link https://html.spec.whatwg.org/multipage/parsing.html#escapingString}.\n *\n * @param data String to escape.\n */\nexport const escapeAttribute = getEscaper(/[\"&\\u00A0]/g, new Map([\n    [34, \"&quot;\"],\n    [38, \"&amp;\"],\n    [160, \"&nbsp;\"],\n]));\n/**\n * Encodes all characters that have to be escaped in HTML text,\n * following {@link https://html.spec.whatwg.org/multipage/parsing.html#escapingString}.\n *\n * @param data String to escape.\n */\nexport const escapeText = getEscaper(/[&<>\\u00A0]/g, new Map([\n    [38, \"&amp;\"],\n    [60, \"&lt;\"],\n    [62, \"&gt;\"],\n    [160, \"&nbsp;\"],\n]));\n//# sourceMappingURL=escape.js.map"],"x_google_ignoreList":[0],"mappings":";AAAA,MAAa,cAAc;AAC3B,MAAM,6BAAa,IAAI,IAAI;CACvB,CAAC,IAAI,QAAQ;CACb,CAAC,IAAI,OAAO;CACZ,CAAC,IAAI,QAAQ;CACb,CAAC,IAAI,MAAM;CACX,CAAC,IAAI,MAAM;AACf,CAAC;AAED,MAAa,eAEb,OAAO,UAAU,eAAe,QACzB,KAAK,UAAU,IAAI,YAAY,KAAK,KAElC,GAAG,WAAW,EAAE,WAAW,KAAK,IAAI,WAAY,SAC1C,EAAE,WAAW,KAAK,IAAI,SAAU,OAC/B,EAAE,WAAW,QAAQ,CAAC,IACtB,QACA,QACF,EAAE,WAAW,KAAK;;;;;;;;AAQhC,SAAgB,UAAU,KAAK;CAC3B,IAAI,MAAM;CACV,IAAI,UAAU;CACd,IAAI;CACJ,QAAQ,QAAQ,YAAY,KAAK,GAAG,OAAO,MAAM;EAC7C,MAAM,IAAI,MAAM;EAChB,MAAM,OAAO,IAAI,WAAW,CAAC;EAC7B,MAAM,OAAO,WAAW,IAAI,IAAI;EAChC,IAAI,SAAS,KAAA,GAAW;GACpB,OAAO,IAAI,UAAU,SAAS,CAAC,IAAI;GACnC,UAAU,IAAI;EAClB,OACK;GACD,OAAO,GAAG,IAAI,UAAU,SAAS,CAAC,EAAE,KAAK,aAAa,KAAK,CAAC,CAAC,CAAC,SAAS,EAAE,EAAE;GAE3E,UAAU,YAAY,aAAa,QAAQ,OAAO,WAAY,KAAM;EACxE;CACJ;CACA,OAAO,MAAM,IAAI,OAAO,OAAO;AACnC;;;;;;;;;;;AAqBA,SAAS,WAAW,OAAO,KAAK;CAC5B,OAAO,SAAS,OAAO,MAAM;EACzB,IAAI;EACJ,IAAI,UAAU;EACd,IAAI,SAAS;EACb,OAAQ,QAAQ,MAAM,KAAK,IAAI,GAAI;GAC/B,IAAI,YAAY,MAAM,OAClB,UAAU,KAAK,UAAU,SAAS,MAAM,KAAK;GAGjD,UAAU,IAAI,IAAI,MAAM,EAAE,CAAC,WAAW,CAAC,CAAC;GAExC,UAAU,MAAM,QAAQ;EAC5B;EACA,OAAO,SAAS,KAAK,UAAU,OAAO;CAC1C;AACJ;;;;;;;AAeA,MAAa,kBAAkB,WAAW,+BAAe,IAAI,IAAI;CAC7D,CAAC,IAAI,QAAQ;CACb,CAAC,IAAI,OAAO;CACZ,CAAC,KAAK,QAAQ;AAClB,CAAC,CAAC;;;;;;;AAOF,MAAa,aAAa,WAAW,gCAAgB,IAAI,IAAI;CACzD,CAAC,IAAI,OAAO;CACZ,CAAC,IAAI,MAAM;CACX,CAAC,IAAI,MAAM;CACX,CAAC,KAAK,QAAQ;AAClB,CAAC,CAAC"}