@eksml/xml 0.1.0

package/dist/converters/fromLossy.d.mts

@@ -0,0 +1,18 @@
+import { n as TNode } from "../parser-BfdEfWDg.mjs";
+import { LossyValue } from "./lossy.mjs";
+
+//#region src/converters/fromLossy.d.ts
+/**
+ * Convert a lossy JS object back to a `(TNode | string)[]` DOM tree.
+ *
+ * Accepts the same shapes that `lossy()` returns:
+ * - A single `LossyValue` (e.g. `{ root: { ... } }`)
+ * - An array of `LossyValue` (multiple roots)
+ *
+ * @param input - A lossy value or array of lossy values.
+ * @returns A DOM array suitable for `write()` or further processing.
+ */
+declare function fromLossy(input: LossyValue | LossyValue[]): (TNode | string)[];
+//#endregion
+export { fromLossy };
+//# sourceMappingURL=fromLossy.d.mts.map

package/dist/converters/fromLossy.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fromLossy.d.mts","names":[],"sources":["../../src/converters/fromLossy.ts"],"mappings":";;;;;;;;;;;;;;iBAiDgB,SAAA,CACd,KAAA,EAAO,UAAA,GAAa,UAAA,MAClB,KAAA"}

package/dist/converters/fromLossy.mjs

@@ -0,0 +1,91 @@
+//#region src/converters/fromLossy.ts
+const DOLLAR = 36;
+/**
+* Convert a lossy JS object back to a `(TNode | string)[]` DOM tree.
+*
+* Accepts the same shapes that `lossy()` returns:
+* - A single `LossyValue` (e.g. `{ root: { ... } }`)
+* - An array of `LossyValue` (multiple roots)
+*
+* @param input - A lossy value or array of lossy values.
+* @returns A DOM array suitable for `write()` or further processing.
+*/
+function fromLossy(input) {
+	if (Array.isArray(input)) {
+		const result = [];
+		for (let i = 0; i < input.length; i++) {
+			const item = input[i];
+			if (typeof item === "string") result.push(item);
+			else if (item === null) continue;
+			else convertTopLevelObject(item, result);
+		}
+		return result;
+	}
+	if (input === null || typeof input === "string") return typeof input === "string" ? [input] : [];
+	const result = [];
+	convertTopLevelObject(input, result);
+	return result;
+}
+/**
+* Convert a top-level `{ tagName: value }` object into TNode(s) and push
+* them onto the result array.
+*/
+function convertTopLevelObject(object, result) {
+	const keys = Object.keys(object);
+	for (let i = 0; i < keys.length; i++) {
+		const tagName = keys[i];
+		result.push(convertElement(tagName, object[tagName]));
+	}
+}
+/**
+* Convert a tag name + lossy value into a TNode.
+*/
+function convertElement(tagName, value) {
+	if (value === null) return {
+		tagName,
+		attributes: null,
+		children: []
+	};
+	if (typeof value === "string") return {
+		tagName,
+		attributes: null,
+		children: [value]
+	};
+	if (Array.isArray(value)) return convertElement(tagName, value[0] ?? null);
+	const objectValue = value;
+	const objectKeys = Object.keys(objectValue);
+	let attributes = null;
+	const children = [];
+	for (let i = 0; i < objectKeys.length; i++) {
+		const key = objectKeys[i];
+		if (key === "$$") {
+			const mixedArray = objectValue.$$;
+			for (let j = 0; j < mixedArray.length; j++) {
+				const mixedEntry = mixedArray[j];
+				if (typeof mixedEntry === "string") children.push(mixedEntry);
+				else {
+					const entryTagName = Object.keys(mixedEntry)[0];
+					children.push(convertElement(entryTagName, mixedEntry[entryTagName]));
+				}
+			}
+		} else if (key.charCodeAt(0) === DOLLAR) {
+			if (attributes === null) attributes = Object.create(null);
+			const attributeName = key.substring(1);
+			const attributeValue = objectValue[key];
+			attributes[attributeName] = attributeValue === null ? null : String(attributeValue);
+		} else {
+			const childValue = objectValue[key];
+			if (Array.isArray(childValue)) for (let j = 0; j < childValue.length; j++) children.push(convertElement(key, childValue[j]));
+			else children.push(convertElement(key, childValue));
+		}
+	}
+	return {
+		tagName,
+		attributes,
+		children
+	};
+}
+//#endregion
+export { fromLossy };
+
+//# sourceMappingURL=fromLossy.mjs.map

