urlpurify 2.2.1 → 2.3.0

package/dist/node_modules/entities/dist/decode.mjs

@@ -1,58 +1,27 @@
 import { codePointToString } from "./decode-codepoint.mjs";
-import { htmlDecodeTree } from "./generated/decode-data-html.mjs";
-import { BinTrieFlags } from "./internal/bin-trie-flags.mjs";
+import { htmlDecodeData } from "./generated/decode-data-html.mjs";
+import { BUCKET_HASH_1, BUCKET_HASH_2, CHAR_REMAP, initDecodeData, pairIndex } from "./internal/decode-data-format.mjs";
 // node_modules/entities/dist/decode.js
-var CharCodes;
-(function(CharCodes) {
-	CharCodes[CharCodes["AMP"] = 38] = "AMP";
-	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_X"] = 120] = "LOWER_X";
-})(CharCodes || (CharCodes = {}));
+const CHAR_AMP = 38;
+const CHAR_NUM = 35;
+const CHAR_SEMI = 59;
+const CHAR_EQUALS = 61;
+const CHAR_ZERO = 48;
+const CHAR_LOWER_A = 97;
+const CHAR_LOWER_X = 120;
+const CHAR_UPPER_A = 65;
 /** Bit that needs to be set to convert an upper case ASCII character to lower case */
 const TO_LOWER_BIT = 32;
-const CONSUMED_SHIFT = 21;
-const CODE_POINT_MASK = 2097151;
-/**
-* Reserved consumed field for counts of at least 2047 characters after `&`.
-* The true count is in `longNumericConsumed`.
-*/
-const CONSUMED_OVERFLOW = 2047;
-/**
-* Side channel for numeric entities of at least 2048 characters including
-* `&`. Set by `parseNumericEntity` when its consumed count reaches the
-* reserved value `CONSUMED_OVERFLOW`; callers read the true count from here.
-* A module-level slot avoids a tuple allocation on the hot path.
-*/
-let longNumericConsumed = 0;
-/**
-* Extract the consumed count from a `parseNumericEntity` packed result,
-* recovering the true length from `longNumericConsumed` when the packed
-* field contains the sentinel. Read it before the next `parseNumericEntity`
-* call, which may overwrite the side channel. This helper owns that protocol.
-* @param packed Packed result of `parseNumericEntity`.
-*/
-function unpackConsumed(packed) {
-	const consumed = packed >>> CONSUMED_SHIFT;
-	return consumed === CONSUMED_OVERFLOW ? longNumericConsumed : consumed;
-}
 /**
 * Unsigned subtraction trick: (code - lo) >>> 0 wraps negatives to large
 * values, so a single `<=` covers the entire [lo..hi] range check.
 * @param code Code point to check.
 */
 function isNumber(code) {
-	return code - CharCodes.ZERO >>> 0 <= 9;
+	return code - CHAR_ZERO >>> 0 <= 9;
 }
-function isHexadecimalCharacter(code) {
-	return (code | TO_LOWER_BIT) - CharCodes.LOWER_A >>> 0 <= 5;
-}
-function isAlpha(code) {
-	return (code | TO_LOWER_BIT) - CharCodes.LOWER_A >>> 0 <= 25;
+function isAlphaNumeric(code) {
+	return isNumber(code) || (code | TO_LOWER_BIT) - CHAR_LOWER_A >>> 0 <= 25;
 }
 /**
 * Checks if the given character is a valid end character for an entity in an attribute.
@@ -62,16 +31,8 @@ function isAlpha(code) {
 * @param code Code point to check.
 */
 function isEntityInAttributeInvalidEnd(code) {
-	return code === CharCodes.EQUALS || isAlpha(code) || isNumber(code);
+	return code === CHAR_EQUALS || isAlphaNumeric(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 = {}));
 /**
 * Decoding mode for named entities.
 */
@@ -84,231 +45,285 @@ var DecodingMode;
 	/** Entities in attributes have limitations on ending characters. */
 	DecodingMode[DecodingMode["Attribute"] = 2] = "Attribute";
 })(DecodingMode || (DecodingMode = {}));
