@eksml/xml 0.1.0

package/dist/parser-CYq309aR.mjs

@@ -0,0 +1,479 @@
+import { n as HTML_VOID_ELEMENTS, t as HTML_RAW_CONTENT_TAGS } from "./htmlConstants-D6fsKbZ-.mjs";
+import { decodeHTML, decodeXML } from "entities";
+//#region src/utilities/escapeRegExp.ts
+/**
+* Escapes special regex characters in a string so it can be safely
+* interpolated into a `new RegExp(...)` pattern.
+*
+* Uses the native `RegExp.escape` when available (Node ≥ 24, Chrome ≥ 136,
+* Firefox ≥ 134, Safari ≥ 18.2), otherwise falls back to a manual replacement.
+* @internal
+*/
+const escapeRegExp = typeof RegExp.escape === "function" ? RegExp.escape : (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+//#endregion
+//#region src/utilities/filter.ts
+/**
+* Filter nodes like Array.filter - returns nodes where the filter function returns true
+* @param input - XML string or array of nodes to filter
+* @param predicate - Filter function
+* @param depth - Current depth in the tree (internal use)
+* @param path - Current path in the tree (internal use)
+* @returns Filtered array of nodes
+*/
+function filter(input, predicate, depth = 0, path = "") {
+	const out = [];
+	filterInto(out, typeof input === "string" ? parse(input) : input, predicate, depth, path);
+	return out;
+}
+function filterInto(out, children, predicate, depth, path) {
+	for (let i = 0; i < children.length; i++) {
+		const child = children[i];
+		if (typeof child === "object") {
+			if (predicate(child, i, depth, path)) out.push(child);
+			if (child.children) filterInto(out, child.children, predicate, depth + 1, (path ? path + "." : "") + i + "." + child.tagName);
+		}
+	}
+}
+//#endregion
+//#region src/parser.ts
+const LT = 60;
+const GT = 62;
+const SLASH = 47;
+const BANG = 33;
+const QUESTION = 63;
+const LBRACKET = 91;
+const RBRACKET = 93;
+const SQUOTE = 39;
+const DQUOTE = 34;
+const DASH = 45;
+const UNDERSCORE = 95;
+const COLON = 58;
+const NAME_END = new Uint8Array(128);
+NAME_END[9] = 1;
+NAME_END[10] = 1;
+NAME_END[13] = 1;
+NAME_END[32] = 1;
+NAME_END[47] = 1;
+NAME_END[61] = 1;
+NAME_END[62] = 1;
+/**
+* Parse XML/HTML into a DOM Object with minimal validation and fault tolerance
+* @param S - The XML string to parse
+* @param options - Parsing options
+* @returns Array of parsed nodes and text content
+*/
+function parse(S, options) {
+	const resolvedOptions = options || {};
+	let pos = resolvedOptions.pos || 0;
+	const keepComments = !!resolvedOptions.keepComments;
+	const trimWhitespace = !!resolvedOptions.trimWhitespace;
+	const strict = !!resolvedOptions.strict;
+	const htmlMode = !!resolvedOptions.html;
+	const decode = resolvedOptions.entities === true ? htmlMode ? decodeHTML : decodeXML : null;
+	const selfClosingTagList = resolvedOptions.selfClosingTags ?? (htmlMode ? HTML_VOID_ELEMENTS : []);
+	const rawContentTagList = resolvedOptions.rawContentTags ?? (htmlMode ? HTML_RAW_CONTENT_TAGS : []);
+	const selfClosingSet = selfClosingTagList.length > 0 ? new Set(selfClosingTagList) : null;
+	const rawContentSet = rawContentTagList.length > 0 ? new Set(rawContentTagList) : null;
+	/** Build an error with line/column info for strict mode. */
+	function strictError(message, atPos) {
+		const p = atPos !== void 0 ? atPos : pos;
+		const lines = S.substring(0, p).split("\n");
+		const line = lines.length;
+		const column = lines[lines.length - 1].length + 1;
+		return /* @__PURE__ */ new Error(`${message} at line ${line}, column ${column}`);
+	}
+	/**
+	* Strip whitespace-only text nodes from a children array when it
+	* contains only element nodes and whitespace-only text (i.e. "ignorable
+	* whitespace" per XML spec). Mixed-content elements — those with at
+	* least one non-whitespace text child — are left untouched so that
+	* whitespace formatting is preserved.
+	* Mutates the array in-place for performance.
+	*/
+	function stripIgnorableWhitespace(children) {
+		let hasElement = false;
+		let hasWhitespaceOnlyText = false;
+		let hasNonWhitespaceText = false;
+		for (let i = 0; i < children.length; i++) {
+			const child = children[i];
+			if (typeof child !== "string") hasElement = true;
+			else if (child.trim().length === 0) hasWhitespaceOnlyText = true;
+			else hasNonWhitespaceText = true;
+		}
+		if (hasElement && hasWhitespaceOnlyText && !hasNonWhitespaceText) {
+			let writeIndex = 0;
+			for (let i = 0; i < children.length; i++) {
+				const child = children[i];
+				if (typeof child === "string" && child.trim().length === 0) continue;
+				children[writeIndex++] = child;
+			}
+			children.length = writeIndex;
+		}
+	}
+	function parseChildren(rootTagName) {
+		const stack = [];
+		let currentTagName = rootTagName;
+		let children = [];
+		while (S[pos]) if (S.charCodeAt(pos) === LT) {
+			if (S.charCodeAt(pos + 1) === SLASH) {
+				const closeStart = pos + 2;
+				pos = S.indexOf(">", pos);
+				if (pos === -1) {
+					if (strict) throw strictError("Unclosed close tag", closeStart - 2);
+					pos = S.length;
+					stripIgnorableWhitespace(children);
+					while (stack.length > 0) {
+						const frame = stack.pop();
+						const node = {
+							tagName: currentTagName,
+							attributes: frame.attributes,
+							children
+						};
+						currentTagName = frame.tagName;
+						children = frame.children;
+						children.push(node);
+						stripIgnorableWhitespace(children);
+					}
+					return children;
+				}
+				const closeTag = S.substring(closeStart, pos).trimEnd();
+				if (closeTag !== currentTagName) throw strictError(`Unexpected close tag </${closeTag}> (expected </${currentTagName}>)`);
+				if (pos + 1) pos += 1;
+				stripIgnorableWhitespace(children);
+				if (stack.length === 0) return children;
+				const frame = stack.pop();
+				const node = {
+					tagName: currentTagName,
+					attributes: frame.attributes,
+					children
+				};
+				currentTagName = frame.tagName;
+				children = frame.children;
+				children.push(node);
+				if (node.tagName.charCodeAt(0) === QUESTION) {
+					children.push(...node.children);
+					node.children = [];
+				}
+				continue;
+			} else if (S.charCodeAt(pos + 1) === BANG) {
+				if (S.charCodeAt(pos + 2) === DASH) {
+					const startCommentPos = pos;
+					pos = S.indexOf("-->", pos + 3);
+					if (pos === -1) {
+						if (strict) throw strictError("Unclosed comment", startCommentPos);
+						pos = S.length;
+						if (keepComments) children.push(S.substring(startCommentPos));
+					} else {
+						pos += 2;
+						if (keepComments) children.push(S.substring(startCommentPos, pos + 1));
+					}
+				} else if (S.charCodeAt(pos + 2) === LBRACKET && S.charCodeAt(pos + 8) === LBRACKET && S.substring(pos + 3, pos + 8).toLowerCase() === "cdata") {
+					const cdataEndIndex = S.indexOf("]]>", pos);
+					if (cdataEndIndex === -1) {
+						if (strict) throw strictError("Unclosed CDATA section");
+						children.push(S.substring(pos + 9));
+						pos = S.length;
+					} else {
+						children.push(S.substring(pos + 9, cdataEndIndex));
+						pos = cdataEndIndex + 3;
+					}
+					continue;
+				} else {
+					pos += 2;
+					const keywordStart = pos - 1;
+					while (pos < S.length) {
+						const cc = S.charCodeAt(pos);
+						if (cc <= 32 || cc === GT || cc === LBRACKET) break;
+						pos++;
+					}
+					const declTagName = S.substring(keywordStart, pos);
+					let declAttributes = null;
+					while (pos < S.length) {
+						const cc = S.charCodeAt(pos);
+						if (cc === GT || cc === LBRACKET) break;
+						if (cc <= 32) {
+							pos++;
+							continue;
+						}
+						if (cc === SQUOTE || cc === DQUOTE) {
+							const closePos = S.indexOf(cc === SQUOTE ? "'" : "\"", pos + 1);
+							if (closePos === -1) {
+								if (strict) throw strictError("Unclosed declaration");
+								pos = S.length;
+								break;
+							}
+							const token = S.substring(pos + 1, closePos);
+							if (declAttributes === null) declAttributes = Object.create(null);
+							declAttributes[token] = null;
+							pos = closePos + 1;
+							continue;
+						}
+						const tokenStart = pos;
+						while (pos < S.length) {
+							const tc = S.charCodeAt(pos);
+							if (tc <= 32 || tc === GT || tc === LBRACKET) break;
+							pos++;
+						}
+						const token = S.substring(tokenStart, pos);
+						if (declAttributes === null) declAttributes = Object.create(null);
+						declAttributes[token] = null;
+					}
+					if (pos < S.length && S.charCodeAt(pos) === LBRACKET) {
+						pos++;
+						let insideBracketSection = true;
+						while (insideBracketSection && pos < S.length) {
+							if (S.charCodeAt(pos) === RBRACKET) insideBracketSection = false;
+							else {
+								const quoteCharCode = S.charCodeAt(pos);
+								if (quoteCharCode === SQUOTE || quoteCharCode === DQUOTE) {
+									pos = S.indexOf(quoteCharCode === SQUOTE ? "'" : "\"", pos + 1);
+									if (pos === -1) {
+										pos = S.length;
+										break;
+									}
+								}
+							}
+							pos++;
+						}
+						while (pos < S.length && S.charCodeAt(pos) <= 32) pos++;
+					}
+					if (strict && (pos >= S.length || S.charCodeAt(pos) !== GT)) throw strictError("Unclosed declaration");
+					children.push({
+						tagName: declTagName,
+						attributes: declAttributes,
+						children: []
+					});
+				}
+				pos++;
+				continue;
+			}
+			pos++;
+			const tagName = parseName();
+			let attributes = null;
+			while (S.charCodeAt(pos) !== GT && S[pos]) {
+				let charCode = S.charCodeAt(pos);
+				if (charCode > 64 && charCode < 91 || charCode > 96 && charCode < 123 || charCode === UNDERSCORE || charCode === COLON || charCode > 127) {
+					const name = parseName();
+					let code = S.charCodeAt(pos);
+					while (code && code !== SQUOTE && code !== DQUOTE && !(code > 64 && code < 91 || code > 96 && code < 123 || code === UNDERSCORE || code === COLON || code > 127) && code !== GT) {
+						pos++;
+						code = S.charCodeAt(pos);
+					}
+					let value;
+					if (code === SQUOTE || code === DQUOTE) {
+						value = parseString();
+						if (pos === -1) {
+							const node = {
+								tagName,
+								attributes,
+								children: []
+							};
+							children.push(node);
+							while (stack.length > 0) {
+								const frame = stack.pop();
+								const parent = {
+									tagName: currentTagName,
+									attributes: frame.attributes,
+									children
+								};
+								currentTagName = frame.tagName;
+								children = frame.children;
+								children.push(parent);
+							}
+							return children;
+						}
+						if (decode) value = decode(value);
+					} else {
+						value = null;
+						pos--;
+					}
+					if (attributes === null) attributes = Object.create(null);
+					attributes[name] = value;
+				}
+				pos++;
+			}
+			if (strict && !S[pos]) throw strictError(`Unclosed tag <${tagName}>`);
+			if (S.charCodeAt(pos - 1) !== SLASH && S.charCodeAt(pos - 1) !== QUESTION && tagName.charCodeAt(0) !== BANG) if (rawContentSet !== null && rawContentSet.has(tagName)) {
+				const closeTagStr = "</" + tagName + ">";
+				const start = pos + 1;
+				pos = S.indexOf(closeTagStr, start);
+				let rawChildren;
+				if (pos === -1) {
+					if (strict) throw strictError(`Unclosed tag <${tagName}>`);
+					rawChildren = [S.substring(start)];
+					pos = S.length;
+				} else {
+					rawChildren = [S.substring(start, pos)];
+					pos += closeTagStr.length;
+				}
+				const node = {
+					tagName,
+					attributes,
+					children: rawChildren
+				};
+				children.push(node);
+				if (tagName.charCodeAt(0) === QUESTION) {
+					children.push(...node.children);
+					node.children = [];
+				}
+			} else if (selfClosingSet === null || !selfClosingSet.has(tagName)) {
+				pos++;
+				stack.push({
+					tagName: currentTagName,
+					attributes,
+					children
+				});
+				currentTagName = tagName;
+				children = [];
+			} else {
+				pos++;
+				const node = {
+					tagName,
+					attributes,
+					children: []
+				};
+				children.push(node);
+				if (tagName.charCodeAt(0) === QUESTION) {
+					children.push(...node.children);
+					node.children = [];
+				}
+			}
+			else {
+				pos++;
+				const node = {
+					tagName,
+					attributes,
+					children: []
+				};
+				children.push(node);
+				if (tagName.charCodeAt(0) === QUESTION) {
+					children.push(...node.children);
+					node.children = [];
+				}
+			}
+		} else {
+			let text = parseText();
+			if (decode) text = decode(text);
+			if (trimWhitespace) {
+				const trimmed = text.trim();
+				if (trimmed.length > 0) children.push(trimmed);
+			} else if (text.length > 0) children.push(text);
+			pos++;
+		}
+		if (strict && currentTagName !== "") throw strictError(`Unclosed tag <${currentTagName}>`);
+		stripIgnorableWhitespace(children);
+		while (stack.length > 0) {
+			const frame = stack.pop();
+			const node = {
+				tagName: currentTagName,
+				attributes: frame.attributes,
+				children
+			};
+			currentTagName = frame.tagName;
+			children = frame.children;
+			children.push(node);
+			stripIgnorableWhitespace(children);
+		}
+		return children;
+	}
+	function parseText() {
+		const start = pos;
+		pos = S.indexOf("<", pos) - 1;
+		if (pos === -2) pos = S.length;
+		return S.substring(start, pos + 1);
+	}
+	function parseName() {
+		const start = pos;
+		let charCode = S.charCodeAt(pos);
+		while (charCode < 128 ? NAME_END[charCode] === 0 : charCode === charCode) charCode = S.charCodeAt(++pos);
+		return S.substring(start, pos);
+	}
+	function parseNode() {
+		pos++;
+		const tagName = parseName();
+		let attributes = null;
+		let children = [];
+		while (S.charCodeAt(pos) !== GT && S[pos]) {
+			let charCode = S.charCodeAt(pos);
+			if (charCode > 64 && charCode < 91 || charCode > 96 && charCode < 123 || charCode === UNDERSCORE || charCode === COLON || charCode > 127) {
+				const name = parseName();
+				let code = S.charCodeAt(pos);
+				while (code && code !== SQUOTE && code !== DQUOTE && !(code > 64 && code < 91 || code > 96 && code < 123 || code === UNDERSCORE || code === COLON || code > 127) && code !== GT) {
+					pos++;
+					code = S.charCodeAt(pos);
+				}
+				let value;
+				if (code === SQUOTE || code === DQUOTE) {
+					value = parseString();
+					if (pos === -1) return {
+						tagName,
+						attributes,
+						children
+					};
+					if (decode) value = decode(value);
+				} else {
+					value = null;
+					pos--;
+				}
+				if (attributes === null) attributes = Object.create(null);
+				attributes[name] = value;
+			}
+			pos++;
+		}
+		if (strict && !S[pos]) throw strictError(`Unclosed tag <${tagName}>`);
+		if (S.charCodeAt(pos - 1) !== SLASH && S.charCodeAt(pos - 1) !== QUESTION && tagName.charCodeAt(0) !== BANG) if (rawContentSet !== null && rawContentSet.has(tagName)) {
+			const closeTag = "</" + tagName + ">";
+			const start = pos + 1;
+			pos = S.indexOf(closeTag, start);
+			if (pos === -1) {
+				if (strict) throw strictError(`Unclosed tag <${tagName}>`);
+				children = [S.substring(start)];
+				pos = S.length;
+			} else {
+				children = [S.substring(start, pos)];
+				pos += closeTag.length;
+			}
+		} else if (selfClosingSet === null || !selfClosingSet.has(tagName)) {
+			pos++;
+			children = parseChildren(tagName);
+		} else pos++;
+		else pos++;
+		return {
+			tagName,
+			attributes,
+			children
+		};
+	}
+	function parseString() {
+		const quoteCharCode = S.charCodeAt(pos);
+		const startPosition = pos + 1;
+		pos = S.indexOf(quoteCharCode === SQUOTE ? "'" : "\"", startPosition);
+		return S.substring(startPosition, pos);
+	}
+	function findElements() {
+		if (!resolvedOptions.attrName || !resolvedOptions.attrValue) return -1;
+		const matchResult = new RegExp("\\s" + escapeRegExp(resolvedOptions.attrName) + "\\s*=['\"]" + escapeRegExp(resolvedOptions.attrValue) + "['\"]").exec(S);
+		if (matchResult) return matchResult.index;
+		else return -1;
+	}
+	let out;
+	if (resolvedOptions.attrValue !== void 0) {
+		resolvedOptions.attrName = resolvedOptions.attrName || "id";
+		const results = [];
+		while ((pos = findElements()) !== -1) {
+			pos = S.lastIndexOf("<", pos);
+			if (pos !== -1) results.push(parseNode());
+			S = S.slice(pos);
+			pos = 0;
+		}
+		out = results;
+	} else if (resolvedOptions.parseNode) out = parseNode();
+	else out = parseChildren("");
+	if (resolvedOptions.filter && Array.isArray(out)) out = filter(out, resolvedOptions.filter);
+	if (resolvedOptions.setPos && typeof out === "object" && !Array.isArray(out)) out.pos = pos;
+	return out;
+}
+//#endregion
+export { filter as n, escapeRegExp as r, parse as t };
+
+//# sourceMappingURL=parser-CYq309aR.mjs.map

package/dist/parser-CYq309aR.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser-CYq309aR.mjs","names":[],"sources":["../src/utilities/escapeRegExp.ts","../src/utilities/filter.ts","../src/parser.ts"],"sourcesContent":["// RegExp.escape is not yet in the ES2023 lib typings\ndeclare global {\n  interface RegExpConstructor {\n    escape?: (s: string) => string;\n  }\n}\n\n/**\n * Escapes special regex characters in a string so it can be safely\n * interpolated into a `new RegExp(...)` pattern.\n *\n * Uses the native `RegExp.escape` when available (Node ≥ 24, Chrome ≥ 136,\n * Firefox ≥ 134, Safari ≥ 18.2), otherwise falls back to a manual replacement.\n * @internal\n */\nexport const escapeRegExp: (s: string) => string =\n  typeof RegExp.escape === 'function'\n    ? RegExp.escape\n    : (s) => s.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n","import type { TNode } from '#src/parser.ts';\nimport { parse } from '#src/parser.ts';\n\n/**\n * Filter nodes like Array.filter - returns nodes where the filter function returns true\n * @param input - XML string or array of nodes to filter\n * @param predicate - Filter function\n * @param depth - Current depth in the tree (internal use)\n * @param path - Current path in the tree (internal use)\n * @returns Filtered array of nodes\n */\nexport function filter(\n  input: string | (TNode | string)[],\n  predicate: (\n    node: TNode,\n    index: number,\n    depth: number,\n    path: string,\n  ) => boolean,\n  depth: number = 0,\n  path: string = '',\n): TNode[] {\n  const out: TNode[] = [];\n  filterInto(\n    out,\n    typeof input === 'string' ? parse(input) : input,\n    predicate,\n    depth,\n    path,\n  );\n  return out;\n}\n\nfunction filterInto(\n  out: TNode[],\n  children: (TNode | string)[],\n  predicate: (\n    node: TNode,\n    index: number,\n    depth: number,\n    path: string,\n  ) => boolean,\n  depth: number,\n  path: string,\n): void {\n  for (let i = 0; i < children.length; i++) {\n    const child = children[i]!;\n    if (typeof child === 'object') {\n      if (predicate(child, i, depth, path)) {\n        out.push(child);\n      }\n      if (child.children) {\n        filterInto(\n          out,\n          child.children,\n          predicate,\n          depth + 1,\n          (path ? path + '.' : '') + i + '.' + child.tagName,\n        );\n      }\n    }\n  }\n}\n","import { decodeXML, decodeHTML } from 'entities';\nimport { escapeRegExp } from '#src/utilities/escapeRegExp.ts';\nimport { filter } from '#src/utilities/filter.ts';\nimport {\n  HTML_VOID_ELEMENTS,\n  HTML_RAW_CONTENT_TAGS,\n} from '#src/utilities/htmlConstants.ts';\n// @generated:char-codes:begin\nconst LT = 60; // <\nconst GT = 62; // >\nconst SLASH = 47; // /\nconst BANG = 33; // !\nconst QUESTION = 63; // ?\nconst LBRACKET = 91; // [\nconst RBRACKET = 93; // ]\nconst SQUOTE = 39; // '\nconst DQUOTE = 34; // \"\nconst DASH = 45; // -\nconst UNDERSCORE = 95; // _\nconst COLON = 58; // :\n// @generated:char-codes:end\n\n/**\n * A parsed XML node\n */\nexport interface TNode {\n  tagName: string;\n  /**\n   * Element attributes, or `null` if the element has no attributes.\n   * Values can be:\n   * - string: attribute with a value (e.g., `<div id=\"test\">` -> `{id: \"test\"}`)\n   * - null: attribute without a value (e.g., `<input disabled>` -> `{disabled: null}`)\n   * - empty string: attribute with empty value (e.g., `<input value=\"\">` -> `{value: \"\"}`)\n   */\n  attributes: Record<string, string | null> | null;\n  children: (TNode | string)[];\n}\n\n/**\n * TNode with a pos property, returned when setPos option is true\n */\ninterface TNodeWithPos extends TNode {\n  pos: number;\n}\n\n/**\n * Options for parsing XML\n */\nexport interface ParseOptions {\n  /** Starting position in the string */\n  pos?: number;\n  /**\n   * Array of tag names that are self-closing (void elements) and don't need closing tags.\n   * In XML mode (default), this defaults to `[]` — self-closing is detected only by `/>` syntax.\n   * In HTML mode (`html: true`), this defaults to the standard HTML void elements.\n   * Can be overridden explicitly regardless of mode.\n   */\n  selfClosingTags?: string[];\n  /**\n   * Array of tag names whose content should be treated as raw text, not parsed as XML/HTML.\n   * The parser will scan for the matching `</tagName>` close tag and emit everything between\n   * as a single text child node.\n   *\n   * In XML mode (default), this defaults to `[]`.\n   * In HTML mode (`html: true`), this defaults to `[\"script\", \"style\"]`.\n   * Can be overridden explicitly regardless of mode.\n   */\n  rawContentTags?: string[];\n  /**\n   * Enable HTML parsing mode. When `true`, sets sensible defaults for:\n   * - `selfClosingTags`: standard HTML void elements (area, base, br, col, embed, hr, img, input, link, meta, param, source, track, wbr)\n   * - `rawContentTags`: elements whose content is raw text (script, style)\n   *\n   * These defaults can be overridden by explicitly passing `selfClosingTags` or `rawContentTags`.\n   */\n  html?: boolean;\n  /** Keep XML comments in the output */\n  keepComments?: boolean;\n  /** Trim whitespace from text nodes and discard whitespace-only text nodes */\n  trimWhitespace?: boolean;\n  /**\n   * Strict mode: throw on malformed XML instead of recovering silently.\n   * Catches unclosed comments, CDATA sections, processing instructions,\n   * close tags, and open tags that reach end-of-input without closing.\n   */\n  strict?: boolean;\n  /**\n   * Decode XML/HTML entities in text content and attribute values.\n   * When enabled, named entities (`&amp;`, `&lt;`, etc.), decimal character\n   * references (`&#228;`), and hex character references (`&#xe4;`) are decoded.\n   *\n   * In HTML mode (`html: true`), the full set of HTML named entities is\n   * supported (e.g. `&nbsp;`, `&copy;`, `&mdash;`). In XML mode, only the\n   * five standard XML entities plus numeric references are decoded.\n   *\n   * CDATA sections are never decoded regardless of this setting.\n   *\n   * Defaults to `false` — entities are preserved as-is in the output.\n   */\n  entities?: boolean;\n  /** Attribute name to search for (used with attrValue) */\n  attrName?: string;\n  /** Attribute value to search for (regex pattern) */\n  attrValue?: string;\n  /** Filter function to apply to nodes */\n  filter?: (node: TNode, index: number, depth: number, path: string) => boolean;\n}\n\n/** Internal options extending ParseOptions — not part of the public API. */\ninterface InternalParseOptions extends ParseOptions {\n  /** If true, the returned object will have a pos property indicating where parsing stopped */\n  setPos?: boolean;\n  /** Parse a single node instead of a list of nodes */\n  parseNode?: boolean;\n}\n\n// Pre-computed lookup table: 1 for characters that terminate a name token\n// Name-ending chars: \\t(9) \\n(10) \\r(13) space(32) /(47) =(61) >(62)\nconst NAME_END = new Uint8Array(128);\nNAME_END[9] = 1; // \\t\nNAME_END[10] = 1; // \\n\nNAME_END[13] = 1; // \\r\nNAME_END[32] = 1; // space\nNAME_END[47] = 1; // /\nNAME_END[61] = 1; // =\nNAME_END[62] = 1; // >\n\n/**\n * Parse XML/HTML into a DOM Object with minimal validation and fault tolerance\n * @param S - The XML string to parse\n * @param options - Parsing options\n * @returns Array of parsed nodes and text content\n */\nexport function parse(\n  S: string,\n  options?: ParseOptions | InternalParseOptions,\n): (TNode | string)[] {\n  const resolvedOptions = (options || {}) as InternalParseOptions;\n\n  let pos = resolvedOptions.pos || 0;\n  const keepComments = !!resolvedOptions.keepComments;\n  const trimWhitespace = !!resolvedOptions.trimWhitespace;\n  const strict = !!resolvedOptions.strict;\n  const htmlMode = !!resolvedOptions.html;\n  const decode =\n    resolvedOptions.entities === true\n      ? htmlMode\n        ? decodeHTML\n        : decodeXML\n      : null;\n\n  const selfClosingTagList: string[] =\n    resolvedOptions.selfClosingTags ?? (htmlMode ? HTML_VOID_ELEMENTS : []);\n  const rawContentTagList: string[] =\n    resolvedOptions.rawContentTags ?? (htmlMode ? HTML_RAW_CONTENT_TAGS : []);\n\n  // Convert to Sets for O(1) lookup when non-empty\n  const selfClosingSet: Set<string> | null =\n    selfClosingTagList.length > 0 ? new Set(selfClosingTagList) : null;\n  const rawContentSet: Set<string> | null =\n    rawContentTagList.length > 0 ? new Set(rawContentTagList) : null;\n\n  /** Build an error with line/column info for strict mode. */\n  function strictError(message: string, atPos?: number): Error {\n    const p = atPos !== undefined ? atPos : pos;\n    const before = S.substring(0, p);\n    const lines = before.split('\\n');\n    const line = lines.length;\n    const column = lines[lines.length - 1]!.length + 1;\n    return new Error(`${message} at line ${line}, column ${column}`);\n  }\n\n  /**\n   * Strip whitespace-only text nodes from a children array when it\n   * contains only element nodes and whitespace-only text (i.e. \"ignorable\n   * whitespace\" per XML spec). Mixed-content elements — those with at\n   * least one non-whitespace text child — are left untouched so that\n   * whitespace formatting is preserved.\n   * Mutates the array in-place for performance.\n   */\n  function stripIgnorableWhitespace(children: (TNode | string)[]): void {\n    let hasElement = false;\n    let hasWhitespaceOnlyText = false;\n    let hasNonWhitespaceText = false;\n    for (let i = 0; i < children.length; i++) {\n      const child = children[i]!;\n      if (typeof child !== 'string') {\n        hasElement = true;\n      } else if (child.trim().length === 0) {\n        hasWhitespaceOnlyText = true;\n      } else {\n        hasNonWhitespaceText = true;\n      }\n    }\n    // Only strip when children are exclusively elements + whitespace-only\n    // text (pure element containers). Mixed content is left intact.\n    if (hasElement && hasWhitespaceOnlyText && !hasNonWhitespaceText) {\n      // Compact in-place with a write pointer (avoids O(n) splice per removal)\n      let writeIndex = 0;\n      for (let i = 0; i < children.length; i++) {\n        const child = children[i]!;\n        if (typeof child === 'string' && child.trim().length === 0) continue;\n        children[writeIndex++] = child;\n      }\n      children.length = writeIndex;\n    }\n  }\n\n  function parseChildren(rootTagName: string): (TNode | string)[] {\n    // Iterative tree-building using an explicit stack to avoid\n    // stack overflow on deeply nested XML (the old recursive\n    // parseNode → parseChildren → parseNode chain blew up at ~2000 levels).\n    interface Frame {\n      tagName: string;\n      attributes: Record<string, string | null> | null;\n      children: (TNode | string)[];\n    }\n    const stack: Frame[] = [];\n    let currentTagName = rootTagName;\n    let children: (TNode | string)[] = [];\n\n    while (S[pos]) {\n      if (S.charCodeAt(pos) === LT) {\n        if (S.charCodeAt(pos + 1) === SLASH) {\n          // ---- Close tag ----\n          const closeStart = pos + 2;\n          pos = S.indexOf('>', pos);\n\n          if (pos === -1) {\n            if (strict) throw strictError('Unclosed close tag', closeStart - 2);\n            pos = S.length;\n            stripIgnorableWhitespace(children);\n            // Unwind: if we are inside a stacked frame, pop back\n            while (stack.length > 0) {\n              const frame = stack.pop()!;\n              const node: TNode = {\n                tagName: currentTagName,\n                attributes: frame.attributes,\n                children,\n              };\n              // Restore from stack\n              currentTagName = frame.tagName;\n              children = frame.children;\n              children.push(node);\n              stripIgnorableWhitespace(children);\n            }\n            return children;\n          }\n\n          const closeTag = S.substring(closeStart, pos).trimEnd();\n          if (closeTag !== currentTagName) {\n            throw strictError(\n              `Unexpected close tag </${closeTag}> (expected </${currentTagName}>)`,\n            );\n          }\n\n          if (pos + 1) pos += 1;\n\n          stripIgnorableWhitespace(children);\n\n          if (stack.length === 0) {\n            // We've closed the root tag — return\n            return children;\n          }\n\n          // Pop frame: finalize node and add to parent's children\n          const frame = stack.pop()!;\n          const node: TNode = {\n            tagName: currentTagName,\n            attributes: frame.attributes,\n            children,\n          };\n          currentTagName = frame.tagName;\n          children = frame.children;\n          children.push(node);\n          // Handle processing instruction children promotion\n          if (node.tagName.charCodeAt(0) === QUESTION) {\n            children.push(...node.children);\n            node.children = [];\n          }\n          continue;\n        } else if (S.charCodeAt(pos + 1) === BANG) {\n          if (S.charCodeAt(pos + 2) === DASH) {\n            // comment: use indexOf(\"-->\") for fast scanning\n            const startCommentPos = pos;\n            pos = S.indexOf('-->', pos + 3);\n            if (pos === -1) {\n              if (strict)\n                throw strictError('Unclosed comment', startCommentPos);\n              pos = S.length;\n              if (keepComments) {\n                children.push(S.substring(startCommentPos));\n              }\n            } else {\n              pos += 2; // point to the '>'\n              if (keepComments) {\n                children.push(S.substring(startCommentPos, pos + 1));\n              }\n            }\n          } else if (\n            S.charCodeAt(pos + 2) === LBRACKET &&\n            S.charCodeAt(pos + 8) === LBRACKET &&\n            S.substring(pos + 3, pos + 8).toLowerCase() === 'cdata'\n          ) {\n            // cdata\n            const cdataEndIndex = S.indexOf(']]>', pos);\n            if (cdataEndIndex === -1) {\n              if (strict) throw strictError('Unclosed CDATA section');\n              children.push(S.substring(pos + 9));\n              pos = S.length;\n            } else {\n              children.push(S.substring(pos + 9, cdataEndIndex));\n              pos = cdataEndIndex + 3;\n            }\n            continue;\n          } else {\n            // doctype / other <!...> declarations: parse as TNode\n            // Read the declaration keyword (e.g. \"!DOCTYPE\")\n            pos += 2; // skip '<!'\n            const keywordStart = pos - 1; // include the '!'\n            while (pos < S.length) {\n              const cc = S.charCodeAt(pos);\n              if (cc <= 32 || cc === GT || cc === LBRACKET) break;\n              pos++;\n            }\n            const declTagName = S.substring(keywordStart, pos);\n\n            // Parse space-separated tokens as null-valued attributes\n            let declAttributes: Record<string, string | null> | null = null;\n            while (pos < S.length) {\n              const cc = S.charCodeAt(pos);\n              if (cc === GT || cc === LBRACKET) break;\n              // Skip whitespace\n              if (cc <= 32) {\n                pos++;\n                continue;\n              }\n              // Quoted token — capture including quotes as the key\n              if (cc === SQUOTE || cc === DQUOTE) {\n                const closePos = S.indexOf(cc === SQUOTE ? \"'\" : '\"', pos + 1);\n                if (closePos === -1) {\n                  if (strict) throw strictError('Unclosed declaration');\n                  pos = S.length;\n                  break;\n                }\n                const token = S.substring(pos + 1, closePos);\n                if (declAttributes === null)\n                  declAttributes = Object.create(null);\n                declAttributes![token] = null;\n                pos = closePos + 1;\n                continue;\n              }\n              // Unquoted token\n              const tokenStart = pos;\n              while (pos < S.length) {\n                const tc = S.charCodeAt(pos);\n                if (tc <= 32 || tc === GT || tc === LBRACKET) break;\n                pos++;\n              }\n              const token = S.substring(tokenStart, pos);\n              if (declAttributes === null) declAttributes = Object.create(null);\n              declAttributes![token] = null;\n            }\n\n            // Skip internal DTD subset ([...]) if present\n            if (pos < S.length && S.charCodeAt(pos) === LBRACKET) {\n              pos++; // skip '['\n              let insideBracketSection = true;\n              while (insideBracketSection && pos < S.length) {\n                if (S.charCodeAt(pos) === RBRACKET) {\n                  insideBracketSection = false;\n                } else {\n                  // Skip quoted strings inside internal DTD subset\n                  const quoteCharCode = S.charCodeAt(pos);\n                  if (quoteCharCode === SQUOTE || quoteCharCode === DQUOTE) {\n                    pos = S.indexOf(\n                      quoteCharCode === SQUOTE ? \"'\" : '\"',\n                      pos + 1,\n                    );\n                    if (pos === -1) {\n                      pos = S.length;\n                      break;\n                    }\n                  }\n                }\n                pos++;\n              }\n              // Skip any whitespace between ] and >\n              while (pos < S.length && S.charCodeAt(pos) <= 32) pos++;\n            }\n\n            if (strict && (pos >= S.length || S.charCodeAt(pos) !== GT))\n              throw strictError('Unclosed declaration');\n\n            children.push({\n              tagName: declTagName,\n              attributes: declAttributes,\n              children: [],\n            } as TNode);\n          }\n          pos++;\n          continue;\n        }\n        // ---- Open tag (inline parseNode logic) ----\n        pos++;\n        const tagName = parseName();\n        let attributes: Record<string, string | null> | null = null;\n\n        // parsing attributes\n        while (S.charCodeAt(pos) !== GT && S[pos]) {\n          let charCode = S.charCodeAt(pos);\n          if (\n            (charCode > 64 && charCode < 91) ||\n            (charCode > 96 && charCode < 123) ||\n            charCode === UNDERSCORE ||\n            charCode === COLON ||\n            charCode > 127\n          ) {\n            const name = parseName();\n            let code = S.charCodeAt(pos);\n            while (\n              code &&\n              code !== SQUOTE &&\n              code !== DQUOTE &&\n              !(\n                (code > 64 && code < 91) ||\n                (code > 96 && code < 123) ||\n                code === UNDERSCORE ||\n                code === COLON ||\n                code > 127\n              ) &&\n              code !== GT\n            ) {\n              pos++;\n              code = S.charCodeAt(pos);\n            }\n            let value: string | null;\n            if (code === SQUOTE || code === DQUOTE) {\n              value = parseString();\n              if (pos === -1) {\n                // Unterminated attribute string — emit node with what we have\n                const node: TNode = { tagName, attributes, children: [] };\n                children.push(node);\n                // Unwind remaining stack frames\n                while (stack.length > 0) {\n                  const frame = stack.pop()!;\n                  const parent: TNode = {\n                    tagName: currentTagName,\n                    attributes: frame.attributes,\n                    children,\n                  };\n                  currentTagName = frame.tagName;\n                  children = frame.children;\n                  children.push(parent);\n                }\n                return children;\n              }\n              if (decode) value = decode(value);\n            } else {\n              value = null;\n              pos--;\n            }\n            if (attributes === null) attributes = Object.create(null);\n            attributes![name] = value;\n          }\n          pos++;\n        }\n        if (strict && !S[pos]) {\n          throw strictError(`Unclosed tag <${tagName}>`);\n        }\n\n        // Determine if this node has children or is self-closing\n        if (\n          S.charCodeAt(pos - 1) !== SLASH &&\n          S.charCodeAt(pos - 1) !== QUESTION &&\n          tagName.charCodeAt(0) !== BANG\n        ) {\n          if (rawContentSet !== null && rawContentSet.has(tagName)) {\n            // Raw content tag\n            const closeTagStr = '</' + tagName + '>';\n            const start = pos + 1;\n            pos = S.indexOf(closeTagStr, start);\n            let rawChildren: (TNode | string)[];\n            if (pos === -1) {\n              if (strict) throw strictError(`Unclosed tag <${tagName}>`);\n              rawChildren = [S.substring(start)];\n              pos = S.length;\n            } else {\n              rawChildren = [S.substring(start, pos)];\n              pos += closeTagStr.length;\n            }\n            const node: TNode = { tagName, attributes, children: rawChildren };\n            children.push(node);\n            if (tagName.charCodeAt(0) === QUESTION) {\n              children.push(...node.children);\n              node.children = [];\n            }\n          } else if (selfClosingSet === null || !selfClosingSet.has(tagName)) {\n            // Node has children — push frame and descend\n            pos++;\n            stack.push({ tagName: currentTagName, attributes, children });\n            currentTagName = tagName;\n            children = [];\n          } else {\n            // Self-closing tag (from selfClosingTags list)\n            pos++;\n            const node: TNode = { tagName, attributes, children: [] };\n            children.push(node);\n            if (tagName.charCodeAt(0) === QUESTION) {\n              children.push(...node.children);\n              node.children = [];\n            }\n          }\n        } else {\n          // Explicit self-closing (/>) or processing instruction (?>) or declaration\n          pos++;\n          const node: TNode = { tagName, attributes, children: [] };\n          children.push(node);\n          if (tagName.charCodeAt(0) === QUESTION) {\n            children.push(...node.children);\n            node.children = [];\n          }\n        }\n      } else {\n        let text = parseText();\n        if (decode) text = decode(text);\n        if (trimWhitespace) {\n          const trimmed = text.trim();\n          if (trimmed.length > 0) {\n            children.push(trimmed);\n          }\n        } else {\n          if (text.length > 0) {\n            children.push(text);\n          }\n        }\n        pos++;\n      }\n    }\n    // If we exit the loop for a named tag, input ended without a close tag\n    if (strict && currentTagName !== '') {\n      throw strictError(`Unclosed tag <${currentTagName}>`);\n    }\n    stripIgnorableWhitespace(children);\n    // Unwind any remaining stack frames (unclosed tags in non-strict mode)\n    while (stack.length > 0) {\n      const frame = stack.pop()!;\n      const node: TNode = {\n        tagName: currentTagName,\n        attributes: frame.attributes,\n        children,\n      };\n      currentTagName = frame.tagName;\n      children = frame.children;\n      children.push(node);\n      stripIgnorableWhitespace(children);\n    }\n    return children;\n  }\n\n  function parseText(): string {\n    const start = pos;\n    pos = S.indexOf('<', pos) - 1;\n    if (pos === -2) pos = S.length;\n    return S.substring(start, pos + 1);\n  }\n\n  function parseName(): string {\n    const start = pos;\n    let charCode = S.charCodeAt(pos);\n    while (\n      charCode < 128\n        ? NAME_END[charCode] === 0\n        : charCode === charCode /* not NaN = not past end */\n    ) {\n      charCode = S.charCodeAt(++pos);\n    }\n    return S.substring(start, pos);\n  }\n\n  function parseNode(): TNode {\n    pos++;\n    const tagName = parseName();\n    // Defer attributes allocation until first attribute is found\n    let attributes: Record<string, string | null> | null = null;\n    let children: (TNode | string)[] = [];\n\n    // parsing attributes\n    while (S.charCodeAt(pos) !== GT && S[pos]) {\n      let charCode = S.charCodeAt(pos);\n      // Valid XML attribute name start: A-Z, a-z, _, :, or non-ASCII\n      if (\n        (charCode > 64 && charCode < 91) ||\n        (charCode > 96 && charCode < 123) ||\n        charCode === UNDERSCORE ||\n        charCode === COLON ||\n        charCode > 127\n      ) {\n        const name = parseName();\n        // search beginning of the string\n        let code = S.charCodeAt(pos);\n        while (\n          code &&\n          code !== SQUOTE &&\n          code !== DQUOTE &&\n          !(\n            (code > 64 && code < 91) ||\n            (code > 96 && code < 123) ||\n            code === UNDERSCORE ||\n            code === COLON ||\n            code > 127\n          ) &&\n          code !== GT\n        ) {\n          pos++;\n          code = S.charCodeAt(pos);\n        }\n        let value: string | null;\n        if (code === SQUOTE || code === DQUOTE) {\n          value = parseString();\n          if (pos === -1) {\n            return { tagName, attributes, children };\n          }\n          if (decode) value = decode(value);\n        } else {\n          value = null;\n          pos--;\n        }\n        // Allocate attributes object lazily on first attribute\n        if (attributes === null) attributes = Object.create(null);\n        attributes![name] = value;\n      }\n      pos++;\n    }\n    if (strict && !S[pos]) {\n      throw strictError(`Unclosed tag <${tagName}>`);\n    }\n    // optional parsing of children\n    // Self-closing: explicit />, processing instruction ?>, or declaration <!...>\n    if (\n      S.charCodeAt(pos - 1) !== SLASH &&\n      S.charCodeAt(pos - 1) !== QUESTION &&\n      tagName.charCodeAt(0) !== BANG\n    ) {\n      if (rawContentSet !== null && rawContentSet.has(tagName)) {\n        // Raw content tag: scan for the matching close tag and emit content as raw text\n        const closeTag = '</' + tagName + '>';\n        const start = pos + 1;\n        pos = S.indexOf(closeTag, start);\n        if (pos === -1) {\n          if (strict) throw strictError(`Unclosed tag <${tagName}>`);\n          // Unclosed raw content tag: consume the rest of the string\n          children = [S.substring(start)];\n          pos = S.length;\n        } else {\n          children = [S.substring(start, pos)];\n          pos += closeTag.length;\n        }\n      } else if (selfClosingSet === null || !selfClosingSet.has(tagName)) {\n        pos++;\n        children = parseChildren(tagName);\n      } else {\n        pos++;\n      }\n    } else {\n      pos++;\n    }\n    return { tagName, attributes, children };\n  }\n\n  function parseString(): string {\n    const quoteCharCode = S.charCodeAt(pos);\n    const startPosition = pos + 1;\n    pos = S.indexOf(quoteCharCode === SQUOTE ? \"'\" : '\"', startPosition);\n    return S.substring(startPosition, pos);\n  }\n\n  function findElements(): number {\n    if (!resolvedOptions.attrName || !resolvedOptions.attrValue) return -1;\n    const matchResult = new RegExp(\n      '\\\\s' +\n        escapeRegExp(resolvedOptions.attrName) +\n        '\\\\s*=[\\'\"]' +\n        escapeRegExp(resolvedOptions.attrValue) +\n        '[\\'\"]',\n    ).exec(S);\n    if (matchResult) {\n      return matchResult.index;\n    } else {\n      return -1;\n    }\n  }\n\n  let out: (TNode | string)[] | TNode;\n\n  if (resolvedOptions.attrValue !== undefined) {\n    resolvedOptions.attrName = resolvedOptions.attrName || 'id';\n    const results: (TNode | string)[] = [];\n\n    while ((pos = findElements()) !== -1) {\n      pos = S.lastIndexOf('<', pos);\n      if (pos !== -1) {\n        results.push(parseNode());\n      }\n      S = S.slice(pos);\n      pos = 0;\n    }\n    out = results;\n  } else if (resolvedOptions.parseNode) {\n    out = parseNode();\n  } else {\n    out = parseChildren('');\n  }\n\n  if (resolvedOptions.filter && Array.isArray(out)) {\n    out = filter(out, resolvedOptions.filter);\n  }\n\n  if (\n    resolvedOptions.setPos &&\n    typeof out === 'object' &&\n    !Array.isArray(out)\n  ) {\n    (out as TNodeWithPos).pos = pos;\n  }\n\n  return out as (TNode | string)[];\n}\n"],"mappings":"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"}

package/dist/parser.d.mts

@@ -0,0 +1,2 @@
+import { n as TNode, r as parse, t as ParseOptions } from "./parser-BfdEfWDg.mjs";
+export { ParseOptions, TNode, parse };

package/dist/parser.mjs

@@ -0,0 +1,2 @@
+import { t as parse } from "./parser-CYq309aR.mjs";
+export { parse };

package/dist/sax.d.mts

@@ -0,0 +1,64 @@
+//#region src/saxEngine.d.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 +=.
+ */
+/** Attributes record emitted with opentag events. */
+type Attributes = Record<string, string | null>;
+//#endregion
+//#region src/sax.d.ts
+/** Event name → handler signature map for the SAX parser. */
+interface SaxEventMap {
+  openTag: (tagName: string, attributes: Attributes) => void;
+  closeTag: (tagName: string) => void;
+  text: (text: string) => void;
+  cdata: (data: string) => void;
+  comment: (comment: string) => void;
+  processingInstruction: (name: string, body: string) => void;
+  doctype: (tagName: string, attributes: Attributes) => void;
+}
+/** SAX event names. */
+type SaxEventName = keyof SaxEventMap;
+/** EventEmitter-style SAX parser returned by `createSaxParser()`. */
+interface SaxParser {
+  /** Register an event handler. */
+  on<E extends SaxEventName>(event: E, handler: SaxEventMap[E]): void;
+  /** Remove an event handler. */
+  off<E extends SaxEventName>(event: E, handler: SaxEventMap[E]): void;
+  /** Feed a chunk of XML to the parser. */
+  write(chunk: string): void;
+  /** Signal end-of-input and flush any remaining buffered data. */
+  close(): void;
+}
+/** Options for `createSaxParser()`. */
+interface SaxParserOptions {
+  /**
+   * Enable HTML mode. Sets `selfClosingTags` and `rawContentTags` to their
+   * HTML defaults unless explicitly provided.
+   */
+  html?: boolean;
+  /** Tag names that are self-closing (void). Defaults to HTML voids when `html: true`. */
+  selfClosingTags?: string[];
+  /** Tag names whose content is raw text. Defaults to `['script', 'style']` when `html: true`. */
+  rawContentTags?: string[];
+}
+/**
+ * Create an EventEmitter-style SAX parser.
+ *
+ * Uses the internal SAX engine, but wraps it with `.on()` / `.off()` methods
+ * so handlers can be added and removed dynamically.
+ *
+ * @param options - Parser options (html mode, selfClosingTags, rawContentTags).
+ * @returns A SaxParser with `.on()`, `.off()`, `.write()`, `.close()`.
+ */
+declare function createSaxParser(options?: SaxParserOptions): SaxParser;
+//#endregion
+export { SaxEventMap, SaxEventName, SaxParser, SaxParserOptions, createSaxParser };
+//# sourceMappingURL=sax.d.mts.map

package/dist/sax.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sax.d.mts","names":[],"sources":["../src/saxEngine.ts","../src/sax.ts"],"mappings":";;AAsCA;;;;;;;;ACNA;;;KDMY,UAAA,GAAa,MAAA;;;;UCNR,WAAA;EACf,OAAA,GAAU,OAAA,UAAiB,UAAA,EAAY,UAAA;EACvC,QAAA,GAAW,OAAA;EACX,IAAA,GAAO,IAAA;EACP,KAAA,GAAQ,IAAA;EACR,OAAA,GAAU,OAAA;EACV,qBAAA,GAAwB,IAAA,UAAc,IAAA;EACtC,OAAA,GAAU,OAAA,UAAiB,UAAA,EAAY,UAAA;AAAA;;KAI7B,YAAA,SAAqB,WAAA;;UAGhB,SAAA;EAHL;EAKV,EAAA,WAAa,YAAA,EAAc,KAAA,EAAO,CAAA,EAAG,OAAA,EAAS,WAAA,CAAY,CAAA;;EAE1D,GAAA,WAAc,YAAA,EAAc,KAAA,EAAO,CAAA,EAAG,OAAA,EAAS,WAAA,CAAY,CAAA;EAPjB;EAS1C,KAAA,CAAM,KAAA;EANkB;EAQxB,KAAA;AAAA;;UAQe,gBAAA;EAd2C;;;;EAmB1D,IAAA;EAjB4D;EAmB5D,eAAA;EArBA;EAuBA,cAAA;AAAA;;;;;;;;;;iBAgBc,eAAA,CAAgB,OAAA,GAAU,gBAAA,GAAmB,SAAA"}