package/dist/converters/fromLossy.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"fromLossy.mjs","names":[],"sources":["../../src/converters/fromLossy.ts"],"sourcesContent":["/**\n * fromLossy — convert a lossy JS object back to a TNode DOM tree.\n *\n * This is the inverse of `lossy()`. Because the lossy format does not preserve\n * sibling order between different tag names, the reconstruction is best-effort:\n * elements appear in JS object key insertion order, and arrays expand in\n * sequence. Mixed content (`$$` arrays) preserves interleaving exactly.\n *\n * Lossy format rules (reversed):\n * - `null` → empty element (no attributes, no children)\n * - `string` → text-only element (one string child)\n * - `$`-prefixed keys → attributes (prefix stripped)\n * - `$$` array → mixed content (strings become text, objects become elements)\n * - Non-`$` keys → element children (arrays expand to repeated siblings)\n * - Top-level single-key object → single root element\n * - Top-level array → multiple root elements\n *\n * @example\n * ```ts\n * import { fromLossy } from \"@eksml/xml/from-lossy\";\n * import { lossy } from \"@eksml/xml/lossy\";\n * import { write } from \"@eksml/xml/writer\";\n *\n * const obj = lossy('<root><item>hello</item><item>world</item></root>');\n * const dom = fromLossy(obj);\n * const xml = write(dom);\n * ```\n */\n\nimport type { TNode } from '#src/parser.ts';\nimport type {\n  LossyValue,\n  LossyObject,\n  LossyMixedEntry,\n} from '#src/converters/lossy.ts';\n// @generated:char-codes:begin\nconst DOLLAR = 36; // $\n// @generated:char-codes:end\n\n/**\n * Convert a lossy JS object back to a `(TNode | string)[]` DOM tree.\n *\n * Accepts the same shapes that `lossy()` returns:\n * - A single `LossyValue` (e.g. `{ root: { ... } }`)\n * - An array of `LossyValue` (multiple roots)\n *\n * @param input - A lossy value or array of lossy values.\n * @returns A DOM array suitable for `write()` or further processing.\n */\nexport function fromLossy(\n  input: LossyValue | LossyValue[],\n): (TNode | string)[] {\n  // Array of top-level values\n  if (Array.isArray(input)) {\n    const result: (TNode | string)[] = [];\n    for (let i = 0; i < input.length; i++) {\n      const item = input[i]!;\n      if (typeof item === 'string') {\n        result.push(item);\n      } else if (item === null) {\n        // Top-level null — unusual, skip\n        continue;\n      } else {\n        // Each object in the array is { tagName: value }\n        convertTopLevelObject(item, result);\n      }\n    }\n    return result;\n  }\n\n  // Single value\n  if (input === null || typeof input === 'string') {\n    // Bare null or string at top level — can't form a TNode without a tag name\n    return typeof input === 'string' ? [input] : [];\n  }\n\n  // Single-root object: { rootTag: value }\n  const result: (TNode | string)[] = [];\n  convertTopLevelObject(input, result);\n  return result;\n}\n\n/**\n * Convert a top-level `{ tagName: value }` object into TNode(s) and push\n * them onto the result array.\n */\nfunction convertTopLevelObject(\n  object: LossyObject,\n  result: (TNode | string)[],\n): void {\n  const keys = Object.keys(object);\n  for (let i = 0; i < keys.length; i++) {\n    const tagName = keys[i]!;\n    result.push(convertElement(tagName, object[tagName]!));\n  }\n}\n\n/**\n * Convert a tag name + lossy value into a TNode.\n */\nfunction convertElement(\n  tagName: string,\n  value: LossyValue | LossyValue[] | LossyMixedEntry[],\n): TNode {\n  // null → empty element\n  if (value === null) {\n    return { tagName, attributes: null, children: [] };\n  }\n\n  // string → text-only element\n  if (typeof value === 'string') {\n    return { tagName, attributes: null, children: [value] };\n  }\n\n  // Array → this is a repeated-sibling array at the parent level,\n  // but convertElement is called per-value, so arrays here shouldn't\n  // normally occur. Defensive: treat as first element.\n  if (Array.isArray(value)) {\n    // This case is handled by the caller expanding arrays.\n    // If somehow called directly, use first item.\n    return convertElement(tagName, value[0] ?? null);\n  }\n\n  // LossyObject → extract attributes ($-prefixed), check for $$ mixed content,\n  // then process element-only children\n  const objectValue = value as LossyObject;\n  const objectKeys = Object.keys(objectValue);\n\n  let attributes: Record<string, string | null> | null = null;\n  const children: (TNode | string)[] = [];\n  let hasMixed = false;\n\n  for (let i = 0; i < objectKeys.length; i++) {\n    const key = objectKeys[i]!;\n\n    if (key === '$$') {\n      // Mixed content array\n      hasMixed = true;\n      const mixedArray = objectValue.$$ as LossyMixedEntry[];\n      for (let j = 0; j < mixedArray.length; j++) {\n        const mixedEntry = mixedArray[j]!;\n        if (typeof mixedEntry === 'string') {\n          children.push(mixedEntry);\n        } else {\n          // { tagName: value } — single-key object\n          const entryKeys = Object.keys(mixedEntry);\n          const entryTagName = entryKeys[0]!;\n          children.push(\n            convertElement(\n              entryTagName,\n              (mixedEntry as LossyObject)[entryTagName]!,\n            ),\n          );\n        }\n      }\n    } else if (key.charCodeAt(0) === DOLLAR) {\n      // Attribute — strip the $ prefix\n      if (attributes === null) {\n        attributes = Object.create(null) as Record<string, string | null>;\n      }\n      const attributeName = key.substring(1);\n      const attributeValue = objectValue[key];\n      attributes[attributeName] =\n        attributeValue === null ? null : String(attributeValue);\n    } else {\n      // Element child(ren)\n      const childValue = objectValue[key]!;\n      if (Array.isArray(childValue)) {\n        // Repeated siblings\n        for (let j = 0; j < childValue.length; j++) {\n          children.push(convertElement(key, childValue[j]!));\n        }\n      } else {\n        children.push(convertElement(key, childValue as LossyValue));\n      }\n    }\n  }\n\n  return { tagName, attributes, children };\n}\n"],"mappings":";AAoCA,MAAM,SAAS;;;;;;;;;;;AAaf,SAAgB,UACd,OACoB;AAEpB,KAAI,MAAM,QAAQ,MAAM,EAAE;EACxB,MAAM,SAA6B,EAAE;AACrC,OAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;GACrC,MAAM,OAAO,MAAM;AACnB,OAAI,OAAO,SAAS,SAClB,QAAO,KAAK,KAAK;YACR,SAAS,KAElB;OAGA,uBAAsB,MAAM,OAAO;;AAGvC,SAAO;;AAIT,KAAI,UAAU,QAAQ,OAAO,UAAU,SAErC,QAAO,OAAO,UAAU,WAAW,CAAC,MAAM,GAAG,EAAE;CAIjD,MAAM,SAA6B,EAAE;AACrC,uBAAsB,OAAO,OAAO;AACpC,QAAO;;;;;;AAOT,SAAS,sBACP,QACA,QACM;CACN,MAAM,OAAO,OAAO,KAAK,OAAO;AAChC,MAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;EACpC,MAAM,UAAU,KAAK;AACrB,SAAO,KAAK,eAAe,SAAS,OAAO,SAAU,CAAC;;;;;;AAO1D,SAAS,eACP,SACA,OACO;AAEP,KAAI,UAAU,KACZ,QAAO;EAAE;EAAS,YAAY;EAAM,UAAU,EAAE;EAAE;AAIpD,KAAI,OAAO,UAAU,SACnB,QAAO;EAAE;EAAS,YAAY;EAAM,UAAU,CAAC,MAAM;EAAE;AAMzD,KAAI,MAAM,QAAQ,MAAM,CAGtB,QAAO,eAAe,SAAS,MAAM,MAAM,KAAK;CAKlD,MAAM,cAAc;CACpB,MAAM,aAAa,OAAO,KAAK,YAAY;CAE3C,IAAI,aAAmD;CACvD,MAAM,WAA+B,EAAE;AAGvC,MAAK,IAAI,IAAI,GAAG,IAAI,WAAW,QAAQ,KAAK;EAC1C,MAAM,MAAM,WAAW;AAEvB,MAAI,QAAQ,MAAM;GAGhB,MAAM,aAAa,YAAY;AAC/B,QAAK,IAAI,IAAI,GAAG,IAAI,WAAW,QAAQ,KAAK;IAC1C,MAAM,aAAa,WAAW;AAC9B,QAAI,OAAO,eAAe,SACxB,UAAS,KAAK,WAAW;SACpB;KAGL,MAAM,eADY,OAAO,KAAK,WAAW,CACV;AAC/B,cAAS,KACP,eACE,cACC,WAA2B,cAC7B,CACF;;;aAGI,IAAI,WAAW,EAAE,KAAK,QAAQ;AAEvC,OAAI,eAAe,KACjB,cAAa,OAAO,OAAO,KAAK;GAElC,MAAM,gBAAgB,IAAI,UAAU,EAAE;GACtC,MAAM,iBAAiB,YAAY;AACnC,cAAW,iBACT,mBAAmB,OAAO,OAAO,OAAO,eAAe;SACpD;GAEL,MAAM,aAAa,YAAY;AAC/B,OAAI,MAAM,QAAQ,WAAW,CAE3B,MAAK,IAAI,IAAI,GAAG,IAAI,WAAW,QAAQ,IACrC,UAAS,KAAK,eAAe,KAAK,WAAW,GAAI,CAAC;OAGpD,UAAS,KAAK,eAAe,KAAK,WAAyB,CAAC;;;AAKlE,QAAO;EAAE;EAAS;EAAY;EAAU"}