+/** Decode data for HTML entities. */
+const htmlDecode = /* #__PURE__ */ initDecodeData(htmlDecodeData);
+const htmlKeys = /* #__PURE__ */ (() => htmlDecode.keys)();
+const htmlBuckets = /* #__PURE__ */ (() => htmlDecode.buckets)();
+const htmlSlotMidOff = /* #__PURE__ */ (() => htmlDecode.slotMidOff)();
+const htmlLengthBits = /* #__PURE__ */ (() => htmlDecode.lengthBits)();
+const htmlMiddles = /* #__PURE__ */ (() => htmlDecode.middles)();
+/** Hoisted for the specialized HTML cores; see `emitHtmlValue`. */
+const htmlSlotValue = /* #__PURE__ */ (() => htmlDecode.slotValue)();
+const htmlValues = /* #__PURE__ */ (() => htmlDecode.values)();
 /**
-* Determines the branch of the current node that is taken given the current
-* character. This function is used to traverse the trie.
-*
-* See `BinTrieFlags` for the branch-data layouts handled here.
-* @param decodeTree The trie.
-* @param current The current node's header word.
-* @param nodeIndex Index of the node's first branch-data word (the header
-*   plus any value words have been skipped by the caller).
-* @param char The current character.
-* @returns The index of the next node, or -1 if no branch is taken.
+* The replacement string for a packed `slotValue` entry. Most values need
+* just one UTF-16 code unit.
+* @param packed Replacement offset, legacy flag, and length from `htmlSlotValue`.
+*/
+function emitHtmlValue(packed) {
+	const off = packed >> 2;
+	return (packed & 1) === 0 ? htmlValues.charAt(off) : htmlValues.slice(off, off + (packed & 1) + 1);
+}
+/**
+* Find the slot matching `text[start..start+length)`, or -1. A match proves
+* every character of the span (exact key + middle comparison).
+* @param text Input text.
+* @param start Start of the span in `text`.
+* @param length Length of the span.
 */
