@shell-shock/preset-cli 0.9.11 → 0.9.12

package/dist/node_modules/.pnpm/colors-option@6.1.2/node_modules/colors-option/build/src/main.mjs

@@ -0,0 +1,23 @@
+import { Chalk } from "../../../../../chalk@5.6.2/node_modules/chalk/source/index.mjs";
+import { getOpts } from "./options.mjs";
+import { WriteStream } from "node:tty";
+
+//#region ../../node_modules/.pnpm/colors-option@6.1.2/node_modules/colors-option/build/src/main.js
+const colorsOption = (opts) => {
+	const { stream, colors = stream.isTTY && stream.getColorDepth() !== 1, level: levelOption = DEPTH_TO_LEVEL[WriteStream.prototype.getColorDepth()], chalkOpts } = getOpts(opts);
+	const level = colors ? levelOption : 0;
+	return new Chalk({
+		...chalkOpts,
+		level
+	});
+};
+const DEPTH_TO_LEVEL = {
+	1: 1,
+	4: 1,
+	8: 2,
+	24: 3
+};
+
+//#endregion
+export { colorsOption as default };
+//# sourceMappingURL=main.mjs.map

package/dist/node_modules/.pnpm/colors-option@6.1.2/node_modules/colors-option/build/src/main.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.mjs","names":[],"sources":["../../../../../../../../../../node_modules/.pnpm/colors-option@6.1.2/node_modules/colors-option/build/src/main.js"],"sourcesContent":["import{WriteStream}from\"node:tty\";\n\nimport{Chalk}from\"chalk\";\n\nimport{getOpts}from\"./options.js\";\n\n\n\n\n\n\n\n\n\n\n\n\n\nconst colorsOption=(opts)=>{\nconst{\nstream,\ncolors=stream.isTTY&&stream.getColorDepth()!==1,\nlevel:levelOption=DEPTH_TO_LEVEL[WriteStream.prototype.getColorDepth()],\nchalkOpts\n}=getOpts(opts);\nconst level=colors?levelOption:0;\nreturn new Chalk({...chalkOpts,level})\n};\n\nexport default colorsOption;\n\n\n\n\n\nconst DEPTH_TO_LEVEL={1:1,4:1,8:2,24:3};"],"x_google_ignoreList":[0],"mappings":";;;;;AAkBA,MAAM,gBAAc,SAAO;CAC3B,MAAK,EACL,QACA,SAAO,OAAO,SAAO,OAAO,eAAe,KAAG,GAC9C,OAAM,cAAY,eAAe,YAAY,UAAU,eAAe,GACtE,cACE,QAAQ,KAAK;CACf,MAAM,QAAM,SAAO,cAAY;AAC/B,QAAO,IAAI,MAAM;EAAC,GAAG;EAAU;EAAM,CAAC;;AAStC,MAAM,iBAAe;CAAC,GAAE;CAAE,GAAE;CAAE,GAAE;CAAE,IAAG;CAAE"}

package/dist/node_modules/.pnpm/colors-option@6.1.2/node_modules/colors-option/build/src/options.cjs

@@ -0,0 +1,36 @@
+const require_runtime = require('../../../../../../../_virtual/_rolldown/runtime.cjs');
+const require_index = require('../../../../../is-plain-obj@4.1.0/node_modules/is-plain-obj/index.cjs');
+let node_process = require("node:process");
+let node_stream = require("node:stream");
+
+//#region ../../node_modules/.pnpm/colors-option@6.1.2/node_modules/colors-option/build/src/options.js
+const getOpts = (opts = {}) => {
+	validateBasicOpts(opts);
+	const { colors, stream = node_process.stdout, level, ...chalkOpts } = opts;
+	validateColors(colors);
+	validateStream(stream);
+	validateLevel(level);
+	return {
+		colors,
+		stream,
+		level,
+		chalkOpts
+	};
+};
+const validateBasicOpts = (opts) => {
+	if (!require_index.default(opts)) throw new TypeError(`Options must be a plain object: ${opts}`);
+};
+const validateColors = (colors) => {
+	if (colors !== void 0 && typeof colors !== "boolean") throw new TypeError(`"colors" option must be a boolean: ${colors}`);
+};
+const validateStream = (stream) => {
+	if (!(stream instanceof node_stream.Stream)) throw new TypeError(`"stream" option must be a stream: ${stream}`);
+};
+const validateLevel = (level) => {
+	if (level === void 0) return;
+	if (level === 0) throw new TypeError("\"level\" option must not be 0. Please use \"colors: false\" instead.");
+	if (!Number.isInteger(level) || level < 1 || level > 3) throw new TypeError(`"level" option must be 1, 2 or 3, not: ${level}`);
+};
+
+//#endregion
+exports.getOpts = getOpts;

package/dist/node_modules/.pnpm/colors-option@6.1.2/node_modules/colors-option/build/src/options.mjs