package/dist/converters/lossless.d.mts

@@ -0,0 +1,39 @@
+import { n as TNode, t as ParseOptions } from "../parser-BfdEfWDg.mjs";
+
+//#region src/converters/lossless.d.ts
+/** A single entry in the JSON output array. */
+type LosslessEntry = {
+  [tagName: string]: LosslessEntry[];
+} | {
+  $text: string;
+} | {
+  $attr: Record<string, string | null>;
+} | {
+  $comment: string;
+};
+/** Options for lossless. */
+interface LosslessOptions extends ParseOptions {}
+/**
+ * Convert a single `TNode | string` item into its lossless representation.
+ *
+ * - `TNode` → `{ tagName: [ ...children ] }`
+ * - `string` → `{ $text: "..." }` or `{ $comment: "..." }`
+ *
+ * Used internally by `XmlParseStream` when `output: 'lossless'` is set.
+ *
+ * @internal
+ */
+declare function convertItemToLossless(item: TNode | string): LosslessEntry;
+/**
+ * Parse an XML/HTML string or convert a pre-parsed DOM tree into an
+ * order-preserving JSON-friendly structure.
+ *
+ * @param input - An XML/HTML string, or a pre-parsed `(TNode | string)[]` DOM array
+ * @param options - Parsing options (only used when `input` is a string)
+ * @returns Array of top-level JSON entries
+ */
+declare function lossless(input: string, options?: LosslessOptions): LosslessEntry[];
+declare function lossless(input: (TNode | string)[]): LosslessEntry[];
+//#endregion
+export { LosslessEntry, LosslessOptions, convertItemToLossless, lossless };
+//# sourceMappingURL=lossless.d.mts.map

package/dist/converters/lossless.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lossless.d.mts","names":[],"sources":["../../src/converters/lossless.ts"],"mappings":";;;;KAkCY,aAAA;EAAA,CACL,OAAA,WAAkB,aAAA;AAAA;EACnB,KAAA;AAAA;EACA,KAAA,EAAO,MAAA;AAAA;EACP,QAAA;AAAA;;UAGW,eAAA,SAAwB,YAAA;;;;;;;;;;;iBAyCzB,qBAAA,CAAsB,IAAA,EAAM,KAAA,YAAiB,aAAA;;;;;;;;;iBAa7C,QAAA,CACd,KAAA,UACA,OAAA,GAAU,eAAA,GACT,aAAA;AAAA,iBACa,QAAA,CAAS,KAAA,GAAQ,KAAA,eAAoB,aAAA"}

package/dist/converters/lossless.mjs

@@ -0,0 +1,74 @@
+import { t as parse } from "../parser-CYq309aR.mjs";
+//#region src/converters/lossless.ts
+/**
+* lossless — XML-to-JSON converter producing an order-preserving format.
+*
+* Each element becomes a single-key object `{ tagName: children[] }`.
+* Text nodes become `{ $text: "..." }`.
+* Attributes become `{ $attr: { ... } }` as the first entry in the children array.
+* Comments (when kept) become `{ $comment: "..." }`.
+*
+* All marker keys are valid JS identifiers so you can use dot notation:
+* `entry.$attr.id`, `entry.$text`, `entry.$comment`.
+*
+* The format preserves element order, mixed content, and attributes losslessly,
+* and is fully JSON-serializable.
+*
+* @example
+* ```ts
+* import { lossless } from "@eksml/xml/lossless";
+*
+* const result = lossless('<root attr="1"><item>hell<b>o</b></item></root>');
+* // [
+* //   { "root": [
+* //     { $attr: { "attr": "1" } },
+* //     { "item": [
+* //       { $text: "hell" },
+* //       { "b": [{ $text: "o" }] }
+* //     ]}
+* //   ]}
+* // ]
+* ```
+*/
+function convertNode(node) {
+	const children = [];
+	if (node.attributes !== null) children.push({ $attr: node.attributes });
+	for (let i = 0; i < node.children.length; i++) {
+		const child = node.children[i];
+		if (typeof child === "string") children.push(convertString(child));
+		else children.push(convertNode(child));
+	}
+	return { [node.tagName]: children };
+}
+function convertString(text) {
+	if (text.startsWith("<!--") && text.endsWith("-->")) return { $comment: text.substring(4, text.length - 3) };
+	return { $text: text };
+}
+/**
+* Convert a single `TNode | string` item into its lossless representation.
+*
+* - `TNode` → `{ tagName: [ ...children ] }`
+* - `string` → `{ $text: "..." }` or `{ $comment: "..." }`
+*
+* Used internally by `XmlParseStream` when `output: 'lossless'` is set.
+*
+* @internal
+*/
+function convertItemToLossless(item) {
+	if (typeof item === "string") return convertString(item);
+	return convertNode(item);
+}
+function lossless(input, options) {
+	const dom = typeof input === "string" ? parse(input, { ...options }) : input;
+	const result = [];
+	for (let i = 0; i < dom.length; i++) {
+		const node = dom[i];
+		if (typeof node === "string") result.push(convertString(node));
+		else result.push(convertNode(node));
+	}
+	return result;
+}
+//#endregion
+export { convertItemToLossless, lossless };
+
+//# sourceMappingURL=lossless.mjs.map