-function determineBranch(decodeTree, current, nodeIndex, char) {
-	const branchCount = (current & BinTrieFlags.BRANCH_LENGTH) >> 7;
-	const jumpOffset = current & BinTrieFlags.JUMP_TABLE;
-	if (jumpOffset) {
-		if (branchCount === 0) return char === jumpOffset ? nodeIndex : -1;
-		const slot = char - jumpOffset;
-		if (slot >>> 0 >= branchCount) return -1;
-		const stored = decodeTree[nodeIndex + slot];
-		return stored === 0 ? -1 : nodeIndex + branchCount + stored - 1 & 65535;
+function findSlotHtml(text, start, length) {
+	const c0 = text.charCodeAt(start);
+	const c1 = text.charCodeAt(start + 1);
+	const c2 = text.charCodeAt(start + length - 2);
+	const c3 = text.charCodeAt(start + length - 1);
+	if ((c0 | c1 | c2 | c3) > 127) return -1;
+	const key = c0 << 25 | c1 << 18 | c2 << 11 | CHAR_REMAP[c3] << 5 | length;
+	let slot = 2 * ((Math.imul(key, BUCKET_HASH_1) >>> 16) * htmlBuckets >>> 16);
+	for (let attempt = 0;; attempt++) {
+		if (htmlKeys[slot] === key && (length <= 4 || isMidMatchHtml(slot, text, start, length))) return slot;
+		if (htmlKeys[slot + 1] === key && (length <= 4 || isMidMatchHtml(slot + 1, text, start, length))) return slot + 1;
+		if (attempt === 1) return -1;
+		slot = 2 * ((Math.imul(key, BUCKET_HASH_2) >>> 16) * htmlBuckets >>> 16);
 	}
-	if (branchCount === 0) return -1;
-	const packedKeySlots = branchCount + 1 >> 1;
-	const branchEnd = nodeIndex + packedKeySlots + branchCount;
-	for (let index = 0; index < branchCount; index++) {
-		const key = decodeTree[nodeIndex + (index >> 1)] >> ((index & 1) << 3) & 255;
-		if (key === char) return branchEnd + decodeTree[nodeIndex + packedKeySlots + index] & 65535;
-		if (key > char) return -1;
+}
+/**
+* Compare the middle characters (positions 2..length-3) of the candidate at
+* `slot` against the input. The key already proves the outer characters and
+* the length. Names of length at most four are accepted by the caller.
+* @param slot Slot of the candidate.
+* @param text Input text.
+* @param start Start of the span in `text`.
+* @param length Length of the span.
+*/
+function isMidMatchHtml(slot, text, start, length) {
+	let wordIndex = htmlSlotMidOff[slot];
+	let index = start + 2;
+	const end = start + length - 2;
+	while (index + 1 < end) {
+		if ((text.charCodeAt(index) | text.charCodeAt(index + 1) << 16) !== htmlMiddles[wordIndex++]) return false;
+		index += 2;
 	}
-	return -1;
+	return index === end || text.charCodeAt(index) === (htmlMiddles[wordIndex] & 65535);
 }
 /**
-* Read the decoded value from a trie node.
-* @param decodeTree The trie.
-* @param nodeIndex The index of the node.
-* @param valueLength The length of the value (1, 2, or 3).
-* @returns The decoded string.
+* `parseNumericEntity` packs its two results into one integer:
+* `(consumed << CONSUMED_SHIFT) | codePoint`. The code point occupies the low
+* 21 bits (max 0x110000, clamped before packing); `consumed` takes the upper
+* 11 bits and is read back with `>>> CONSUMED_SHIFT`, so the sign bit set by a
+* large `consumed` is harmless. The maximum consumed field is reserved for
+* long references, whose full length is stored in `longNumericConsumed`.
+* A zero return means "no numeric entity".
 */
-function readTrieValue(decodeTree, nodeIndex, valueLength) {
-	if (valueLength === 1) return String.fromCharCode(decodeTree[nodeIndex] & BinTrieFlags.VALUE_MASK);
-	if (valueLength === 2) return String.fromCharCode(decodeTree[nodeIndex + 1]);
-	return String.fromCharCode(decodeTree[nodeIndex + 1], decodeTree[nodeIndex + 2]);
+const NUMERIC_CONSUMED_SHIFT = 21;
+const NUMERIC_CODE_POINT_MASK = 2097151;
+const NUMERIC_CONSUMED_OVERFLOW = 2047;
+/** Full length, including `&`, when the packed consumed field overflows. */
+let longNumericConsumed = 0;
+/**
+* Recover the consumed count before the next numeric parse can overwrite
+* `longNumericConsumed`. This avoids allocating a tuple for each reference.
+* @param packed Packed result of `parseNumericEntity`.
+*/
+function unpackConsumed(packed) {
+	const consumed = packed >>> NUMERIC_CONSUMED_SHIFT;
+	return consumed === NUMERIC_CONSUMED_OVERFLOW ? longNumericConsumed : consumed;
 }
+/** ASCII digit values; 0xff marks characters outside the hexadecimal range. */
+const numericDigits = /* #__PURE__ */ (() => {
+	const digits = (/* @__PURE__ */ new Uint8Array(128)).fill(255);
+	for (let digit = 0; digit < 10; digit++) digits[CHAR_ZERO + digit] = digit;
+	for (let digit = 0; digit < 6; digit++) {
+		digits[CHAR_UPPER_A + digit] = digit + 10;
+		digits[CHAR_LOWER_A + digit] = digit + 10;
+	}
+	return digits;
+})();
 /**
-* Parse a numeric entity (`&#DDD;` or `&#xHHH;`).
-*
-* Encodes the result as `(consumed << CONSUMED_SHIFT) | codepoint` (see
-* the packing comment at the top of the file; overlong entities spill
-* their length into `longNumericConsumed`). Returns 0 when no digits were
-* found.
-*
-* This is the sync counterpart of the streaming
-* `EntityDecoder#stateNumericDecimal` / `#stateNumericHex`. Digit parsing
-* matches those methods; only this packed result needs a value clamp.
-* @param input       The input string.
-* @param numberStart Index of the `#` character.
-* @param inputLength Cached `input.length`.
+* Parse a numeric entity starting right after the `#`. In legacy mode the
+* terminating semicolon is optional. Returns the number of characters
+* consumed (counting the `&` and `#`) packed with the code point (see
+* the packing constants above), or 0 if there is no valid numeric entity at this
+* position.
+* @param input Input string.
+* @param offset Index right after the `#`.
+* @param isStrict Whether a terminating semicolon is required.
 */
-function parseNumericEntity(input, numberStart, inputLength) {
-	let offset = numberStart + 1;
-	let cp = 0;
-	let digitStart = offset;
-	if (offset < inputLength && (input.charCodeAt(offset) | TO_LOWER_BIT) === CharCodes.LOWER_X) {
-		offset += 1;
-		digitStart = offset;
-		while (offset < inputLength) {
-			const char = input.charCodeAt(offset);
-			if (isNumber(char)) cp = cp * 16 + (char - CharCodes.ZERO);
-			else if (isHexadecimalCharacter(char)) cp = cp * 16 + ((char | TO_LOWER_BIT) - CharCodes.LOWER_A + 10);
-			else break;
-			offset += 1;
+function parseNumericEntity(input, offset, isStrict) {
+	const inputLength = input.length;
+	let index = offset;
+	let codePoint = 0;
+	let digitsStart;
+	if ((input.charCodeAt(index) | TO_LOWER_BIT) === CHAR_LOWER_X) {
+		index += 1;
+		digitsStart = index;
+		while (index < inputLength) {
+			const char = input.charCodeAt(index);
+			if (char >= 128) break;
+			const digit = numericDigits[char];
+			if (digit <= 15) {
+				codePoint = codePoint * 16 + digit;
+				index++;
+			} else break;
+		}
+	} else {
+		digitsStart = index;
+		while (index < inputLength) {
+			const char = input.charCodeAt(index);
+			if (char >= 128) break;
+			const digit = numericDigits[char];
+			if (digit <= 9) {
+				codePoint = codePoint * 10 + digit;
+				index++;
+			} else break;
 		}
-	} else while (offset < inputLength) {
-		const digit = input.charCodeAt(offset) - CharCodes.ZERO;
-		if (digit >>> 0 > 9) break;
-		cp = cp * 10 + digit;
-		offset += 1;
 	}
-	if (offset === digitStart) return 0;
-	if (offset < inputLength && input.charCodeAt(offset) === CharCodes.SEMI) offset += 1;
-	if (cp > 1114111) cp = 1114112;
-	let consumed = offset - numberStart;
-	if (consumed >= CONSUMED_OVERFLOW) {
+	if (index === digitsStart) return 0;
+	if (codePoint > 1114111) codePoint = 1114112;
+	let consumed = index - offset + 2;
+	if (index < inputLength && input.charCodeAt(index) === CHAR_SEMI) consumed += 1;
+	else if (isStrict) return 0;
+	if (consumed >= NUMERIC_CONSUMED_OVERFLOW) {
 		longNumericConsumed = consumed;
-		consumed = CONSUMED_OVERFLOW;
+		consumed = NUMERIC_CONSUMED_OVERFLOW;
 	}
-	return consumed << CONSUMED_SHIFT | cp;
+	return consumed << NUMERIC_CONSUMED_SHIFT | codePoint;
 }
 /**
-* Decode all entities in `input` using the HTML trie.
-*
-* Hard-wired to `htmlDecodeTree`: the inline root navigation below assumes
-* the HTML root's jump-table shape, so this must not be generalized to
-* other tries (the XML trie's dictionary root would silently match no
-* entities — `decodeXML` has its own hand-coded fast path instead).
-* @param input      The string to decode.
-* @param isStrict Only match semicolon-terminated entities.
-* @param isAttribute Whether to apply attribute-specific parsing rules (disallowing certain non-semicolon terminators).
-* @returns The decoded string.
+* Find the longest legacy (semicolon-less) match for the name starting at
+* `start`, using the per-class legacy length bits. Returns
+* `slot << 3 | matchLength`, or -1 if there is no match. Only called after
+* the exact probes failed (the miss path).
+* @param input Input text.
+* @param start Start of the name.
+* @param maxLength Number of available run characters.
 */
-function decodeWithTrie(input, isStrict, isAttribute) {
-	const decodeTree = htmlDecodeTree;
+function findLegacySlot(input, start, maxLength) {
+	let legacy = htmlLengthBits[pairIndex(input.charCodeAt(start), input.charCodeAt(start + 1))] >>> 16 & 31;
+	while (legacy !== 0) {
+		const top = 31 - Math.clz32(legacy);
+		legacy ^= 1 << top;
+		if (top + 2 > maxLength) continue;
+		const slot = findSlotHtml(input, start, top + 2);
+		if (slot >= 0 && (htmlSlotValue[slot] & 2) !== 0) return slot << 3 | top + 2;
+	}
+	return -1;
+}
+/**
+* Match a class containing long names without probing all its shorter lengths.
+* The 32-character window bounds the scan even for invalid or unterminated runs.
+* Returns `(slot << 6) | consumed`, excluding the `&`, or -1 on a miss.
+* @param input Input containing the candidate name.
+* @param start Start of the name.
+* @param mode Decoding mode, including the rules for legacy matches.
+*/
+function findLongClassMatch(input, start, mode) {
+	const length = input.slice(start, start + 32).indexOf(";");
+	if (length - 2 >>> 0 <= 29) {
+		const slot = findSlotHtml(input, start, length);
+		if (slot >= 0) return slot << 6 | length + 1;
+	}
+	if (mode !== DecodingMode.Strict) {
+		const packed = findLegacySlot(input, start, Math.min(31, input.length - start));
+		if (packed >= 0) {
+			const length = packed & 7;
+			if (mode !== DecodingMode.Attribute || start + length >= input.length || !isEntityInAttributeInvalidEnd(input.charCodeAt(start + length))) return packed >> 3 << 6 | length;
+		}
+	}
+	return -1;
+}
+/**
+* The next `&` to resume from after emitting a replacement, given the index
+* just past it. A leaf the decoders call after every emit: the common
+* adjacent-entity case (`&amp;&lt;`) skips the `indexOf` C++ call.
+* @param input Input text.
+* @param last Index just past the entity that was emitted.
+*/
+function nextOffset(input, last) {
+	if (last >= input.length) return -1;
+	return input.charCodeAt(last) === CHAR_AMP ? last : input.indexOf("&", last);
+}
+/**
+* Synchronous HTML decoder, shared by all three decoding modes.
+* @param input String to decode.
+* @param mode Decoding mode for named entities.
+*/
+function decodeHtmlText(input, mode) {
+	const isLegacyAllowed = mode !== DecodingMode.Strict;
 	let offset = input.indexOf("&");
 	if (offset < 0) return input;
 	const inputLength = input.length;
-	let chunkStart = 0;
 	let result = "";
-	const root = decodeTree[0];
-	const rootJumpOffset = root & BinTrieFlags.JUMP_TABLE;
-	const rootBranchCount = (root & BinTrieFlags.BRANCH_LENGTH) >> 7;
+	let last = 0;
 	do {
-		const entityStart = offset + 1;
-		const firstChar = input.charCodeAt(entityStart);
-		let consumed;
-		let value;
-		if (firstChar === CharCodes.NUM) {
-			const packed = parseNumericEntity(input, entityStart, inputLength);
-			consumed = unpackConsumed(packed);
-			if (isStrict && consumed > 0 && input.charCodeAt(entityStart + consumed - 1) !== CharCodes.SEMI) consumed = 0;
-			value = consumed === 0 ? "" : codePointToString(packed & CODE_POINT_MASK);
-		} else if (isAlpha(firstChar)) {
-			consumed = 0;
-			value = "";
-			const rootSlotIndex = firstChar - rootJumpOffset;
-			let nodeIndex;
-			if (rootSlotIndex >>> 0 < rootBranchCount) {
-				const stored = decodeTree[1 + rootSlotIndex];
-				nodeIndex = stored === 0 ? -1 : rootBranchCount + stored & 65535;
-			} else nodeIndex = -1;
-			let bestNodeIndex = 0;
-			let bestValueLength = 0;
-			let current = nodeIndex < 0 ? 0 : decodeTree[nodeIndex];
-			let index = entityStart + 1;
-			trie: while (index < inputLength) {
-				while ((current & (BinTrieFlags.VALUE_LENGTH | BinTrieFlags.FLAG13)) === 0 && (current & BinTrieFlags.JUMP_TABLE) !== 0) {
-					const jumpOffset = current & BinTrieFlags.JUMP_TABLE;
-					const branchCount = (current & BinTrieFlags.BRANCH_LENGTH) >> 7;
-					if (branchCount === 0) {
-						if (input.charCodeAt(index) !== jumpOffset) break trie;
-						nodeIndex += 1;
-					} else {
-						const slot = input.charCodeAt(index) - jumpOffset;
-						if (slot >>> 0 >= branchCount) break trie;
-						const stored = decodeTree[nodeIndex + 1 + slot];
-						if (stored === 0) break trie;
-						nodeIndex = nodeIndex + branchCount + stored & 65535;
-					}
-					current = decodeTree[nodeIndex];
-					index += 1;
-					if (index >= inputLength) break trie;
-				}
-				if ((current & (BinTrieFlags.VALUE_LENGTH | BinTrieFlags.FLAG13)) === BinTrieFlags.FLAG13) {
-					const runLength = (current & BinTrieFlags.BRANCH_LENGTH) >> 7;
-					if (input.charCodeAt(index) !== (current & BinTrieFlags.JUMP_TABLE)) break;
-					index += 1;
-					const remaining = runLength - 1;
-					let wordIndex = nodeIndex + 1;
-					let charIndexInPacked = 0;
-					for (; charIndexInPacked + 1 < remaining; charIndexInPacked += 2) {
-						const packed = decodeTree[wordIndex];
-						if (input.charCodeAt(index) !== (packed & 255)) break trie;
-						index += 1;
-						if (input.charCodeAt(index) !== (packed >> 8 & 255)) break trie;
-						index += 1;
-						wordIndex += 1;
-					}
-					if (charIndexInPacked < remaining) {
-						if (input.charCodeAt(index) !== (decodeTree[wordIndex] & 255)) break;
-						index += 1;
-					}
-					nodeIndex += 1 + (runLength >> 1);
-					current = decodeTree[nodeIndex];
-					continue;
-				}
-				const valueLength = current >>> 14;
-				const char = input.charCodeAt(index);
-				if (valueLength !== 0) {
-					if (char === CharCodes.SEMI) {
-						consumed = index - entityStart + 1;
-						value = valueLength === 1 ? String.fromCharCode(current & BinTrieFlags.VALUE_MASK) : readTrieValue(decodeTree, nodeIndex, valueLength);
-						break;
-					}
-					if (!isStrict && (current & BinTrieFlags.FLAG13) === 0) {
-						consumed = index - entityStart;
-						bestNodeIndex = nodeIndex;
-						bestValueLength = valueLength;
-					}
-					if (valueLength === 1) break;
-				}
-				const next = determineBranch(decodeTree, current, nodeIndex + (valueLength || 1), char);
-				if (next < 0) break;
-				nodeIndex = next;
-				current = decodeTree[nodeIndex];
-				index += 1;
+		const start = offset + 1;
+		if (start + 1 >= inputLength) break;
+		const c0 = input.charCodeAt(start);
+		if (c0 === CHAR_AMP) {
+			offset = start;
+			continue;
+		}
+		if (c0 === CHAR_NUM) {
+			const packed = parseNumericEntity(input, start + 1, !isLegacyAllowed);
+			const consumed = unpackConsumed(packed);
+			if (consumed === 0) offset = input.indexOf("&", start);
+			else {
+				if (last !== offset) result += input.slice(last, offset);
+				result += codePointToString(packed & NUMERIC_CODE_POINT_MASK);
+				last = offset + consumed;
+				offset = nextOffset(input, last);
 			}
-			if (value === "") {
-				const finalVL = current >>> 14;
-				if (finalVL !== 0 && !isStrict && (current & BinTrieFlags.FLAG13) === 0) {
-					consumed = index - entityStart;
-					bestNodeIndex = nodeIndex;
-					bestValueLength = finalVL;
-				}
-				if (consumed > 0) value = readTrieValue(decodeTree, bestNodeIndex, bestValueLength);
+			continue;
+		}
+		const bits = htmlLengthBits[pairIndex(c0, input.charCodeAt(start + 1))];
+		if ((bits & 32768) !== 0) {
+			const packed = findLongClassMatch(input, start, mode);
+			if (packed >= 0) {
+				if (last !== offset) result += input.slice(last, offset);
+				result += emitHtmlValue(htmlSlotValue[packed >> 6]);
+				last = start + (packed & 63);
+				offset = nextOffset(input, last);
+			} else offset = input.indexOf("&", start);
+			continue;
+		}
+		let probed = bits & 32767;
+		let matched = -1;
+		while (probed !== 0) {
+			const low = probed & -probed;
+			probed ^= low;
+			const length = 33 - Math.clz32(low);
+			const end = start + length;
+			if (end > inputLength) break;
+			const isTerminated = end < inputLength && input.charCodeAt(end) === CHAR_SEMI;
+			if (!(isTerminated || isLegacyAllowed && (bits >>> length + 14 & 1) !== 0)) continue;
+			const slot = findSlotHtml(input, start, length);
+			if (slot < 0) continue;
+			if (isTerminated) {
+				matched = slot << 6 | 32 | length + 1;
+				break;
 			}
-		} else {
-			consumed = 0;
-			value = "";
+			if ((htmlSlotValue[slot] & 2) !== 0) matched = slot << 6 | length;
 		}
-		if (consumed === 0 || isAttribute && firstChar !== CharCodes.NUM && input.charCodeAt(entityStart + consumed - 1) !== CharCodes.SEMI && entityStart + consumed < inputLength && isEntityInAttributeInvalidEnd(input.charCodeAt(entityStart + consumed))) offset = entityStart;
-		else {
-			if (chunkStart < offset) result += input.slice(chunkStart, offset);
-			result += value;
-			offset = chunkStart = entityStart + consumed;
+		if (matched >= 0) {
+			const length = matched & 31;
+			if ((matched & 32) !== 0 || mode !== DecodingMode.Attribute || start + length >= inputLength || !isEntityInAttributeInvalidEnd(input.charCodeAt(start + length))) {
+				if (last !== offset) result += input.slice(last, offset);
+				result += emitHtmlValue(htmlSlotValue[matched >> 6]);
+				last = start + length;
+				offset = nextOffset(input, last);
+				continue;
+			}
 		}
-		if (input.charCodeAt(offset) !== CharCodes.AMP) offset = input.indexOf("&", offset);
+		offset = input.indexOf("&", start + 1);
 	} while (offset >= 0);
-	return result + input.slice(chunkStart);
+	return result + input.slice(last);
 }
 /**
-* Decodes an HTML string, requiring all entities to be terminated by a semicolon.
+* Decodes an HTML string, requiring all entities to be terminated by a
+* semicolon.
 * @param htmlString The string to decode.
 * @returns The decoded string.
 */
 function decodeHTMLStrict(htmlString) {
-	return decodeWithTrie(htmlString, true, false);
+	return decodeHtmlText(htmlString, DecodingMode.Strict);
 }
-export { DecodingMode, decodeHTMLStrict, determineBranch };
+export { DecodingMode, decodeHTMLStrict };