@@ -0,0 +1,36 @@
+import isPlainObject from "../../../../../is-plain-obj@4.1.0/node_modules/is-plain-obj/index.mjs";
+import { stdout } from "node:process";
+import { Stream } from "node:stream";
+
+//#region ../../node_modules/.pnpm/colors-option@6.1.2/node_modules/colors-option/build/src/options.js
+const getOpts = (opts = {}) => {
+	validateBasicOpts(opts);
+	const { colors, stream = stdout, level, ...chalkOpts } = opts;
+	validateColors(colors);
+	validateStream(stream);
+	validateLevel(level);
+	return {
+		colors,
+		stream,
+		level,
+		chalkOpts
+	};
+};
+const validateBasicOpts = (opts) => {
+	if (!isPlainObject(opts)) throw new TypeError(`Options must be a plain object: ${opts}`);
+};
+const validateColors = (colors) => {
+	if (colors !== void 0 && typeof colors !== "boolean") throw new TypeError(`"colors" option must be a boolean: ${colors}`);
+};
+const validateStream = (stream) => {
+	if (!(stream instanceof Stream)) throw new TypeError(`"stream" option must be a stream: ${stream}`);
+};
+const validateLevel = (level) => {
+	if (level === void 0) return;
+	if (level === 0) throw new TypeError("\"level\" option must not be 0. Please use \"colors: false\" instead.");
+	if (!Number.isInteger(level) || level < 1 || level > 3) throw new TypeError(`"level" option must be 1, 2 or 3, not: ${level}`);
+};
+
+//#endregion
+export { getOpts };
+//# sourceMappingURL=options.mjs.map

package/dist/node_modules/.pnpm/colors-option@6.1.2/node_modules/colors-option/build/src/options.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.mjs","names":["isPlainObj"],"sources":["../../../../../../../../../../node_modules/.pnpm/colors-option@6.1.2/node_modules/colors-option/build/src/options.js"],"sourcesContent":["import{stdout}from\"node:process\";\nimport{Stream}from\"node:stream\";\n\nimport isPlainObj from\"is-plain-obj\";\n\n\nexport const getOpts=(opts={})=>{\nvalidateBasicOpts(opts);\nconst{colors,stream=stdout,level,...chalkOpts}=opts;\nvalidateColors(colors);\nvalidateStream(stream);\nvalidateLevel(level);\nreturn{colors,stream,level,chalkOpts}\n};\n\nconst validateBasicOpts=(opts)=>{\nif(!isPlainObj(opts)){\nthrow new TypeError(`Options must be a plain object: ${opts}`)\n}\n};\n\nconst validateColors=(colors)=>{\nif(colors!==undefined&&typeof colors!==\"boolean\"){\nthrow new TypeError(`\"colors\" option must be a boolean: ${colors}`)\n}\n};\n\nconst validateStream=(stream)=>{\nif(!(stream instanceof Stream)){\nthrow new TypeError(`\"stream\" option must be a stream: ${stream}`)\n}\n};\n\nconst validateLevel=(level)=>{\nif(level===undefined){\nreturn\n}\n\nif(level===0){\nthrow new TypeError(\n\"\\\"level\\\" option must not be 0. Please use \\\"colors: false\\\" instead.\"\n)\n}\n\nif(!Number.isInteger(level)||level<1||level>3){\nthrow new TypeError(`\"level\" option must be 1, 2 or 3, not: ${level}`)\n}\n};"],"x_google_ignoreList":[0],"mappings":";;;;;AAMA,MAAa,WAAS,OAAK,EAAE,KAAG;AAChC,mBAAkB,KAAK;CACvB,MAAK,EAAC,QAAO,SAAO,QAAO,OAAM,GAAG,cAAW;AAC/C,gBAAe,OAAO;AACtB,gBAAe,OAAO;AACtB,eAAc,MAAM;AACpB,QAAM;EAAC;EAAO;EAAO;EAAM;EAAU;;AAGrC,MAAM,qBAAmB,SAAO;AAChC,KAAG,CAACA,cAAW,KAAK,CACpB,OAAM,IAAI,UAAU,mCAAmC,OAAO;;AAI9D,MAAM,kBAAgB,WAAS;AAC/B,KAAG,WAAS,UAAW,OAAO,WAAS,UACvC,OAAM,IAAI,UAAU,sCAAsC,SAAS;;AAInE,MAAM,kBAAgB,WAAS;AAC/B,KAAG,EAAE,kBAAkB,QACvB,OAAM,IAAI,UAAU,qCAAqC,SAAS;;AAIlE,MAAM,iBAAe,UAAQ;AAC7B,KAAG,UAAQ,OACX;AAGA,KAAG,UAAQ,EACX,OAAM,IAAI,UACV,wEACC;AAGD,KAAG,CAAC,OAAO,UAAU,MAAM,IAAE,QAAM,KAAG,QAAM,EAC5C,OAAM,IAAI,UAAU,0CAA0C,QAAQ"}

package/dist/node_modules/.pnpm/entities@4.5.0/node_modules/entities/lib/esm/decode.cjs

@@ -0,0 +1,373 @@
+const require_decode_data_html = require('./generated/decode-data-html.cjs');
+const require_decode_data_xml = require('./generated/decode-data-xml.cjs');
+const require_decode_codepoint = require('./decode_codepoint.cjs');
+
+//#region ../../node_modules/.pnpm/entities@4.5.0/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(require_decode_codepoint.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 += require_decode_codepoint.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;
+}
+const htmlDecoder = getDecoder(require_decode_data_html.default);
+const xmlDecoder = getDecoder(require_decode_data_xml.default);
+/**
+* Decodes an HTML string.
+*
+* @param str The string to decode.
+* @param mode The decoding mode.
+* @returns The decoded string.
+*/
+function decodeHTML(str, mode = DecodingMode.Legacy) {
+	return htmlDecoder(str, mode);
+}
+
+//#endregion
+exports.decodeHTML = decodeHTML;