package/dist/converters/lossless.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"lossless.mjs","names":[],"sources":["../../src/converters/lossless.ts"],"sourcesContent":["/**\n * lossless — XML-to-JSON converter producing an order-preserving format.\n *\n * Each element becomes a single-key object `{ tagName: children[] }`.\n * Text nodes become `{ $text: \"...\" }`.\n * Attributes become `{ $attr: { ... } }` as the first entry in the children array.\n * Comments (when kept) become `{ $comment: \"...\" }`.\n *\n * All marker keys are valid JS identifiers so you can use dot notation:\n * `entry.$attr.id`, `entry.$text`, `entry.$comment`.\n *\n * The format preserves element order, mixed content, and attributes losslessly,\n * and is fully JSON-serializable.\n *\n * @example\n * ```ts\n * import { lossless } from \"@eksml/xml/lossless\";\n *\n * const result = lossless('<root attr=\"1\"><item>hell<b>o</b></item></root>');\n * // [\n * //   { \"root\": [\n * //     { $attr: { \"attr\": \"1\" } },\n * //     { \"item\": [\n * //       { $text: \"hell\" },\n * //       { \"b\": [{ $text: \"o\" }] }\n * //     ]}\n * //   ]}\n * // ]\n * ```\n */\n\nimport { parse, type TNode, type ParseOptions } from '#src/parser.ts';\n\n/** A single entry in the JSON output array. */\nexport type LosslessEntry =\n  | { [tagName: string]: LosslessEntry[] }\n  | { $text: string }\n  | { $attr: Record<string, string | null> }\n  | { $comment: string };\n\n/** Options for lossless. */\nexport interface LosslessOptions extends ParseOptions {}\n\nfunction convertNode(node: TNode): LosslessEntry {\n  const children: LosslessEntry[] = [];\n\n  // Attributes go first as { $attr: { ... } }\n  if (node.attributes !== null) {\n    children.push({ $attr: node.attributes });\n  }\n\n  // Then child nodes\n  for (let i = 0; i < node.children.length; i++) {\n    const child = node.children[i]!;\n    if (typeof child === 'string') {\n      children.push(convertString(child));\n    } else {\n      children.push(convertNode(child));\n    }\n  }\n\n  return { [node.tagName]: children };\n}\n\nfunction convertString(text: string): LosslessEntry {\n  // Comments from parse() come as \"<!-- ... -->\"\n  if (text.startsWith('<!--') && text.endsWith('-->')) {\n    return { $comment: text.substring(4, text.length - 3) };\n  }\n  return { $text: text };\n}\n\n/**\n * Convert a single `TNode | string` item into its lossless representation.\n *\n * - `TNode` → `{ tagName: [ ...children ] }`\n * - `string` → `{ $text: \"...\" }` or `{ $comment: \"...\" }`\n *\n * Used internally by `XmlParseStream` when `output: 'lossless'` is set.\n *\n * @internal\n */\nexport function convertItemToLossless(item: TNode | string): LosslessEntry {\n  if (typeof item === 'string') return convertString(item);\n  return convertNode(item);\n}\n\n/**\n * Parse an XML/HTML string or convert a pre-parsed DOM tree into an\n * order-preserving JSON-friendly structure.\n *\n * @param input - An XML/HTML string, or a pre-parsed `(TNode | string)[]` DOM array\n * @param options - Parsing options (only used when `input` is a string)\n * @returns Array of top-level JSON entries\n */\nexport function lossless(\n  input: string,\n  options?: LosslessOptions,\n): LosslessEntry[];\nexport function lossless(input: (TNode | string)[]): LosslessEntry[];\nexport function lossless(\n  input: string | (TNode | string)[],\n  options?: LosslessOptions,\n): LosslessEntry[] {\n  const dom = typeof input === 'string' ? parse(input, { ...options }) : input;\n  const result: LosslessEntry[] = [];\n  for (let i = 0; i < dom.length; i++) {\n    const node = dom[i]!;\n    if (typeof node === 'string') {\n      result.push(convertString(node));\n    } else {\n      result.push(convertNode(node));\n    }\n  }\n  return result;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2CA,SAAS,YAAY,MAA4B;CAC/C,MAAM,WAA4B,EAAE;AAGpC,KAAI,KAAK,eAAe,KACtB,UAAS,KAAK,EAAE,OAAO,KAAK,YAAY,CAAC;AAI3C,MAAK,IAAI,IAAI,GAAG,IAAI,KAAK,SAAS,QAAQ,KAAK;EAC7C,MAAM,QAAQ,KAAK,SAAS;AAC5B,MAAI,OAAO,UAAU,SACnB,UAAS,KAAK,cAAc,MAAM,CAAC;MAEnC,UAAS,KAAK,YAAY,MAAM,CAAC;;AAIrC,QAAO,GAAG,KAAK,UAAU,UAAU;;AAGrC,SAAS,cAAc,MAA6B;AAElD,KAAI,KAAK,WAAW,OAAO,IAAI,KAAK,SAAS,MAAM,CACjD,QAAO,EAAE,UAAU,KAAK,UAAU,GAAG,KAAK,SAAS,EAAE,EAAE;AAEzD,QAAO,EAAE,OAAO,MAAM;;;;;;;;;;;;AAaxB,SAAgB,sBAAsB,MAAqC;AACzE,KAAI,OAAO,SAAS,SAAU,QAAO,cAAc,KAAK;AACxD,QAAO,YAAY,KAAK;;AAgB1B,SAAgB,SACd,OACA,SACiB;CACjB,MAAM,MAAM,OAAO,UAAU,WAAW,MAAM,OAAO,EAAE,GAAG,SAAS,CAAC,GAAG;CACvE,MAAM,SAA0B,EAAE;AAClC,MAAK,IAAI,IAAI,GAAG,IAAI,IAAI,QAAQ,KAAK;EACnC,MAAM,OAAO,IAAI;AACjB,MAAI,OAAO,SAAS,SAClB,QAAO,KAAK,cAAc,KAAK,CAAC;MAEhC,QAAO,KAAK,YAAY,KAAK,CAAC;;AAGlC,QAAO"}

package/dist/converters/lossy.d.mts

