@eksml/xml 0.1.0

package/dist/writer.mjs

@@ -0,0 +1,357 @@
+import { n as HTML_VOID_ELEMENTS } from "./htmlConstants-D6fsKbZ-.mjs";
+import { fromLossy } from "./converters/fromLossy.mjs";
+import { fromLossless } from "./converters/fromLossless.mjs";
+import { escapeAttribute, escapeText, escapeUTF8 } from "entities";
+//#region src/writer.ts
+const BANG = 33;
+const QUESTION = 63;
+/**
+* Characters forbidden in XML tag names and attribute names.
+* Covers structural delimiters (`<`, `>`, `=`), quote characters, and
+* whitespace that would break well-formedness if interpolated unchecked.
+*/
+const INVALID_NAME_CHARS = /[<>=\s"']/;
+function validateTagName(tag) {
+	if (tag.length === 0) throw new Error("Invalid tag name: tag name must not be empty");
+	const name = tag.charCodeAt(0) === QUESTION || tag.charCodeAt(0) === BANG ? tag.substring(1) : tag;
+	if (name.length === 0) return;
+	if (INVALID_NAME_CHARS.test(name)) throw new Error(`Invalid tag name: "${tag}" contains forbidden characters`);
+}
+function validateAttributeNames(attributes) {
+	const keys = Object.keys(attributes);
+	for (let i = 0; i < keys.length; i++) {
+		const key = keys[i];
+		if (key.length === 0 || INVALID_NAME_CHARS.test(key)) throw new Error(`Invalid attribute name: "${key}" contains forbidden characters`);
+	}
+}
+/**
+* Recursion depth at which the circular-reference WeakSet guard kicks in.
+* Below this depth, no WeakSet overhead is incurred — the natural call-stack
+* limit provides a safety net. Typical XML documents have depth < 10.
+*/
+const CIRCULAR_CHECK_DEPTH = 16;
+function write(input, options) {
+	if (!input) return "";
+	const dom = toDom(input);
+	if (!options || !options.pretty && !options.entities && !options.html) return compactWrite(dom);
+	return fullWriter(dom, options);
+}
+/**
+* Test whether a string is a simple keyword that can appear unquoted in a
+* DOCTYPE declaration (e.g. `html`, `PUBLIC`, `SYSTEM`).
+* Anything else (URIs, public identifiers) must be double-quoted.
+*/
+const SIMPLE_KEYWORD = /^[A-Za-z][A-Za-z0-9_-]*$/;
+function compactWrite(input) {
+	let out = "";
+	let seen = null;
+	function writeChildren(nodes, depth) {
+		for (let i = 0; i < nodes.length; i++) {
+			const node = nodes[i];
+			if (typeof node === "string") out += node;
+			else writeNode(node, depth);
+		}
+	}
+	function writeNode(node, depth) {
+		if (depth >= CIRCULAR_CHECK_DEPTH) {
+			if (seen === null) seen = /* @__PURE__ */ new WeakSet();
+			if (seen.has(node)) throw new Error("Circular reference detected in TNode tree");
+			seen.add(node);
+		}
+		const tag = node.tagName;
+		validateTagName(tag);
+		const attributes = node.attributes;
+		const firstChar = tag.charCodeAt(0);
+		if (attributes !== null && firstChar !== BANG) validateAttributeNames(attributes);
+		if (attributes === null) {
+			if (firstChar === QUESTION) {
+				out += "<" + tag + "?>";
+				return;
+			}
+			if (firstChar === BANG) {
+				out += "<" + tag + ">";
+				return;
+			}
+			out += "<" + tag + ">";
+		} else {
+			out += "<" + tag;
+			const isDeclaration = firstChar === BANG;
+			const keys = Object.keys(attributes);
+			for (let j = 0; j < keys.length; j++) {
+				const attributeName = keys[j];
+				const attributeValue = attributes[attributeName];
+				if (attributeValue === null) if (isDeclaration && !SIMPLE_KEYWORD.test(attributeName)) out += " \"" + attributeName + "\"";
+				else out += " " + attributeName;
+				else if (attributeValue.indexOf("\"") === -1) out += " " + attributeName + "=\"" + attributeValue + "\"";
+				else if (attributeValue.indexOf("'") === -1) out += " " + attributeName + "='" + attributeValue + "'";
+				else out += " " + attributeName + "='" + attributeValue.replace(/'/g, "&apos;") + "'";
+			}
+			if (firstChar === QUESTION) {
+				out += "?>";
+				return;
+			}
+			if (firstChar === BANG) {
+				out += ">";
+				return;
+			}
+			out += ">";
+		}
+		writeChildren(node.children, depth + 1);
+		out += "</" + tag + ">";
+	}
+	writeChildren(Array.isArray(input) ? input : [input], 0);
+	return out;
+}
+function fullWriter(input, options) {
+	const indent = !options.pretty ? "" : typeof options.pretty === "string" ? options.pretty : "  ";
+	const encodeEntities = !!options.entities;
+	const htmlMode = !!options.html;
+	const encodeRawText = encodeEntities ? htmlMode ? escapeUTF8 : escapeText : (input) => input;
+	/** Encode text content, but pass comments through verbatim. */
+	const encodeTextContent = (input) => input.startsWith("<!--") ? input : encodeRawText(input);
+	const encodeAttributeValue = encodeEntities ? htmlMode ? escapeUTF8 : escapeAttribute : (input) => input;
+	const voidSet = htmlMode ? new Set(HTML_VOID_ELEMENTS) : null;
+	if (!indent) {
+		let out = "";
+		let seen = null;
+		function writeChildren(nodes, depth) {
+			for (let i = 0; i < nodes.length; i++) {
+				const node = nodes[i];
+				if (typeof node === "string") out += encodeTextContent(node);
+				else writeNode(node, depth);
+			}
+		}
+		function writeNode(node, depth) {
+			if (depth >= CIRCULAR_CHECK_DEPTH) {
+				if (seen === null) seen = /* @__PURE__ */ new WeakSet();
+				if (seen.has(node)) throw new Error("Circular reference detected in TNode tree");
+				seen.add(node);
+			}
+			const tag = node.tagName;
+			validateTagName(tag);
+			const attributes = node.attributes;
+			const firstChar = tag.charCodeAt(0);
+			if (attributes !== null && firstChar !== BANG) validateAttributeNames(attributes);
+			if (attributes === null) {
+				if (firstChar === QUESTION) {
+					out += "<" + tag + "?>";
+					return;
+				}
+				if (firstChar === BANG) {
+					out += "<" + tag + ">";
+					return;
+				}
+				if (voidSet !== null && voidSet.has(tag)) {
+					out += "<" + tag + ">";
+					return;
+				}
+				out += "<" + tag + ">";
+			} else {
+				out += "<" + tag;
+				const isDeclaration = firstChar === BANG;
+				const keys = Object.keys(attributes);
+				for (let j = 0; j < keys.length; j++) {
+					const attributeName = keys[j];
+					const attributeValue = attributes[attributeName];
+					if (attributeValue === null) if (isDeclaration && !SIMPLE_KEYWORD.test(attributeName)) out += " \"" + attributeName + "\"";
+					else out += " " + attributeName;
+					else {
+						const encoded = encodeAttributeValue(attributeValue);
+						if (encoded.indexOf("\"") === -1) out += " " + attributeName + "=\"" + encoded + "\"";
+						else if (encoded.indexOf("'") === -1) out += " " + attributeName + "='" + encoded + "'";
+						else out += " " + attributeName + "='" + encoded.replace(/'/g, "&apos;") + "'";
+					}
+				}
+				if (firstChar === QUESTION) {
+					out += "?>";
+					return;
+				}
+				if (firstChar === BANG) {
+					out += ">";
+					return;
+				}
+				if (voidSet !== null && voidSet.has(tag)) {
+					out += ">";
+					return;
+				}
+				out += ">";
+			}
+			writeChildren(node.children, depth + 1);
+			out += "</" + tag + ">";
+		}
+		writeChildren(Array.isArray(input) ? input : [input], 0);
+		return out;
+	}
+	let out = "";
+	let seen = null;
+	function hasTextChildren(nodes) {
+		for (let i = 0; i < nodes.length; i++) {
+			const node = nodes[i];
+			if (typeof node === "string" && !node.startsWith("<!--")) return true;
+		}
+		return false;
+	}
+	function prettyWriteAttributes(node, isDeclaration = false) {
+		if (node.attributes === null) return;
+		const keys = Object.keys(node.attributes);
+		for (let j = 0; j < keys.length; j++) {
+			const key = keys[j];
+			const attributeValue = node.attributes[key];
+			if (attributeValue === null) if (isDeclaration && !SIMPLE_KEYWORD.test(key)) out += " \"" + key + "\"";
+			else out += " " + key;
+			else {
+				const encoded = encodeAttributeValue(attributeValue);
+				if (encoded.indexOf("\"") === -1) out += " " + key + "=\"" + encoded + "\"";
+				else if (encoded.indexOf("'") === -1) out += " " + key + "='" + encoded + "'";
+				else out += " " + key + "='" + encoded.replace(/'/g, "&apos;") + "'";
+			}
+		}
+	}
+	function prettyWriteNode(node, depth) {
+		if (!node) return;
+		if (depth >= CIRCULAR_CHECK_DEPTH) {
+			if (seen === null) seen = /* @__PURE__ */ new WeakSet();
+			if (seen.has(node)) throw new Error("Circular reference detected in TNode tree");
+			seen.add(node);
+		}
+		const tag = node.tagName;
+		validateTagName(tag);
+		const padding = indent.repeat(depth);
+		const firstChar = tag.charCodeAt(0);
+		if (node.attributes !== null && firstChar !== BANG) validateAttributeNames(node.attributes);
+		if (firstChar === QUESTION) {
+			out += padding + "<" + tag;
+			prettyWriteAttributes(node);
+			out += "?>";
+			return;
+		}
+		if (firstChar === BANG) {
+			out += padding + "<" + tag;
+			prettyWriteAttributes(node, true);
+			out += ">";
+			return;
+		}
+		const children = node.children;
+		const childrenLength = children.length;
+		if (voidSet !== null && voidSet.has(tag)) {
+			out += padding + "<" + tag;
+			prettyWriteAttributes(node);
+			out += ">";
+			return;
+		}
+		if (childrenLength === 0) {
+			out += padding + "<" + tag;
+			prettyWriteAttributes(node);
+			out += "/>";
+			return;
+		}
+		const hasText = hasTextChildren(children);
+		let hasElements = false;
+		if (hasText) {
+			for (let i = 0; i < childrenLength; i++) if (typeof children[i] !== "string") {
+				hasElements = true;
+				break;
+			}
+		}
+		if (hasText && !hasElements) {
+			out += padding + "<" + tag;
+			prettyWriteAttributes(node);
+			out += ">";
+			let first = true;
+			for (let i = 0; i < childrenLength; i++) {
+				const text = children[i].trim();
+				if (text.length === 0) continue;
+				if (!first) out += " ";
+				first = false;
+				out += encodeTextContent(text);
+			}
+			out += "</" + tag + ">";
+			return;
+		}
+		if (hasText) {
+			const childPadding = indent.repeat(depth + 1);
+			out += padding + "<" + tag;
+			prettyWriteAttributes(node);
+			out += ">";
+			for (let i = 0; i < childrenLength; i++) {
+				const child = children[i];
+				if (typeof child === "string") if (child.startsWith("<!--")) out += "\n" + childPadding + encodeTextContent(child);
+				else {
+					const trimmed = child.trim();
+					if (trimmed.length > 0) out += "\n" + childPadding + encodeTextContent(trimmed);
+				}
+				else {
+					out += "\n";
+					prettyWriteNode(child, depth + 1);
+				}
+			}
+			out += "\n" + padding + "</" + tag + ">";
+			return;
+		}
+		out += padding + "<" + tag;
+		prettyWriteAttributes(node);
+		out += ">";
+		for (let i = 0; i < childrenLength; i++) {
+			const child = children[i];
+			if (typeof child === "string") out += "\n" + indent.repeat(depth + 1) + encodeTextContent(child);
+			else {
+				out += "\n";
+				prettyWriteNode(child, depth + 1);
+			}
+		}
+		out += "\n" + padding + "</" + tag + ">";
+	}
+	const nodes = Array.isArray(input) ? input : [input];
+	for (let i = 0; i < nodes.length; i++) {
+		const node = nodes[i];
+		if (i > 0) out += "\n";
+		if (typeof node === "string") out += encodeTextContent(node);
+		else prettyWriteNode(node, 0);
+	}
+	return out;
+}
+/**
+* Detect the input format and convert to a `(TNode | string)[]` DOM array
+* suitable for the writer functions.
+*
+* Detection heuristics:
+* 1. A single TNode (has `tagName` string property) → pass through
+* 2. An array whose first non-string element has `tagName` → already DOM
+* 3. An array whose first non-string element has `$text`, `$comment`, `$attr`,
+*    or a single key mapping to an array → lossless format
+* 4. Anything else (including `null`, bare strings, objects without `tagName`) → lossy
+*/
+function toDom(input) {
+	if (input === null || input === void 0) return [];
+	if (!Array.isArray(input) && typeof input === "object" && isTNode(input)) return input;
+	if (!Array.isArray(input) && typeof input !== "object") return fromLossy(input);
+	if (!Array.isArray(input)) return fromLossy(input);
+	const array = input;
+	if (array.length === 0) return [];
+	let sample = void 0;
+	for (let i = 0; i < array.length; i++) if (typeof array[i] !== "string") {
+		sample = array[i];
+		break;
+	}
+	if (sample === void 0) return array;
+	if (typeof sample === "object" && sample !== null && isTNode(sample)) return array;
+	if (typeof sample === "object" && sample !== null && isLosslessEntry(sample)) return fromLossless(array);
+	return fromLossy(array);
+}
+/** Check if a value looks like a TNode (has tagName string + children array). */
+function isTNode(value) {
+	return typeof value === "object" && value !== null && typeof value.tagName === "string" && Array.isArray(value.children);
+}
+/** Check if a value looks like a LosslessEntry. */
+function isLosslessEntry(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const keys = Object.keys(value);
+	if (keys.length === 0) return false;
+	if ("$text" in value || "$comment" in value || "$attr" in value) return true;
+	if (keys.length === 1 && Array.isArray(value[keys[0]])) return true;
+	return false;
+}
+//#endregion
+export { write };
+
+//# sourceMappingURL=writer.mjs.map

package/dist/writer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"writer.mjs","names":[],"sources":["../src/writer.ts"],"sourcesContent":["import { escapeText, escapeAttribute, escapeUTF8 } from 'entities';\nimport type { TNode } from '#src/parser.ts';\nimport type { LossyValue } from '#src/converters/lossy.ts';\nimport type { LosslessEntry } from '#src/converters/lossless.ts';\nimport { fromLossy } from '#src/converters/fromLossy.ts';\nimport { fromLossless } from '#src/converters/fromLossless.ts';\nimport { HTML_VOID_ELEMENTS } from '#src/utilities/htmlConstants.ts';\n// @generated:char-codes:begin\nconst BANG = 33; // !\nconst QUESTION = 63; // ?\n// @generated:char-codes:end\n\n/**\n * Characters forbidden in XML tag names and attribute names.\n * Covers structural delimiters (`<`, `>`, `=`), quote characters, and\n * whitespace that would break well-formedness if interpolated unchecked.\n */\nconst INVALID_NAME_CHARS = /[<>=\\s\"']/;\n\nfunction validateTagName(tag: string): void {\n  if (tag.length === 0) {\n    throw new Error('Invalid tag name: tag name must not be empty');\n  }\n  // Allow leading `?` (PI) or `!` (DOCTYPE), validate the rest\n  const name =\n    tag.charCodeAt(0) === QUESTION || tag.charCodeAt(0) === BANG\n      ? tag.substring(1)\n      : tag;\n  if (name.length === 0) return; // bare `?` or `!` is degenerate but harmless\n  if (INVALID_NAME_CHARS.test(name)) {\n    throw new Error(`Invalid tag name: \"${tag}\" contains forbidden characters`);\n  }\n}\n\nfunction validateAttributeNames(attributes: Record<string, unknown>): void {\n  const keys = Object.keys(attributes);\n  for (let i = 0; i < keys.length; i++) {\n    const key = keys[i]!;\n    if (key.length === 0 || INVALID_NAME_CHARS.test(key)) {\n      throw new Error(\n        `Invalid attribute name: \"${key}\" contains forbidden characters`,\n      );\n    }\n  }\n}\n\n/**\n * Recursion depth at which the circular-reference WeakSet guard kicks in.\n * Below this depth, no WeakSet overhead is incurred — the natural call-stack\n * limit provides a safety net. Typical XML documents have depth < 10.\n */\nconst CIRCULAR_CHECK_DEPTH = 16;\n\n/** Options for write. */\nexport interface WriterOptions {\n  /**\n   * Pretty-print with indentation. When enabled, each element is placed on\n   * its own line with proper nesting indentation.\n   *\n   * - `true` uses two spaces as the indent.\n   * - A string value is used as the indent directly (e.g. `\"\\t\"`, `\"    \"`).\n   *\n   * Text-only elements are kept inline: `<name>Alice</name>`.\n   * Mixed content (text interleaved with elements) is also kept inline to\n   * avoid altering whitespace semantics.\n   */\n  pretty?: boolean | string;\n  /**\n   * Encode special characters in text content and attribute values as XML\n   * entities. In XML mode (default), `&`, `<`, `>` are encoded in text and\n   * `&`, `\"`, `'` are encoded in attributes. In HTML mode (`html: true`),\n   * the full HTML named entity set is used (e.g. `&copy;`, `&eacute;`).\n   *\n   * Defaults to `false` — text and attribute values are written verbatim.\n   */\n  entities?: boolean;\n  /**\n   * Enable HTML mode. When enabled:\n   * - Void elements (`<br>`, `<img>`, `<hr>`, etc.) are self-closed without\n   *   a closing tag (e.g. `<br>` instead of `<br></br>` or `<br/>`).\n   * - When `entities` is also `true`, uses HTML named entities\n   *   (e.g. `&copy;` instead of `&#xa9;`) for encoding.\n   */\n  html?: boolean;\n}\n\n/** Input types accepted by `write()`. */\nexport type WriterInput =\n  | TNode\n  | (TNode | string)[]\n  | LossyValue\n  | LossyValue[]\n  | LosslessEntry[];\n\n/**\n * Serialize a parsed DOM, lossy object, or lossless entry array back to XML.\n *\n * Input format is auto-detected:\n * - `TNode` or `(TNode | string)[]` — DOM tree, serialized directly\n * - `LossyValue` or `LossyValue[]` — converted to DOM via `fromLossy()` first\n * - `LosslessEntry[]` — converted to DOM via `fromLossless()` first\n *\n * @param input - The node(s), lossy object(s), or lossless entries to serialize\n * @param options - Formatting options\n * @returns XML string\n */\nexport function write(\n  input: TNode | (TNode | string)[],\n  options?: WriterOptions,\n): string;\nexport function write(\n  input: LossyValue | LossyValue[],\n  options?: WriterOptions,\n): string;\nexport function write(input: LosslessEntry[], options?: WriterOptions): string;\nexport function write(input: WriterInput, options?: WriterOptions): string;\nexport function write(input: WriterInput, options?: WriterOptions): string {\n  if (!input) return '';\n\n  const dom = toDom(input);\n\n  // Fast path: no options — skip all option parsing, closure creation,\n  // identity function allocation, and voidSet construction.\n  if (!options || (!options.pretty && !options.entities && !options.html)) {\n    return compactWrite(dom);\n  }\n\n  return fullWriter(dom, options);\n}\n\n// ---------------------------------------------------------------------------\n// Fast path — compact output, no entities, no HTML mode\n// ---------------------------------------------------------------------------\n\n/**\n * Test whether a string is a simple keyword that can appear unquoted in a\n * DOCTYPE declaration (e.g. `html`, `PUBLIC`, `SYSTEM`).\n * Anything else (URIs, public identifiers) must be double-quoted.\n */\nconst SIMPLE_KEYWORD = /^[A-Za-z][A-Za-z0-9_-]*$/;\n\nfunction compactWrite(input: TNode | (TNode | string)[]): string {\n  let out = '';\n  let seen: WeakSet<TNode> | null = null;\n\n  function writeChildren(nodes: (TNode | string)[], depth: number): void {\n    for (let i = 0; i < nodes.length; i++) {\n      const node = nodes[i]!;\n      if (typeof node === 'string') {\n        out += node;\n      } else {\n        writeNode(node, depth);\n      }\n    }\n  }\n\n  function writeNode(node: TNode, depth: number): void {\n    if (depth >= CIRCULAR_CHECK_DEPTH) {\n      if (seen === null) seen = new WeakSet<TNode>();\n      if (seen.has(node)) {\n        throw new Error('Circular reference detected in TNode tree');\n      }\n      seen.add(node);\n    }\n    const tag = node.tagName;\n    validateTagName(tag);\n    const attributes = node.attributes;\n    const firstChar = tag.charCodeAt(0);\n    // Skip attribute name validation for declarations (!DOCTYPE etc.)\n    // where keys are quoted identifiers, not XML attribute names\n    if (attributes !== null && firstChar !== BANG) {\n      validateAttributeNames(attributes);\n    }\n    if (attributes === null) {\n      // No attributes — combine open tag into one concat\n      if (firstChar === QUESTION) {\n        out += '<' + tag + '?>';\n        return;\n      }\n      if (firstChar === BANG) {\n        out += '<' + tag + '>';\n        return;\n      }\n      out += '<' + tag + '>';\n    } else {\n      out += '<' + tag;\n      const isDeclaration = firstChar === BANG;\n      const keys = Object.keys(attributes);\n      for (let j = 0; j < keys.length; j++) {\n        const attributeName = keys[j]!;\n        const attributeValue = attributes[attributeName];\n        if (attributeValue === null) {\n          if (isDeclaration && !SIMPLE_KEYWORD.test(attributeName)) {\n            out += ' \"' + attributeName + '\"';\n          } else {\n            out += ' ' + attributeName;\n          }\n        } else if (attributeValue.indexOf('\"') === -1) {\n          out += ' ' + attributeName + '=\"' + attributeValue + '\"';\n        } else if (attributeValue.indexOf(\"'\") === -1) {\n          out += ' ' + attributeName + \"='\" + attributeValue + \"'\";\n        } else {\n          // Value contains both quote types — escape single quotes\n          out +=\n            ' ' +\n            attributeName +\n            \"='\" +\n            attributeValue.replace(/'/g, '&apos;') +\n            \"'\";\n        }\n      }\n      if (firstChar === QUESTION) {\n        out += '?>';\n        return;\n      }\n      if (firstChar === BANG) {\n        out += '>';\n        return;\n      }\n      out += '>';\n    }\n    writeChildren(node.children, depth + 1);\n    out += '</' + tag + '>';\n  }\n\n  writeChildren(Array.isArray(input) ? input : [input], 0);\n  return out;\n}\n\n// ---------------------------------------------------------------------------\n// Full-featured path — entities, HTML mode, and/or pretty printing\n// ---------------------------------------------------------------------------\n\nfunction fullWriter(\n  input: TNode | (TNode | string)[],\n  options: WriterOptions,\n): string {\n  const indent = !options.pretty\n    ? ''\n    : typeof options.pretty === 'string'\n      ? options.pretty\n      : '  ';\n\n  // Entity encoding functions — identity when disabled\n  const encodeEntities = !!options.entities;\n  const htmlMode = !!options.html;\n  const encodeRawText: (input: string) => string = encodeEntities\n    ? htmlMode\n      ? escapeUTF8\n      : escapeText\n    : (input) => input;\n  /** Encode text content, but pass comments through verbatim. */\n  const encodeTextContent = (input: string): string =>\n    input.startsWith('<!--') ? input : encodeRawText(input);\n  const encodeAttributeValue: (input: string) => string = encodeEntities\n    ? htmlMode\n      ? escapeUTF8\n      : escapeAttribute\n    : (input) => input;\n\n  // HTML void elements — self-close without </tag> in html mode\n  const voidSet: Set<string> | null = htmlMode\n    ? new Set(HTML_VOID_ELEMENTS)\n    : null;\n\n  // Compact path with entities/html support\n  if (!indent) {\n    let out = '';\n    let seen: WeakSet<TNode> | null = null;\n\n    function writeChildren(nodes: (TNode | string)[], depth: number): void {\n      for (let i = 0; i < nodes.length; i++) {\n        const node = nodes[i]!;\n        if (typeof node === 'string') {\n          out += encodeTextContent(node);\n        } else {\n          writeNode(node, depth);\n        }\n      }\n    }\n\n    function writeNode(node: TNode, depth: number): void {\n      if (depth >= CIRCULAR_CHECK_DEPTH) {\n        if (seen === null) seen = new WeakSet<TNode>();\n        if (seen.has(node)) {\n          throw new Error('Circular reference detected in TNode tree');\n        }\n        seen.add(node);\n      }\n      const tag = node.tagName;\n      validateTagName(tag);\n      const attributes = node.attributes;\n      const firstChar = tag.charCodeAt(0);\n      // Skip attribute name validation for declarations (!DOCTYPE etc.)\n      // where keys are quoted identifiers, not XML attribute names\n      if (attributes !== null && firstChar !== BANG) {\n        validateAttributeNames(attributes);\n      }\n      if (attributes === null) {\n        if (firstChar === QUESTION) {\n          out += '<' + tag + '?>';\n          return;\n        }\n        // Declaration tags (e.g. !DOCTYPE) — void in all modes\n        if (firstChar === BANG) {\n          out += '<' + tag + '>';\n          return;\n        }\n        // HTML void elements self-close without a closing tag\n        if (voidSet !== null && voidSet.has(tag)) {\n          out += '<' + tag + '>';\n          return;\n        }\n        out += '<' + tag + '>';\n      } else {\n        out += '<' + tag;\n        const isDeclaration = firstChar === BANG;\n        const keys = Object.keys(attributes);\n        for (let j = 0; j < keys.length; j++) {\n          const attributeName = keys[j]!;\n          const attributeValue = attributes[attributeName];\n          if (attributeValue === null) {\n            if (isDeclaration && !SIMPLE_KEYWORD.test(attributeName)) {\n              out += ' \"' + attributeName + '\"';\n            } else {\n              out += ' ' + attributeName;\n            }\n          } else {\n            const encoded = encodeAttributeValue(attributeValue);\n            if (encoded.indexOf('\"') === -1) {\n              out += ' ' + attributeName + '=\"' + encoded + '\"';\n            } else if (encoded.indexOf(\"'\") === -1) {\n              out += ' ' + attributeName + \"='\" + encoded + \"'\";\n            } else {\n              // Value contains both quote types — escape single quotes\n              out +=\n                ' ' +\n                attributeName +\n                \"='\" +\n                encoded.replace(/'/g, '&apos;') +\n                \"'\";\n            }\n          }\n        }\n        if (firstChar === QUESTION) {\n          out += '?>';\n          return;\n        }\n        // Declaration tags (e.g. !DOCTYPE) — void in all modes\n        if (firstChar === BANG) {\n          out += '>';\n          return;\n        }\n        // HTML void elements self-close without a closing tag\n        if (voidSet !== null && voidSet.has(tag)) {\n          out += '>';\n          return;\n        }\n        out += '>';\n      }\n      writeChildren(node.children, depth + 1);\n      out += '</' + tag + '>';\n    }\n\n    writeChildren(Array.isArray(input) ? input : [input], 0);\n    return out;\n  }\n\n  // Pretty path\n  let out = '';\n  let seen: WeakSet<TNode> | null = null;\n\n  function hasTextChildren(nodes: (TNode | string)[]): boolean {\n    for (let i = 0; i < nodes.length; i++) {\n      const node = nodes[i];\n      // Comments are structural (like elements) — they don't force inline mode\n      if (typeof node === 'string' && !node.startsWith('<!--')) return true;\n    }\n    return false;\n  }\n\n  function prettyWriteAttributes(node: TNode, isDeclaration = false): void {\n    if (node.attributes === null) return;\n    const keys = Object.keys(node.attributes);\n    for (let j = 0; j < keys.length; j++) {\n      const key = keys[j]!;\n      const attributeValue = node.attributes[key];\n      if (attributeValue === null) {\n        if (isDeclaration && !SIMPLE_KEYWORD.test(key)) {\n          out += ' \"' + key + '\"';\n        } else {\n          out += ' ' + key;\n        }\n      } else {\n        const encoded = encodeAttributeValue(attributeValue);\n        if (encoded.indexOf('\"') === -1) {\n          out += ' ' + key + '=\"' + encoded + '\"';\n        } else if (encoded.indexOf(\"'\") === -1) {\n          out += ' ' + key + \"='\" + encoded + \"'\";\n        } else {\n          // Value contains both quote types — escape single quotes\n          out += ' ' + key + \"='\" + encoded.replace(/'/g, '&apos;') + \"'\";\n        }\n      }\n    }\n  }\n\n  function prettyWriteNode(node: TNode, depth: number): void {\n    if (!node) return;\n    if (depth >= CIRCULAR_CHECK_DEPTH) {\n      if (seen === null) seen = new WeakSet<TNode>();\n      if (seen.has(node)) {\n        throw new Error('Circular reference detected in TNode tree');\n      }\n      seen.add(node);\n    }\n    const tag = node.tagName;\n    validateTagName(tag);\n    const padding = indent.repeat(depth);\n    const firstChar = tag.charCodeAt(0);\n    // Skip attribute name validation for declarations (!DOCTYPE etc.)\n    // where keys are quoted identifiers, not XML attribute names\n    if (node.attributes !== null && firstChar !== BANG) {\n      validateAttributeNames(node.attributes);\n    }\n\n    // Processing instruction\n    if (firstChar === QUESTION) {\n      out += padding + '<' + tag;\n      prettyWriteAttributes(node);\n      out += '?>';\n      return;\n    }\n\n    // Declaration tags (e.g. !DOCTYPE) — void in all modes\n    if (firstChar === BANG) {\n      out += padding + '<' + tag;\n      prettyWriteAttributes(node, true);\n      out += '>';\n      return;\n    }\n\n    const children = node.children;\n    const childrenLength = children.length;\n\n    // HTML void elements — self-close without closing tag\n    if (voidSet !== null && voidSet.has(tag)) {\n      out += padding + '<' + tag;\n      prettyWriteAttributes(node);\n      out += '>';\n      return;\n    }\n\n    // Empty element — self-close\n    if (childrenLength === 0) {\n      out += padding + '<' + tag;\n      prettyWriteAttributes(node);\n      out += '/>';\n      return;\n    }\n\n    // Classify children\n    const hasText = hasTextChildren(children);\n    let hasElements = false;\n    if (hasText) {\n      for (let i = 0; i < childrenLength; i++) {\n        if (typeof children[i] !== 'string') {\n          hasElements = true;\n          break;\n        }\n      }\n    }\n\n    // Text-only (no element children) — trim each text child, join with\n    // a single space, and write inline on one line.\n    if (hasText && !hasElements) {\n      out += padding + '<' + tag;\n      prettyWriteAttributes(node);\n      out += '>';\n      let first = true;\n      for (let i = 0; i < childrenLength; i++) {\n        const text = (children[i] as string).trim();\n        if (text.length === 0) continue;\n        if (!first) out += ' ';\n        first = false;\n        out += encodeTextContent(text);\n      }\n      out += '</' + tag + '>';\n      return;\n    }\n\n    // Mixed content — trim text nodes, drop empty, place each non-empty\n    // text and each element child on its own indented line.\n    if (hasText) {\n      const childPadding = indent.repeat(depth + 1);\n      out += padding + '<' + tag;\n      prettyWriteAttributes(node);\n      out += '>';\n      for (let i = 0; i < childrenLength; i++) {\n        const child = children[i]!;\n        if (typeof child === 'string') {\n          // Comments pass through without trimming\n          if (child.startsWith('<!--')) {\n            out += '\\n' + childPadding + encodeTextContent(child);\n          } else {\n            const trimmed = child.trim();\n            if (trimmed.length > 0) {\n              out += '\\n' + childPadding + encodeTextContent(trimmed);\n            }\n          }\n        } else {\n          out += '\\n';\n          prettyWriteNode(child, depth + 1);\n        }\n      }\n      out += '\\n' + padding + '</' + tag + '>';\n      return;\n    }\n\n    // Element-only children (and comments) — indent each child\n    out += padding + '<' + tag;\n    prettyWriteAttributes(node);\n    out += '>';\n    for (let i = 0; i < childrenLength; i++) {\n      const child = children[i]!;\n      if (typeof child === 'string') {\n        // Comments get their own indented line\n        out += '\\n' + indent.repeat(depth + 1) + encodeTextContent(child);\n      } else {\n        out += '\\n';\n        prettyWriteNode(child, depth + 1);\n      }\n    }\n    out += '\\n' + padding + '</' + tag + '>';\n  }\n\n  const nodes = Array.isArray(input) ? input : [input];\n  for (let i = 0; i < nodes.length; i++) {\n    const node = nodes[i]!;\n    if (i > 0) out += '\\n';\n    if (typeof node === 'string') {\n      out += encodeTextContent(node);\n    } else {\n      prettyWriteNode(node, 0);\n    }\n  }\n\n  return out;\n}\n\n// ---------------------------------------------------------------------------\n// Input format detection and conversion\n// ---------------------------------------------------------------------------\n\n/**\n * Detect the input format and convert to a `(TNode | string)[]` DOM array\n * suitable for the writer functions.\n *\n * Detection heuristics:\n * 1. A single TNode (has `tagName` string property) → pass through\n * 2. An array whose first non-string element has `tagName` → already DOM\n * 3. An array whose first non-string element has `$text`, `$comment`, `$attr`,\n *    or a single key mapping to an array → lossless format\n * 4. Anything else (including `null`, bare strings, objects without `tagName`) → lossy\n */\nfunction toDom(\n  input:\n    | TNode\n    | (TNode | string)[]\n    | LossyValue\n    | LossyValue[]\n    | LosslessEntry[],\n): TNode | (TNode | string)[] {\n  if (input === null || input === undefined) return [];\n\n  // Single TNode — pass through\n  if (!Array.isArray(input) && typeof input === 'object' && isTNode(input)) {\n    return input as TNode;\n  }\n\n  // Non-object, non-array: bare string (lossy top-level string)\n  if (!Array.isArray(input) && typeof input !== 'object') {\n    return fromLossy(input as LossyValue);\n  }\n\n  // Non-array object without tagName → lossy object\n  if (!Array.isArray(input)) {\n    return fromLossy(input as LossyValue);\n  }\n\n  // Array — need to distinguish DOM, lossless, and lossy\n  const array = input as unknown[];\n  if (array.length === 0) return [];\n\n  // Find the first non-string element to inspect\n  let sample: unknown = undefined;\n  for (let i = 0; i < array.length; i++) {\n    if (typeof array[i] !== 'string') {\n      sample = array[i];\n      break;\n    }\n  }\n\n  // All strings → could be DOM (text-only top level) — pass through\n  if (sample === undefined) return array as string[];\n\n  // TNode in the array → DOM format\n  if (typeof sample === 'object' && sample !== null && isTNode(sample)) {\n    return array as (TNode | string)[];\n  }\n\n  // Lossless entry: has $text, $comment, $attr, or single key → array value\n  if (\n    typeof sample === 'object' &&\n    sample !== null &&\n    isLosslessEntry(sample)\n  ) {\n    return fromLossless(array as LosslessEntry[]);\n  }\n\n  // Everything else → lossy\n  return fromLossy(array as LossyValue[]);\n}\n\n/** Check if a value looks like a TNode (has tagName string + children array). */\nfunction isTNode(value: unknown): value is TNode {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    typeof (value as TNode).tagName === 'string' &&\n    Array.isArray((value as TNode).children)\n  );\n}\n\n/** Check if a value looks like a LosslessEntry. */\nfunction isLosslessEntry(value: unknown): value is LosslessEntry {\n  if (typeof value !== 'object' || value === null) return false;\n  const keys = Object.keys(value);\n  if (keys.length === 0) return false;\n  // Known lossless marker keys\n  if ('$text' in value || '$comment' in value || '$attr' in value) return true;\n  // Single key mapping to an array → element entry\n  if (\n    keys.length === 1 &&\n    Array.isArray((value as Record<string, unknown>)[keys[0]!])\n  ) {\n    return true;\n  }\n  return false;\n}\n"],"mappings":"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"}

package/dist/xmlParseStream.d.mts

@@ -0,0 +1,138 @@
+import { n as TNode } from "./parser-BfdEfWDg.mjs";
+import { LosslessEntry } from "./converters/lossless.mjs";
+import { LossyValue } from "./converters/lossy.mjs";
+
+//#region src/xmlParseStream.d.ts
+/**
+ * Options for `XmlParseStream`.
+ *
+ * Only the fields that the transform layer actually consumes are exposed here.
+ * This keeps the API honest — options like `trimWhitespace`, `entities`, and
+ * `strict` belong to the synchronous `parse()` function, not the streaming
+ * tree-builder.
+ */
+interface XmlParseStreamOptions {
+  /**
+   * Starting byte offset — skip this many leading characters from the input.
+   * When a string is passed, its `.length` is used as the offset.
+   */
+  offset?: number | string;
+  /** Enable HTML parsing mode (sets default selfClosingTags/rawContentTags). */
+  html?: boolean;
+  /**
+   * Tag names that are self-closing (void elements).
+   * Defaults to standard HTML void elements when `html` is `true`, else `[]`.
+   */
+  selfClosingTags?: string[];
+  /**
+   * Tag names whose content is raw text (not parsed as XML/HTML).
+   * Defaults to `["script", "style"]` when `html` is `true`, else `[]`.
+   */
+  rawContentTags?: string[];
+  /** Keep XML comments in the output. Defaults to `false`. */
+  keepComments?: boolean;
+  /**
+   * Emit only elements matching these tag names instead of waiting for the
+   * entire top-level tree to close.
+   *
+   * When set, each matching element is emitted as a standalone `TNode` subtree
+   * the moment its close tag is encountered, regardless of nesting depth.
+   * Non-matching ancestor elements are **not** built or emitted — the stream
+   * only produces the selected subtrees.
+   *
+   * When multiple selected tags are nested (e.g. selecting both `item` and
+   * `sub` where `<sub>` appears inside `<item>`), each matching element
+   * is emitted independently as it closes. The inner element appears both as a
+   * separate emission **and** as a child within its ancestor's subtree.
+   *
+   * Accepts a single tag name or an array of tag names.
+   *
+   * @example
+   * ```ts
+   * // Given:
+   * // <root>
+   * //   <item>
+   * //     <sub>1</sub><box>a</box>
+   * //   </item>
+   * //   <item>
+   * //     <sub>2</sub><box>b</box>
+   * //   </item>
+   * // </root>
+   * //
+   * // Without select: emits one big <root> TNode after </root>
+   * // With select: "item": emits two <item> TNodes as each closes
+   * const stream = new XmlParseStream({ select: 'item' });
+   *
+   * // Nested selection: emits each <sub> as it closes, then the
+   * // containing <item> (which still includes the <sub> as a child).
+   * const stream2 = new XmlParseStream({ select: ['item', 'sub'] });
+   * ```
+   */
+  select?: string | string[];
+  /**
+   * Output format for emitted chunks.
+   *
+   * - `'dom'` (default) — emit raw `TNode | string` values.
+   * - `'lossy'` — convert each item to the compact lossy format (`LossyValue`).
+   * - `'lossless'` — convert each item to the order-preserving lossless format
+   *   (`LosslessEntry`).
+   */
+  output?: 'dom' | 'lossy' | 'lossless';
+}
+/**
+ * A Web Streams `TransformStream` that incrementally parses XML chunks into
+ * `TNode` subtrees (or lossy/lossless objects). Works in browsers, Node.js
+ * 18+, Deno, and Bun.
+ *
+ * Follows the platform stream class convention (like `TextDecoderStream`,
+ * `DecompressionStream`, etc.) — instantiate with `new` and use with
+ * `.pipeThrough()`.
+ *
+ * Internally powered by the SAX engine with a tree-construction layer
+ * that assembles `TNode` subtrees and emits them as they complete.
+ *
+ * By default, nodes are emitted when a top-level element closes (depth 0).
+ * Use the `select` option to emit specific elements as they close at any depth,
+ * without waiting for the entire document root to finish.
+ *
+ * Use the `output` option to choose the emitted format:
+ * - `'dom'` (default) — raw `TNode | string`
+ * - `'lossy'` — compact lossy objects (`LossyValue`)
+ * - `'lossless'` — order-preserving objects (`LosslessEntry`)
+ *
+ * @example
+ * ```ts
+ * import { XmlParseStream } from '@eksml/xml/stream';
+ *
+ * const response = await fetch('/feed.xml');
+ * const reader = response.body
+ *   .pipeThrough(new TextDecoderStream())
+ *   .pipeThrough(new XmlParseStream())
+ *   .getReader();
+ *
+ * while (true) {
+ *   const { done, value } = await reader.read();
+ *   if (done) break;
+ *   console.log(value); // TNode or string
+ * }
+ * ```
+ */
+declare class XmlParseStream<TOutput = TNode | string> extends TransformStream<string, TOutput> {
+  /** Default DOM output (`TNode | string`). */
+  constructor(options?: XmlParseStreamOptions & {
+    output?: 'dom';
+  });
+  /** Lossy output — each item is converted to `LossyValue`. */
+  constructor(options: XmlParseStreamOptions & {
+    output: 'lossy';
+  });
+  /** Lossless output — each item is converted to `LosslessEntry`. */
+  constructor(options: XmlParseStreamOptions & {
+    output: 'lossless';
+  });
+  /** Dynamic output — when the `output` option is not a literal, returns the widest type. */
+  constructor(options: XmlParseStreamOptions);
+}
+//#endregion
+export { type LosslessEntry, type LossyValue, XmlParseStream, XmlParseStreamOptions };
+//# sourceMappingURL=xmlParseStream.d.mts.map

package/dist/xmlParseStream.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xmlParseStream.d.mts","names":[],"sources":["../src/xmlParseStream.ts"],"mappings":";;;;;;;AAwBA;;;;;;UAAiB,qBAAA;EAiBf;;;;EAZA,MAAA;EA6DM;EA3DN,IAAA;EA6PyB;;;;EAxPzB,eAAA;EA+PqB;;;;EA1PrB,cAAA;EAmP2E;EAjP3E,YAAA;EAiPoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA3MpC,MAAA;;;;;;;;;EASA,MAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAkMW,cAAA,WAAyB,KAAA,mBAAwB,eAAA,SAE5D,OAAA;;cAGY,OAAA,GAAU,qBAAA;IAA0B,MAAA;EAAA;;cAEpC,OAAA,EAAS,qBAAA;IAA0B,MAAA;EAAA;;cAEnC,OAAA,EAAS,qBAAA;IAA0B,MAAA;EAAA;;cAEnC,OAAA,EAAS,qBAAA;AAAA"}