@eksml/xml 0.1.0

package/dist/saxEngine-BDnD7ruG.mjs

@@ -0,0 +1,750 @@
+//#region src/saxEngine.ts
+/**
+* saxEngine — a high-performance, synchronous, event-based streaming XML parser.
+*
+* This is an internal module used by `createSaxParser` and `XmlParseStream`.
+* It is not part of the public API.
+*
+* Architecture: single-pass state machine with batch scanning. Each character is
+* consumed exactly once. Within a chunk, hot-path states (text, tag names,
+* attribute names/values, close tags) scan ahead with indexOf / charCodeAt loops
+* to extract tokens via a single substring() rather than per-character +=.
+*/
+const GT = 62;
+const SLASH = 47;
+const BANG = 33;
+const QUESTION = 63;
+const EQ = 61;
+const LBRACKET = 91;
+const RBRACKET = 93;
+const SQUOTE = 39;
+const DQUOTE = 34;
+const TAB = 9;
+const LF = 10;
+const CR = 13;
+const SPACE = 32;
+const DASH = 45;
+const UPPER_C = 67;
+const UPPER_D = 68;
+const UPPER_A = 65;
+const UPPER_T = 84;
+const State = {
+	TEXT: 0,
+	TAG_OPEN: 1,
+	OPEN_TAG_NAME: 2,
+	OPEN_TAG_BODY: 3,
+	ATTR_NAME: 4,
+	ATTR_AFTER_NAME: 5,
+	ATTR_AFTER_EQ: 6,
+	ATTR_VALUE_DQ: 7,
+	ATTR_VALUE_SQ: 8,
+	ATTR_VALUE_UQ: 9,
+	CLOSE_TAG: 10,
+	SELF_CLOSING: 11,
+	COMMENT_1: 12,
+	COMMENT: 13,
+	COMMENT_END1: 14,
+	COMMENT_END2: 15,
+	CDATA_1: 16,
+	CDATA_2: 17,
+	CDATA_3: 18,
+	CDATA_4: 19,
+	CDATA_5: 20,
+	CDATA_6: 21,
+	CDATA: 22,
+	CDATA_END1: 23,
+	CDATA_END2: 24,
+	PI: 25,
+	PI_END: 26,
+	DOCTYPE: 27,
+	DOCTYPE_BRACKET: 28,
+	BANG_START: 29,
+	RAW_TEXT: 30,
+	RAW_END_1: 31,
+	RAW_END_2: 32,
+	RAW_END_3: 33
+};
+function saxEngine(options = {}) {
+	const { onOpenTag, onCloseTag, onText, onCdata, onComment, onProcessingInstruction, onDoctype, selfClosingTags = [], rawContentTags = [], maxBufferSize } = options;
+	const voidSet = selfClosingTags.length > 0 ? new Set(selfClosingTags) : null;
+	const rawSet = rawContentTags.length > 0 ? new Set(rawContentTags) : null;
+	let state = State.TEXT;
+	let text = "";
+	let tagName = "";
+	let attributeName = "";
+	let attributeValue = "";
+	let attributes = Object.create(null);
+	let special = "";
+	let rawTag = "";
+	let rawText = "";
+	let rawCloseTagMatchIndex = 0;
+	let rawCloseTagTrailing = "";
+	function trimWhitespace(input) {
+		let startIndex = 0;
+		let endIndex = input.length - 1;
+		while (startIndex <= endIndex) {
+			const charCode = input.charCodeAt(startIndex);
+			if (charCode !== SPACE && charCode !== TAB && charCode !== LF && charCode !== CR) break;
+			startIndex++;
+		}
+		while (endIndex >= startIndex) {
+			const charCode = input.charCodeAt(endIndex);
+			if (charCode !== SPACE && charCode !== TAB && charCode !== LF && charCode !== CR) break;
+			endIndex--;
+		}
+		return startIndex === 0 && endIndex === input.length - 1 ? input : input.substring(startIndex, endIndex + 1);
+	}
+	function emitText() {
+		if (text.length === 0) return;
+		if (onText) {
+			const trimmed = trimWhitespace(text);
+			if (trimmed.length > 0) onText(trimmed);
+		}
+		text = "";
+	}
+	/**
+	* Parse the accumulated DOCTYPE body (everything between `<!` and `>`,
+	* excluding internal DTD subsets) and emit an onDoctype event.
+	*
+	* The body string starts with the declaration keyword (e.g. "DOCTYPE html ...")
+	* after the `!`. We prepend `!` to form the tagName (e.g. "!DOCTYPE"), then
+	* parse the remaining space-separated tokens as null-valued attributes.
+	* Quoted strings are unquoted and stored as attribute keys.
+	*/
+	function emitDoctype(body) {
+		const bodyLength = body.length;
+		let i = 0;
+		while (i < bodyLength) {
+			const charCode = body.charCodeAt(i);
+			if (charCode === SPACE || charCode === TAB || charCode === LF || charCode === CR) break;
+			i++;
+		}
+		const tagName = "!" + body.substring(0, i);
+		const attributes = Object.create(null);
+		while (i < bodyLength) {
+			const charCode = body.charCodeAt(i);
+			if (charCode === SPACE || charCode === TAB || charCode === LF || charCode === CR) {
+				i++;
+				continue;
+			}
+			if (charCode === DQUOTE || charCode === SQUOTE) {
+				const quoteChar = charCode === DQUOTE ? "\"" : "'";
+				const closeIndex = body.indexOf(quoteChar, i + 1);
+				if (closeIndex === -1) {
+					attributes[body.substring(i + 1)] = null;
+					break;
+				}
+				attributes[body.substring(i + 1, closeIndex)] = null;
+				i = closeIndex + 1;
+				continue;
+			}
+			const tokenStart = i;
+			while (i < bodyLength) {
+				const tokenCharCode = body.charCodeAt(i);
+				if (tokenCharCode === SPACE || tokenCharCode === TAB || tokenCharCode === LF || tokenCharCode === CR) break;
+				i++;
+			}
+			attributes[body.substring(tokenStart, i)] = null;
+		}
+		onDoctype(tagName, attributes);
+	}
+	/** After we finish parsing an open tag's `>`, handle void/raw transitions. */
+	function finishOpenTag() {
+		if (onOpenTag) onOpenTag(tagName, attributes);
+		if (voidSet !== null && voidSet.has(tagName)) {
+			if (onCloseTag) onCloseTag(tagName);
+		} else if (rawSet !== null && rawSet.has(tagName)) {
+			rawTag = tagName;
+			rawText = "";
+			rawCloseTagMatchIndex = 0;
+			state = State.RAW_TEXT;
+		}
+	}
+	/**
+	* Returns true if `charCode` is a tag-name-ending character:
+	* `>`, `/`, `=`, or whitespace.
+	*/
+	function isNameEnd(charCode) {
+		return charCode === GT || charCode === SLASH || charCode === EQ || charCode === SPACE || charCode === TAB || charCode === LF || charCode === CR;
+	}
+	function processChunk(chunk) {
+		const chunkLength = chunk.length;
+		let i = 0;
+		while (i < chunkLength) switch (state) {
+			case State.TEXT: {
+				const lessThanIndex = chunk.indexOf("<", i);
+				if (lessThanIndex === -1) {
+					text += i === 0 ? chunk : chunk.substring(i);
+					i = chunkLength;
+				} else {
+					if (lessThanIndex > i) text += chunk.substring(i, lessThanIndex);
+					emitText();
+					state = State.TAG_OPEN;
+					i = lessThanIndex + 1;
+				}
+				continue;
+			}
+			case State.TAG_OPEN: {
+				const charCode = chunk.charCodeAt(i);
+				if (charCode === SLASH) {
+					state = State.CLOSE_TAG;
+					tagName = "";
+					i++;
+				} else if (charCode === BANG) {
+					state = State.BANG_START;
+					special = "";
+					i++;
+				} else if (charCode === QUESTION) {
+					state = State.PI;
+					special = "";
+					i++;
+				} else {
+					state = State.OPEN_TAG_NAME;
+					tagName = "";
+					attributes = Object.create(null);
+				}
+				continue;
+			}
+			case State.OPEN_TAG_NAME: {
+				let j = i;
+				while (j < chunkLength) {
+					if (isNameEnd(chunk.charCodeAt(j))) break;
+					j++;
+				}
+				if (j > i) tagName += chunk.substring(i, j);
+				if (j >= chunkLength) {
+					i = chunkLength;
+					continue;
+				}
+				const charCode = chunk.charCodeAt(j);
+				if (charCode === GT) {
+					state = State.TEXT;
+					i = j + 1;
+					finishOpenTag();
+				} else if (charCode === SLASH) {
+					state = State.SELF_CLOSING;
+					i = j + 1;
+				} else {
+					state = State.OPEN_TAG_BODY;
+					i = j + 1;
+				}
+				continue;
+			}
+			case State.OPEN_TAG_BODY: {
+				const charCode = chunk.charCodeAt(i);
+				if (charCode === GT) {
+					state = State.TEXT;
+					i++;
+					finishOpenTag();
+				} else if (charCode === SLASH) {
+					state = State.SELF_CLOSING;
+					i++;
+				} else if (charCode === SPACE || charCode === TAB || charCode === LF || charCode === CR) i++;
+				else {
+					state = State.ATTR_NAME;
+					attributeName = "";
+				}
+				continue;
+			}
+			case State.ATTR_NAME: {
+				let j = i;
+				while (j < chunkLength) {
+					const charCode = chunk.charCodeAt(j);
+					if (charCode === EQ || charCode === GT || charCode === SLASH || charCode === SPACE || charCode === TAB || charCode === LF || charCode === CR) break;
+					j++;
+				}
+				if (j > i) attributeName += chunk.substring(i, j);
+				if (j >= chunkLength) {
+					i = chunkLength;
+					continue;
+				}
+				const charCode = chunk.charCodeAt(j);
+				if (charCode === EQ) {
+					state = State.ATTR_AFTER_EQ;
+					i = j + 1;
+				} else if (charCode === GT) {
+					attributes[attributeName] = null;
+					state = State.TEXT;
+					i = j + 1;
+					finishOpenTag();
+				} else if (charCode === SLASH) {
+					attributes[attributeName] = null;
+					state = State.SELF_CLOSING;
+					i = j + 1;
+				} else {
+					state = State.ATTR_AFTER_NAME;
+					i = j + 1;
+				}
+				continue;
+			}
+			case State.ATTR_AFTER_NAME: {
+				const charCode = chunk.charCodeAt(i);
+				if (charCode === EQ) {
+					state = State.ATTR_AFTER_EQ;
+					i++;
+				} else if (charCode === SPACE || charCode === TAB || charCode === LF || charCode === CR) i++;
+				else if (charCode === GT) {
+					attributes[attributeName] = null;
+					state = State.TEXT;
+					i++;
+					finishOpenTag();
+				} else if (charCode === SLASH) {
+					attributes[attributeName] = null;
+					state = State.SELF_CLOSING;
+					i++;
+				} else {
+					attributes[attributeName] = null;
+					state = State.ATTR_NAME;
+					attributeName = "";
+				}
+				continue;
+			}
+			case State.ATTR_AFTER_EQ: {
+				const charCode = chunk.charCodeAt(i);
+				if (charCode === DQUOTE) {
+					state = State.ATTR_VALUE_DQ;
+					attributeValue = "";
+					i++;
+				} else if (charCode === SQUOTE) {
+					state = State.ATTR_VALUE_SQ;
+					attributeValue = "";
+					i++;
+				} else if (charCode === SPACE || charCode === TAB || charCode === LF || charCode === CR) i++;
+				else if (charCode === GT) {
+					attributes[attributeName] = "";
+					state = State.TEXT;
+					i++;
+					finishOpenTag();
+				} else {
+					state = State.ATTR_VALUE_UQ;
+					attributeValue = "";
+				}
+				continue;
+			}
+			case State.ATTR_VALUE_DQ: {
+				const quoteIndex = chunk.indexOf("\"", i);
+				if (quoteIndex === -1) {
+					attributeValue += i === 0 ? chunk : chunk.substring(i);
+					i = chunkLength;
+				} else {
+					if (quoteIndex > i) attributeValue += chunk.substring(i, quoteIndex);
+					attributes[attributeName] = attributeValue;
+					state = State.OPEN_TAG_BODY;
+					i = quoteIndex + 1;
+				}
+				continue;
+			}
+			case State.ATTR_VALUE_SQ: {
+				const quoteIndex = chunk.indexOf("'", i);
+				if (quoteIndex === -1) {
+					attributeValue += i === 0 ? chunk : chunk.substring(i);
+					i = chunkLength;
+				} else {
+					if (quoteIndex > i) attributeValue += chunk.substring(i, quoteIndex);
+					attributes[attributeName] = attributeValue;
+					state = State.OPEN_TAG_BODY;
+					i = quoteIndex + 1;
+				}
+				continue;
+			}
+			case State.ATTR_VALUE_UQ: {
+				let j = i;
+				while (j < chunkLength) {
+					const charCode = chunk.charCodeAt(j);
+					if (charCode === SPACE || charCode === TAB || charCode === LF || charCode === CR || charCode === GT || charCode === SLASH) break;
+					j++;
+				}
+				if (j > i) attributeValue += chunk.substring(i, j);
+				if (j >= chunkLength) {
+					i = chunkLength;
+					continue;
+				}
+				const charCode = chunk.charCodeAt(j);
+				attributes[attributeName] = attributeValue;
+				if (charCode === GT) {
+					state = State.TEXT;
+					i = j + 1;
+					finishOpenTag();
+				} else if (charCode === SLASH) {
+					state = State.SELF_CLOSING;
+					i = j + 1;
+				} else {
+					state = State.OPEN_TAG_BODY;
+					i = j + 1;
+				}
+				continue;
+			}
+			case State.CLOSE_TAG: {
+				const greaterThanIndex = chunk.indexOf(">", i);
+				if (greaterThanIndex === -1) {
+					tagName += i === 0 ? chunk : chunk.substring(i);
+					i = chunkLength;
+				} else {
+					if (greaterThanIndex > i) tagName += chunk.substring(i, greaterThanIndex);
+					if (onCloseTag) onCloseTag(trimWhitespace(tagName));
+					state = State.TEXT;
+					i = greaterThanIndex + 1;
+				}
+				continue;
+			}
+			case State.SELF_CLOSING:
+				if (chunk.charCodeAt(i) === GT) {
+					state = State.TEXT;
+					i++;
+					if (onOpenTag) onOpenTag(tagName, attributes);
+					if (onCloseTag) onCloseTag(tagName);
+				} else state = State.OPEN_TAG_BODY;
+				continue;
+			case State.BANG_START: {
+				const charCode = chunk.charCodeAt(i);
+				if (charCode === DASH) {
+					state = State.COMMENT_1;
+					special = "<!-";
+					i++;
+				} else if (charCode === LBRACKET) {
+					state = State.CDATA_1;
+					i++;
+				} else {
+					state = State.DOCTYPE;
+					special = "";
+				}
+				continue;
+			}
+			case State.COMMENT_1:
+				if (chunk.charCodeAt(i) === DASH) {
+					state = State.COMMENT;
+					special = "<!--";
+					i++;
+				} else {
+					special = "-";
+					state = State.DOCTYPE;
+				}
+				continue;
+			case State.COMMENT: {
+				const dashIndex = chunk.indexOf("-", i);
+				if (dashIndex === -1) {
+					special += i === 0 ? chunk : chunk.substring(i);
+					i = chunkLength;
+				} else {
+					if (dashIndex > i) special += chunk.substring(i, dashIndex);
+					special += "-";
+					state = State.COMMENT_END1;
+					i = dashIndex + 1;
+				}
+				continue;
+			}
+			case State.COMMENT_END1:
+				if (chunk.charCodeAt(i) === DASH) {
+					state = State.COMMENT_END2;
+					special += "-";
+					i++;
+				} else {
+					state = State.COMMENT;
+					special += chunk[i];
+					i++;
+				}
+				continue;
+			case State.COMMENT_END2: {
+				const charCode = chunk.charCodeAt(i);
+				if (charCode === GT) {
+					special += ">";
+					if (onComment) onComment(special);
+					special = "";
+					state = State.TEXT;
+					i++;
+				} else if (charCode === DASH) {
+					special += "-";
+					i++;
+				} else {
+					state = State.COMMENT;
+					special += chunk[i];
+					i++;
+				}
+				continue;
+			}
+			case State.CDATA_1:
+				if (chunk.charCodeAt(i) === UPPER_C) {
+					state = State.CDATA_2;
+					i++;
+				} else {
+					special = "[";
+					state = State.DOCTYPE;
+				}
+				continue;
+			case State.CDATA_2:
+				if (chunk.charCodeAt(i) === UPPER_D) {
+					state = State.CDATA_3;
+					i++;
+				} else {
+					special = "[C";
+					state = State.DOCTYPE;
+				}
+				continue;
+			case State.CDATA_3:
+				if (chunk.charCodeAt(i) === UPPER_A) {
+					state = State.CDATA_4;
+					i++;
+				} else {
+					special = "[CD";
+					state = State.DOCTYPE;
+				}
+				continue;
+			case State.CDATA_4:
+				if (chunk.charCodeAt(i) === UPPER_T) {
+					state = State.CDATA_5;
+					i++;
+				} else {
+					special = "[CDA";
+					state = State.DOCTYPE;
+				}
+				continue;
+			case State.CDATA_5:
+				if (chunk.charCodeAt(i) === UPPER_A) {
+					state = State.CDATA_6;
+					i++;
+				} else {
+					special = "[CDAT";
+					state = State.DOCTYPE;
+				}
+				continue;
+			case State.CDATA_6:
+				if (chunk.charCodeAt(i) === LBRACKET) {
+					state = State.CDATA;
+					special = "";
+					i++;
+				} else {
+					special = "[CDATA";
+					state = State.DOCTYPE;
+				}
+				continue;
+			case State.CDATA: {
+				const bracketIndex = chunk.indexOf("]", i);
+				if (bracketIndex === -1) {
+					special += i === 0 ? chunk : chunk.substring(i);
+					i = chunkLength;
+				} else {
+					if (bracketIndex > i) special += chunk.substring(i, bracketIndex);
+					state = State.CDATA_END1;
+					i = bracketIndex + 1;
+				}
+				continue;
+			}
+			case State.CDATA_END1:
+				if (chunk.charCodeAt(i) === RBRACKET) {
+					state = State.CDATA_END2;
+					i++;
+				} else {
+					special += "]" + chunk[i];
+					state = State.CDATA;
+					i++;
+				}
+				continue;
+			case State.CDATA_END2: {
+				const charCode = chunk.charCodeAt(i);
+				if (charCode === GT) {
+					if (onCdata) onCdata(special);
+					special = "";
+					state = State.TEXT;
+					i++;
+				} else if (charCode === RBRACKET) {
+					special += "]";
+					i++;
+				} else {
+					special += "]]" + chunk[i];
+					state = State.CDATA;
+					i++;
+				}
+				continue;
+			}
+			case State.PI: {
+				const questionMarkIndex = chunk.indexOf("?", i);
+				if (questionMarkIndex === -1) {
+					special += i === 0 ? chunk : chunk.substring(i);
+					i = chunkLength;
+				} else {
+					if (questionMarkIndex > i) special += chunk.substring(i, questionMarkIndex);
+					state = State.PI_END;
+					i = questionMarkIndex + 1;
+				}
+				continue;
+			}
+			case State.PI_END:
+				if (chunk.charCodeAt(i) === GT) {
+					if (onProcessingInstruction) {
+						const inner = special;
+						let whitespaceIndex = -1;
+						for (let j = 0; j < inner.length; j++) {
+							const innerCharCode = inner.charCodeAt(j);
+							if (innerCharCode === SPACE || innerCharCode === TAB || innerCharCode === LF || innerCharCode === CR) {
+								whitespaceIndex = j;
+								break;
+							}
+						}
+						if (whitespaceIndex === -1) onProcessingInstruction(inner, "");
+						else {
+							const instructionName = inner.substring(0, whitespaceIndex);
+							let bodyStartIndex = whitespaceIndex + 1;
+							while (bodyStartIndex < inner.length) {
+								const bodyCharCode = inner.charCodeAt(bodyStartIndex);
+								if (bodyCharCode !== SPACE && bodyCharCode !== TAB && bodyCharCode !== LF && bodyCharCode !== CR) break;
+								bodyStartIndex++;
+							}
+							let bodyEndIndex = inner.length - 1;
+							while (bodyEndIndex >= bodyStartIndex) {
+								const bodyCharCode = inner.charCodeAt(bodyEndIndex);
+								if (bodyCharCode !== SPACE && bodyCharCode !== TAB && bodyCharCode !== LF && bodyCharCode !== CR) break;
+								bodyEndIndex--;
+							}
+							onProcessingInstruction(instructionName, bodyStartIndex <= bodyEndIndex ? inner.substring(bodyStartIndex, bodyEndIndex + 1) : "");
+						}
+					}
+					special = "";
+					state = State.TEXT;
+					i++;
+				} else {
+					special += "?";
+					state = State.PI;
+				}
+				continue;
+			case State.DOCTYPE: {
+				const charCode = chunk.charCodeAt(i);
+				if (charCode === GT) {
+					if (onDoctype) emitDoctype(special);
+					special = "";
+					state = State.TEXT;
+					i++;
+				} else if (charCode === LBRACKET) {
+					state = State.DOCTYPE_BRACKET;
+					i++;
+				} else {
+					let j = i;
+					while (j < chunkLength) {
+						const scanCharCode = chunk.charCodeAt(j);
+						if (scanCharCode === GT || scanCharCode === LBRACKET) break;
+						j++;
+					}
+					special += chunk.substring(i, j);
+					i = j;
+				}
+				continue;
+			}
+			case State.DOCTYPE_BRACKET:
+				if (chunk.charCodeAt(i) === RBRACKET) {
+					state = State.DOCTYPE;
+					i++;
+				} else i++;
+				continue;
+			case State.RAW_TEXT: {
+				const lessThanIndex = chunk.indexOf("<", i);
+				if (lessThanIndex === -1) {
+					rawText += i === 0 ? chunk : chunk.substring(i);
+					i = chunkLength;
+				} else {
+					if (lessThanIndex > i) rawText += chunk.substring(i, lessThanIndex);
+					state = State.RAW_END_1;
+					i = lessThanIndex + 1;
+				}
+				continue;
+			}
+			case State.RAW_END_1:
+				if (chunk.charCodeAt(i) === SLASH) {
+					state = State.RAW_END_2;
+					rawCloseTagMatchIndex = 0;
+					i++;
+				} else {
+					rawText += "<";
+					state = State.RAW_TEXT;
+				}
+				continue;
+			case State.RAW_END_2:
+				if (rawCloseTagMatchIndex < rawTag.length) if (chunk[i] === rawTag[rawCloseTagMatchIndex]) {
+					rawCloseTagMatchIndex++;
+					i++;
+				} else {
+					rawText += "</" + rawTag.substring(0, rawCloseTagMatchIndex);
+					state = State.RAW_TEXT;
+				}
+				else {
+					const charCode = chunk.charCodeAt(i);
+					if (charCode === GT) {
+						if (onText && rawText.length > 0) onText(rawText);
+						if (onCloseTag) onCloseTag(rawTag);
+						rawText = "";
+						rawTag = "";
+						state = State.TEXT;
+						i++;
+					} else if (charCode === SPACE || charCode === TAB || charCode === LF || charCode === CR) {
+						rawCloseTagTrailing = chunk[i];
+						state = State.RAW_END_3;
+						i++;
+					} else {
+						rawText += "</" + rawTag;
+						state = State.RAW_TEXT;
+					}
+				}
+				continue;
+			case State.RAW_END_3: {
+				const charCode = chunk.charCodeAt(i);
+				if (charCode === GT) {
+					if (onText && rawText.length > 0) onText(rawText);
+					if (onCloseTag) onCloseTag(rawTag);
+					rawText = "";
+					rawTag = "";
+					rawCloseTagTrailing = "";
+					state = State.TEXT;
+					i++;
+				} else if (charCode === SPACE || charCode === TAB || charCode === LF || charCode === CR) {
+					rawCloseTagTrailing += chunk[i];
+					i++;
+				} else {
+					rawText += "</" + rawTag + rawCloseTagTrailing;
+					rawCloseTagTrailing = "";
+					state = State.RAW_TEXT;
+				}
+				continue;
+			}
+			default:
+				i++;
+				continue;
+		}
+	}
+	return {
+		write(chunk) {
+			if (chunk.length === 0) return;
+			processChunk(chunk);
+			if (maxBufferSize !== void 0 && (text.length > maxBufferSize || attributeValue.length > maxBufferSize || special.length > maxBufferSize || rawText.length > maxBufferSize)) {
+				const buf = text.length > maxBufferSize ? "text" : attributeValue.length > maxBufferSize ? "attribute value" : special.length > maxBufferSize ? "special" : "raw text";
+				throw new RangeError(`Buffer overflow: ${buf} buffer exceeded maxBufferSize (${maxBufferSize})`);
+			}
+		},
+		close() {
+			if (state === State.TEXT) emitText();
+			else if (state === State.RAW_END_3) {
+				if (onText && rawText.length > 0) onText(rawText);
+				if (onCloseTag) onCloseTag(rawTag);
+				rawText = "";
+				rawTag = "";
+				rawCloseTagTrailing = "";
+				state = State.TEXT;
+			} else if (state === State.RAW_TEXT || state === State.RAW_END_1 || state === State.RAW_END_2) {
+				if (state === State.RAW_END_1) rawText += "<";
+				else if (state === State.RAW_END_2) rawText += "</" + rawTag.substring(0, rawCloseTagMatchIndex);
+				if (onText && rawText.length > 0) onText(rawText);
+				if (onCloseTag) onCloseTag(rawTag);
+				rawText = "";
+				rawTag = "";
+				state = State.TEXT;
+			}
+			text = "";
+			tagName = "";
+			attributeName = "";
+			attributeValue = "";
+			special = "";
+			state = State.TEXT;
+		}
+	};
+}
+//#endregion
+export { saxEngine as t };
+
+//# sourceMappingURL=saxEngine-BDnD7ruG.mjs.map