@@ -0,0 +1,42 @@
+import { n as TNode, t as ParseOptions } from "../parser-BfdEfWDg.mjs";
+
+//#region src/converters/lossy.d.ts
+/** Options for lossy. */
+interface LossyOptions extends ParseOptions {}
+/** The value of a converted element — null (empty), string, or an object with keys. */
+type LossyValue = null | string | LossyObject;
+/** An element converted to a keyed object. */
+interface LossyObject {
+  [key: string]: LossyValue | LossyValue[] | LossyMixedEntry[];
+}
+/** An entry in a `$$` mixed-content array. */
+type LossyMixedEntry = string | {
+  [tagName: string]: LossyValue;
+};
+/**
+ * Convert a single `TNode | string` item into its lossy representation.
+ *
+ * - `TNode` → `{ tagName: convertedValue }` (same shape as the multi-root
+ *   branch of `lossy()`)
+ * - `string` → passed through as-is
+ *
+ * Used internally by `XmlParseStream` when `output: 'lossy'` is set.
+ *
+ * @internal
+ */
+declare function convertItemToLossy(item: TNode | string): LossyValue;
+/**
+ * Parse an XML/HTML string or convert a pre-parsed DOM tree into the most
+ * simplified lossy JS object format.
+ *
+ * @param input - An XML/HTML string, or a pre-parsed `(TNode | string)[]` DOM array
+ * @param options - Parsing options (only used when `input` is a string)
+ * @returns A LossyValue representing the document. For a single root element
+ *          this is typically `{ rootTag: ... }`. For multiple top-level nodes
+ *          an array is returned.
+ */
+declare function lossy(input: string, options?: LossyOptions): LossyValue | LossyValue[];
+declare function lossy(input: (TNode | string)[]): LossyValue | LossyValue[];
+//#endregion
+export { LossyMixedEntry, LossyObject, LossyOptions, LossyValue, convertItemToLossy, lossy };
+//# sourceMappingURL=lossy.d.mts.map

package/dist/converters/lossy.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lossy.d.mts","names":[],"sources":["../../src/converters/lossy.ts"],"mappings":";;;;UA2DiB,YAAA,SAAqB,YAAA;AAyKtC;AAAA,KAtKY,UAAA,mBAA6B,WAAA;;UAGxB,WAAA;EAAA,CACd,GAAA,WAAc,UAAA,GAAa,UAAA,KAAe,eAAA;AAAA;;KAIjC,eAAA;EAAA,CAA8B,OAAA,WAAkB,UAAA;AAAA;;;;;;;;;;;;iBA2I5C,kBAAA,CAAmB,IAAA,EAAM,KAAA,YAAiB,UAAA;;;;;;;;;;;iBAe1C,KAAA,CACd,KAAA,UACA,OAAA,GAAU,YAAA,GACT,UAAA,GAAa,UAAA;AAAA,iBACA,KAAA,CAAM,KAAA,GAAQ,KAAA,eAAoB,UAAA,GAAa,UAAA"}

package/dist/converters/lossy.mjs

@@ -0,0 +1,158 @@
+import { t as parse } from "../parser-CYq309aR.mjs";
+//#region src/converters/lossy.ts
+/**
+* lossy — simplified lossy XML-to-JS object converter.
+*
+* Produces the most compact JS object representation possible. Element
+* ordering between different tag names is not preserved. The format rules are:
+*
+* - **Text-only element**: collapses to a plain string value.
+*   `<name>text</name>` → `{ "name": "text" }`
+*
+* - **Empty/void element**: collapses to `null`.
+*   `<br/>` → `{ "br": null }`
+*
+* - **Attributes**: prefixed with `$` on the element object.
+*   `<a href="/">link</a>` → `{ "a": { $href: "/", $$: ["link"] } }`
+*
+* - **Mixed content** (text + child elements): children go into an ordered
+*   `$$` array preserving exact interleaving of text and element objects.
+*   `<p>Hello <b>world</b></p>` → `{ "p": { $$: ["Hello ", { "b": "world" }] } }`
+*
+* - **Element-only children** (no text): keyed object with tag names.
+*   `<root><a>1</a><b>2</b></root>` → `{ "root": { "a": "1", "b": "2" } }`
+*
+* - **Repeated same-name siblings**: become an array.
+*   Two `<item>` → `"item": [val1, val2]`; one `<item>` → `"item": val1`
+*
+* All marker keys are valid JS identifiers so you can use dot notation:
+* `node.$href`, `node.$$`, etc.
+*
+* @example
+* ```ts
+* import { lossy } from "@eksml/xml/lossy";
+*
+* const result = lossy(`
+*   <thing>
+*     <second with="attributes">Text</second>
+*     <third>More text</third>
+*     <second another="attribute">Even more text
+*       <fourth>Nested text</fourth>
+*     </second>
+*   </thing>
+* `);
+* // {
+* //   "thing": {
+* //     "second": [
+* //       { $with: "attributes", $$: ["Text"] },
+* //       { $another: "attribute", $$: ["Even more text\n      ", { "fourth": "Nested text" }] }
+* //     ],
+* //     "third": "More text"
+* //   }
+* // }
+* ```
+*/
+const DOLLAR = 36;
+/**
+* Convert a single TNode into its simplified lossy value.
+*
+* Single-pass algorithm: starts optimistically building an element-only object,
+* and upgrades to mixed-content ($$ array) if text nodes are encountered
+* alongside element nodes (or attributes exist with text).
+*/
+function convertNode(node) {
+	const children = node.children;
+	const childrenLength = children ? children.length : 0;
+	const attributes = node.attributes;
+	const hasAttributes = attributes !== null;
+	if (childrenLength === 0 && !hasAttributes) return null;
+	if (childrenLength === 1 && typeof children[0] === "string" && !hasAttributes) return children[0];
+	const elementObject = Object.create(null);
+	if (hasAttributes) for (const key in attributes) elementObject["$" + key] = attributes[key];
+	if (childrenLength === 0) return elementObject;
+	let hasElements = false;
+	let hasText = false;
+	let mixed = null;
+	for (let i = 0; i < childrenLength; i++) {
+		const child = children[i];
+		if (typeof child === "string") {
+			hasText = true;
+			if (mixed !== null) mixed.push(child);
+			else if (hasElements || hasAttributes) {
+				for (const propertyKey in elementObject) if (propertyKey.charCodeAt(0) !== DOLLAR) delete elementObject[propertyKey];
+				mixed = [];
+				for (let j = 0; j < i; j++) {
+					const previousChild = children[j];
+					if (typeof previousChild === "string") mixed.push(previousChild);
+					else mixed.push({ [previousChild.tagName]: convertNode(previousChild) });
+				}
+				mixed.push(child);
+			}
+		} else {
+			if (!hasElements && hasText && !hasAttributes) {
+				hasElements = true;
+				mixed = [];
+				for (let j = 0; j < i; j++) mixed.push(children[j]);
+				mixed.push({ [child.tagName]: convertNode(child) });
+				continue;
+			}
+			hasElements = true;
+			const tag = child.tagName;
+			const convertedValue = convertNode(child);
+			if (mixed !== null) mixed.push({ [tag]: convertedValue });
+			else if (!(tag in elementObject)) elementObject[tag] = convertedValue;
+			else if (!Array.isArray(elementObject[tag])) elementObject[tag] = [elementObject[tag], convertedValue];
+			else elementObject[tag].push(convertedValue);
+		}
+	}
+	if (mixed !== null) {
+		elementObject.$$ = mixed;
+		return elementObject;
+	}
+	if (hasElements) return elementObject;
+	let text = "";
+	for (let i = 0; i < childrenLength; i++) text += children[i];
+	return text;
+}
+/**
+* Convert a single `TNode | string` item into its lossy representation.
+*
+* - `TNode` → `{ tagName: convertedValue }` (same shape as the multi-root
+*   branch of `lossy()`)
+* - `string` → passed through as-is
+*
+* Used internally by `XmlParseStream` when `output: 'lossy'` is set.
+*
+* @internal
+*/
+function convertItemToLossy(item) {
+	if (typeof item === "string") return item;
+	return { [item.tagName]: convertNode(item) };
+}
+function lossy(input, options) {
+	const dom = typeof input === "string" ? parse(input, { ...options }) : input;
+	const nodes = [];
+	for (let i = 0; i < dom.length; i++) {
+		const node = dom[i];
+		if (typeof node === "string") {
+			if (node.trim().length > 0) nodes.push(node);
+		} else if (node.tagName[0] === "?") continue;
+		else nodes.push(node);
+	}
+	if (nodes.length === 1) {
+		const node = nodes[0];
+		if (typeof node === "string") return node;
+		return { [node.tagName]: convertNode(node) };
+	}
+	const result = [];
+	for (let i = 0; i < nodes.length; i++) {
+		const node = nodes[i];
+		if (typeof node === "string") result.push(node);
+		else result.push({ [node.tagName]: convertNode(node) });
+	}
+	return result;
+}
+//#endregion
+export { convertItemToLossy, lossy };
+
+//# sourceMappingURL=lossy.mjs.map

package/dist/converters/lossy.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"lossy.mjs","names":[],"sources":["../../src/converters/lossy.ts"],"sourcesContent":["/**\n * lossy — simplified lossy XML-to-JS object converter.\n *\n * Produces the most compact JS object representation possible. Element\n * ordering between different tag names is not preserved. The format rules are:\n *\n * - **Text-only element**: collapses to a plain string value.\n *   `<name>text</name>` → `{ \"name\": \"text\" }`\n *\n * - **Empty/void element**: collapses to `null`.\n *   `<br/>` → `{ \"br\": null }`\n *\n * - **Attributes**: prefixed with `$` on the element object.\n *   `<a href=\"/\">link</a>` → `{ \"a\": { $href: \"/\", $$: [\"link\"] } }`\n *\n * - **Mixed content** (text + child elements): children go into an ordered\n *   `$$` array preserving exact interleaving of text and element objects.\n *   `<p>Hello <b>world</b></p>` → `{ \"p\": { $$: [\"Hello \", { \"b\": \"world\" }] } }`\n *\n * - **Element-only children** (no text): keyed object with tag names.\n *   `<root><a>1</a><b>2</b></root>` → `{ \"root\": { \"a\": \"1\", \"b\": \"2\" } }`\n *\n * - **Repeated same-name siblings**: become an array.\n *   Two `<item>` → `\"item\": [val1, val2]`; one `<item>` → `\"item\": val1`\n *\n * All marker keys are valid JS identifiers so you can use dot notation:\n * `node.$href`, `node.$$`, etc.\n *\n * @example\n * ```ts\n * import { lossy } from \"@eksml/xml/lossy\";\n *\n * const result = lossy(`\n *   <thing>\n *     <second with=\"attributes\">Text</second>\n *     <third>More text</third>\n *     <second another=\"attribute\">Even more text\n *       <fourth>Nested text</fourth>\n *     </second>\n *   </thing>\n * `);\n * // {\n * //   \"thing\": {\n * //     \"second\": [\n * //       { $with: \"attributes\", $$: [\"Text\"] },\n * //       { $another: \"attribute\", $$: [\"Even more text\\n      \", { \"fourth\": \"Nested text\" }] }\n * //     ],\n * //     \"third\": \"More text\"\n * //   }\n * // }\n * ```\n */\n\nimport { parse, type TNode, type ParseOptions } from '#src/parser.ts';\n// @generated:char-codes:begin\nconst DOLLAR = 36; // $\n// @generated:char-codes:end\n\n/** Options for lossy. */\nexport interface LossyOptions extends ParseOptions {}\n\n/** The value of a converted element — null (empty), string, or an object with keys. */\nexport type LossyValue = null | string | LossyObject;\n\n/** An element converted to a keyed object. */\nexport interface LossyObject {\n  [key: string]: LossyValue | LossyValue[] | LossyMixedEntry[];\n}\n\n/** An entry in a `$$` mixed-content array. */\nexport type LossyMixedEntry = string | { [tagName: string]: LossyValue };\n\n/**\n * Convert a single TNode into its simplified lossy value.\n *\n * Single-pass algorithm: starts optimistically building an element-only object,\n * and upgrades to mixed-content ($$ array) if text nodes are encountered\n * alongside element nodes (or attributes exist with text).\n */\nfunction convertNode(node: TNode): LossyValue {\n  const children = node.children;\n  const childrenLength = children ? children.length : 0;\n  const attributes = node.attributes;\n  const hasAttributes = attributes !== null;\n\n  // --- Empty element ---\n  if (childrenLength === 0 && !hasAttributes) {\n    return null;\n  }\n\n  // --- Text-only element, no attributes ---\n  if (\n    childrenLength === 1 &&\n    typeof children[0] === 'string' &&\n    !hasAttributes\n  ) {\n    return children[0];\n  }\n\n  // --- Build object with attributes ---\n  // Use null-prototype object to prevent __proto__ / constructor pollution\n  const elementObject: LossyObject = Object.create(null);\n\n  if (hasAttributes) {\n    for (const key in attributes) {\n      elementObject['$' + key] = attributes[key]!;\n    }\n  }\n\n  if (childrenLength === 0) {\n    // Empty element with attributes only\n    return elementObject;\n  }\n\n  // --- Single-pass: build element-only object, upgrade to mixed if needed ---\n  // Track whether we've seen elements and/or text so far.\n  // When text appears alongside elements (or attrs), switch to $$ mode,\n  // retroactively converting already-processed children.\n  let hasElements = false;\n  let hasText = false;\n  let mixed: LossyMixedEntry[] | null = null;\n\n  for (let i = 0; i < childrenLength; i++) {\n    const child = children[i]!;\n    if (typeof child === 'string') {\n      hasText = true;\n      if (mixed !== null) {\n        // Already in mixed mode\n        mixed.push(child);\n      } else if (hasElements || hasAttributes) {\n        // Upgrade to mixed mode — retroactively convert prior children.\n        // Remove element keys that were speculatively added to elementObject.\n        for (const propertyKey in elementObject) {\n          if (propertyKey.charCodeAt(0) !== DOLLAR)\n            delete elementObject[propertyKey]; // keep $-prefixed attrs\n        }\n        mixed = [];\n        for (let j = 0; j < i; j++) {\n          const previousChild = children[j]!;\n          if (typeof previousChild === 'string') {\n            mixed.push(previousChild);\n          } else {\n            mixed.push({ [previousChild.tagName]: convertNode(previousChild) });\n          }\n        }\n        mixed.push(child);\n      }\n      // If !hasElements && !hasAttributes, we're still in potential text-only mode\n    } else {\n      if (!hasElements && hasText && !hasAttributes) {\n        // First element after text-only so far — upgrade to mixed mode\n        hasElements = true;\n        mixed = [];\n        for (let j = 0; j < i; j++) {\n          mixed.push(children[j] as string);\n        }\n        mixed.push({ [child.tagName]: convertNode(child) });\n        continue;\n      }\n      hasElements = true;\n      const tag = child.tagName;\n      const convertedValue = convertNode(child);\n      if (mixed !== null) {\n        mixed.push({ [tag]: convertedValue });\n      } else {\n        if (!(tag in elementObject)) {\n          elementObject[tag] = convertedValue;\n        } else if (!Array.isArray(elementObject[tag])) {\n          elementObject[tag] = [\n            elementObject[tag] as LossyValue,\n            convertedValue,\n          ];\n        } else {\n          (elementObject[tag] as LossyValue[]).push(convertedValue);\n        }\n      }\n    }\n  }\n\n  // If we switched to mixed mode, attach and return\n  if (mixed !== null) {\n    elementObject.$$ = mixed;\n    return elementObject;\n  }\n\n  // If we had elements, elementObject is already populated — return it\n  if (hasElements) {\n    return elementObject;\n  }\n\n  // --- Text-only, no attributes, multiple text nodes (edge case) ---\n  let text = '';\n  for (let i = 0; i < childrenLength; i++) {\n    text += children[i] as string;\n  }\n  return text;\n}\n\n/**\n * Convert a single `TNode | string` item into its lossy representation.\n *\n * - `TNode` → `{ tagName: convertedValue }` (same shape as the multi-root\n *   branch of `lossy()`)\n * - `string` → passed through as-is\n *\n * Used internally by `XmlParseStream` when `output: 'lossy'` is set.\n *\n * @internal\n */\nexport function convertItemToLossy(item: TNode | string): LossyValue {\n  if (typeof item === 'string') return item;\n  return { [item.tagName]: convertNode(item) } as LossyObject;\n}\n\n/**\n * Parse an XML/HTML string or convert a pre-parsed DOM tree into the most\n * simplified lossy JS object format.\n *\n * @param input - An XML/HTML string, or a pre-parsed `(TNode | string)[]` DOM array\n * @param options - Parsing options (only used when `input` is a string)\n * @returns A LossyValue representing the document. For a single root element\n *          this is typically `{ rootTag: ... }`. For multiple top-level nodes\n *          an array is returned.\n */\nexport function lossy(\n  input: string,\n  options?: LossyOptions,\n): LossyValue | LossyValue[];\nexport function lossy(input: (TNode | string)[]): LossyValue | LossyValue[];\nexport function lossy(\n  input: string | (TNode | string)[],\n  options?: LossyOptions,\n): LossyValue | LossyValue[] {\n  const dom = typeof input === 'string' ? parse(input, { ...options }) : input;\n\n  // Filter out whitespace-only top-level text and processing instructions\n  // (e.g. <?xml version=\"1.0\"?>) which are metadata, not content.\n  const nodes: (TNode | string)[] = [];\n  for (let i = 0; i < dom.length; i++) {\n    const node = dom[i]!;\n    if (typeof node === 'string') {\n      // Keep non-whitespace text at top level\n      if (node.trim().length > 0) {\n        nodes.push(node);\n      }\n    } else if (node.tagName[0] === '?') {\n      // Skip processing instructions (<?xml?>, <?xsl?>, etc.)\n      continue;\n    } else {\n      nodes.push(node);\n    }\n  }\n\n  // Single root element — return as { rootTag: value }\n  if (nodes.length === 1) {\n    const node = nodes[0]!;\n    if (typeof node === 'string') {\n      return node;\n    }\n    return { [node.tagName]: convertNode(node) } as LossyObject;\n  }\n\n  // Multiple top-level nodes — return array\n  const result: LossyValue[] = [];\n  for (let i = 0; i < nodes.length; i++) {\n    const node = nodes[i]!;\n    if (typeof node === 'string') {\n      result.push(node);\n    } else {\n      result.push({ [node.tagName]: convertNode(node) } as LossyObject);\n    }\n  }\n  return result;\n}\n"],"mappings":"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"}

package/dist/htmlConstants-D6fsKbZ-.mjs

@@ -0,0 +1,30 @@
+//#region src/utilities/htmlConstants.ts
+/**
+* Standard HTML void elements that are self-closing and never have children.
+* Used as the default for `selfClosingTags` when `html: true`.
+*/
+const HTML_VOID_ELEMENTS = [
+	"area",
+	"base",
+	"br",
+	"col",
+	"embed",
+	"hr",
+	"img",
+	"input",
+	"link",
+	"meta",
+	"param",
+	"source",
+	"track",
+	"wbr"
+];
+/**
+* HTML elements whose content is raw text (not parsed as markup).
+* Used as the default for `rawContentTags` when `html: true`.
+*/
+const HTML_RAW_CONTENT_TAGS = ["script", "style"];
+//#endregion
+export { HTML_VOID_ELEMENTS as n, HTML_RAW_CONTENT_TAGS as t };
+
+//# sourceMappingURL=htmlConstants-D6fsKbZ-.mjs.map

package/dist/htmlConstants-D6fsKbZ-.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"htmlConstants-D6fsKbZ-.mjs","names":[],"sources":["../src/utilities/htmlConstants.ts"],"sourcesContent":["/**\n * Standard HTML void elements that are self-closing and never have children.\n * Used as the default for `selfClosingTags` when `html: true`.\n */\nexport const HTML_VOID_ELEMENTS = [\n  'area',\n  'base',\n  'br',\n  'col',\n  'embed',\n  'hr',\n  'img',\n  'input',\n  'link',\n  'meta',\n  'param',\n  'source',\n  'track',\n  'wbr',\n];\n\n/**\n * HTML elements whose content is raw text (not parsed as markup).\n * Used as the default for `rawContentTags` when `html: true`.\n */\nexport const HTML_RAW_CONTENT_TAGS = ['script', 'style'];\n"],"mappings":";;;;;AAIA,MAAa,qBAAqB;CAChC;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD;;;;;AAMD,MAAa,wBAAwB,CAAC,UAAU,QAAQ"}

package/dist/parser-BfdEfWDg.d.mts

@@ -0,0 +1,95 @@
+//#region src/parser.d.ts
+/**
+ * A parsed XML node
+ */
+interface TNode {
+  tagName: string;
+  /**
+   * Element attributes, or `null` if the element has no attributes.
+   * Values can be:
+   * - string: attribute with a value (e.g., `<div id="test">` -> `{id: "test"}`)
+   * - null: attribute without a value (e.g., `<input disabled>` -> `{disabled: null}`)
+   * - empty string: attribute with empty value (e.g., `<input value="">` -> `{value: ""}`)
+   */
+  attributes: Record<string, string | null> | null;
+  children: (TNode | string)[];
+}
+/**
+ * Options for parsing XML
+ */
+interface ParseOptions {
+  /** Starting position in the string */
+  pos?: number;
+  /**
+   * Array of tag names that are self-closing (void elements) and don't need closing tags.
+   * In XML mode (default), this defaults to `[]` — self-closing is detected only by `/>` syntax.
+   * In HTML mode (`html: true`), this defaults to the standard HTML void elements.
+   * Can be overridden explicitly regardless of mode.
+   */
+  selfClosingTags?: string[];
+  /**
+   * Array of tag names whose content should be treated as raw text, not parsed as XML/HTML.
+   * The parser will scan for the matching `</tagName>` close tag and emit everything between
+   * as a single text child node.
+   *
+   * In XML mode (default), this defaults to `[]`.
+   * In HTML mode (`html: true`), this defaults to `["script", "style"]`.
+   * Can be overridden explicitly regardless of mode.
+   */
+  rawContentTags?: string[];
+  /**
+   * Enable HTML parsing mode. When `true`, sets sensible defaults for:
+   * - `selfClosingTags`: standard HTML void elements (area, base, br, col, embed, hr, img, input, link, meta, param, source, track, wbr)
+   * - `rawContentTags`: elements whose content is raw text (script, style)
+   *
+   * These defaults can be overridden by explicitly passing `selfClosingTags` or `rawContentTags`.
+   */
+  html?: boolean;
+  /** Keep XML comments in the output */
+  keepComments?: boolean;
+  /** Trim whitespace from text nodes and discard whitespace-only text nodes */
+  trimWhitespace?: boolean;
+  /**
+   * Strict mode: throw on malformed XML instead of recovering silently.
+   * Catches unclosed comments, CDATA sections, processing instructions,
+   * close tags, and open tags that reach end-of-input without closing.
+   */
+  strict?: boolean;
+  /**
+   * Decode XML/HTML entities in text content and attribute values.
+   * When enabled, named entities (`&amp;`, `&lt;`, etc.), decimal character
+   * references (`&#228;`), and hex character references (`&#xe4;`) are decoded.
+   *
+   * In HTML mode (`html: true`), the full set of HTML named entities is
+   * supported (e.g. `&nbsp;`, `&copy;`, `&mdash;`). In XML mode, only the
+   * five standard XML entities plus numeric references are decoded.
+   *
+   * CDATA sections are never decoded regardless of this setting.
+   *
+   * Defaults to `false` — entities are preserved as-is in the output.
+   */
+  entities?: boolean;
+  /** Attribute name to search for (used with attrValue) */
+  attrName?: string;
+  /** Attribute value to search for (regex pattern) */
+  attrValue?: string;
+  /** Filter function to apply to nodes */
+  filter?: (node: TNode, index: number, depth: number, path: string) => boolean;
+}
+/** Internal options extending ParseOptions — not part of the public API. */
+interface InternalParseOptions extends ParseOptions {
+  /** If true, the returned object will have a pos property indicating where parsing stopped */
+  setPos?: boolean;
+  /** Parse a single node instead of a list of nodes */
+  parseNode?: boolean;
+}
+/**
+ * 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
+ */
+declare function parse(S: string, options?: ParseOptions | InternalParseOptions): (TNode | string)[];
+//#endregion
+export { TNode as n, parse as r, ParseOptions as t };
+//# sourceMappingURL=parser-BfdEfWDg.d.mts.map

package/dist/parser-BfdEfWDg.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser-BfdEfWDg.d.mts","names":[],"sources":["../src/parser.ts"],"mappings":";;AAyBA;;UAAiB,KAAA;EACf,OAAA;EAAA;;;;;;;EAQA,UAAA,EAAY,MAAA;EACZ,QAAA,GAAW,KAAA;AAAA;;;;UAaI,YAAA;EA2Bf;EAzBA,GAAA;EA6BA;;;;;;EAtBA,eAAA;EAgDU;;;;;;AACX;;;EAvCC,cAAA;EA0CqC;;;;;AAwBvC;;EA1DE,IAAA;EA4DU;EA1DV,YAAA;EA2DE;EAzDF,cAAA;EAyDO;;;;;EAnDP,MAAA;EAmDO;;;;;;;;;;;;;EArCP,QAAA;;EAEA,QAAA;;EAEA,SAAA;;EAEA,MAAA,IAAU,IAAA,EAAM,KAAA,EAAO,KAAA,UAAe,KAAA,UAAe,IAAA;AAAA;;UAI7C,oBAAA,SAA6B,YAAA;;EAErC,MAAA;;EAEA,SAAA;AAAA;;;;;;;iBAoBc,KAAA,CACd,CAAA,UACA,OAAA,GAAU,YAAA,GAAe,oBAAA,IACvB,KAAA"}