@endevops/effect-codec-xml 0.0.1

package/dist/parse.d.ts

@@ -0,0 +1,75 @@
+import { XmlVersion } from "./naming.js";
+import { XmlParseError } from "./errors.js";
+import { NameMode } from "./conventions.js";
+import { XmlValue } from "./xml-value.js";
+import { Effect } from "effect";
+//#region src/parse.d.ts
+/**
+ * @description A parsed document: the root element's name, and its content as an {@link XmlValue}.
+ */
+export interface XmlDocument {
+  /**
+   * @description The root element's name as it appeared in the source, after name resolution.
+   */
+  readonly name: string;
+  /**
+   * @description The root element's content. The root's own name is not part of it, the same way a schema's encoded form does not carry a name for the value it
+   * describes.
+   */
+  readonly value: XmlValue;
+}
+/**
+ * @description Options for {@link parseXml} and {@link parseXmlDocument}.
+ */
+export interface XmlParseOptions {
+  /**
+   * @description Keep the whitespace at the edges of every text run.
+   *
+   * @default false\
+   * which trims it — and trimming is what makes a pretty-printed document
+   * read as the same value as an unindented one, because the indentation around a child element and around a closing tag lands at the edges of its
+   * parent's text. Whitespace _inside_ a run is content and is never touched either way, so `'one two'` and a paragraph with a newline in the middle
+   * of it survive. Set it to `true` to keep leading and trailing spaces in text exactly as written, at the cost of a document that was laid out on
+   * several lines no longer reading the same as one that was not.
+   */
+  readonly preserveWhitespace?: boolean | undefined;
+  /**
+   * @description How deep to nest before giving up. Guards against a document crafted to exhaust the stack.
+   *
+   * @default 256
+   */
+  readonly maxDepth?: number | undefined;
+  /**
+   * @description What to do with an element or attribute name that is not a legal XML name.
+   *
+   * @default 'repair'\
+   * the same default {@link renderXml} uses, so a name that renders and a name that parses come out the same.
+   */
+  readonly name?: NameMode | undefined;
+  /**
+   * @description XML version to validate names against.
+   *
+   * @default '1.0'
+   */
+  readonly xmlVersion?: XmlVersion | undefined;
+}
+/**
+ * @description Parses an XML document into its root element's content.\
+ * The walk itself is synchronous, but it reports a malformed document by failing with an {@link XmlParseError} rather than by throwing, so the failure lands in the effect's error channel where `catchTag`, `retry` and a fallback can all
+ * see it. A failed parse is an expected outcome of reading untrusted text — it is what those combinators key off — and only a defect would hide it.
+ * The span is the boundary a performance trace hangs off: it carries the document's length, which is the size that drives the parser's cost, so a
+ * slow parse in a profile can be attributed to the input that produced it. A caller that wants the value outside an `Effect` uses
+ * {@link parseXmlDocument}, which runs the same walk synchronously and throws instead. The walk is plain recursive descent rather than a chain of
+ * `yield*`es. Publicly `parseXml` is still an `Effect` — it suspends the walk so it runs lazily under the span, and folds the failure the walk throws
+ * into the typed error channel — but inside a document there is no effect boundary per tag, attribute or text run. A 500-row report is thousands of
+ * those, and a fiber step for each of them was most of what the `parse 500 rows` row measured. The typed failure survives: the walk throws an
+ * {@link XmlParseError} and `parseXml` catches it into `Effect.fail`.
+ *
+ * @param text - The document to read.
+ * @param options - Whitespace, depth and name-handling settings.
+ *
+ * @returns An effect producing the root element's content as an {@link XmlValue}.
+ */
+export declare const parseXml: (text: string, options?: XmlParseOptions) => Effect.Effect<XmlValue, XmlParseError>;
+//#endregion
+//# sourceMappingURL=parse.d.ts.map

package/dist/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","names":[],"sources":["../src/parse.ts"],"mappings":";;;;;;;;;iBAeiB;;;;WAIN;;;;;WAMA,OAAO;;;;;iBAMD;;;;;;;;;;;WAWN;;;;;;WAOA;;;;;;;WAQA,OAAO;;;;;;WAOP,aAAa;;;;;;;;;;;;;;;;;;;qBAoBX,WAAQ,cAAgB,UAAW,oBAAuB,OAAO,OAAO,UAAU"}

package/dist/parse.js

@@ -0,0 +1,437 @@
+import { XmlParseError } from "./errors.js";
+import { TEXT_KEY, resolveNameSync } from "./conventions.js";
+import { EntityDecoder } from "./entities/entity-decoder.js";
+import { Effect, Predicate, Result } from "effect";
+//#region src/parse.ts
+const decoder = EntityDecoder.make().pipe(Effect.runSync);
+/**
+* @description Parses an XML document into its root element's content.\
+* The walk itself is synchronous, but it reports a malformed document by failing with an {@link XmlParseError} rather than by throwing, so the failure lands in the effect's error channel where `catchTag`, `retry` and a fallback can all
+* see it. A failed parse is an expected outcome of reading untrusted text — it is what those combinators key off — and only a defect would hide it.
+* The span is the boundary a performance trace hangs off: it carries the document's length, which is the size that drives the parser's cost, so a
+* slow parse in a profile can be attributed to the input that produced it. A caller that wants the value outside an `Effect` uses
+* {@link parseXmlDocument}, which runs the same walk synchronously and throws instead. The walk is plain recursive descent rather than a chain of
+* `yield*`es. Publicly `parseXml` is still an `Effect` — it suspends the walk so it runs lazily under the span, and folds the failure the walk throws
+* into the typed error channel — but inside a document there is no effect boundary per tag, attribute or text run. A 500-row report is thousands of
+* those, and a fiber step for each of them was most of what the `parse 500 rows` row measured. The typed failure survives: the walk throws an
+* {@link XmlParseError} and `parseXml` catches it into `Effect.fail`.
+*
+* @param text - The document to read.
+* @param options - Whitespace, depth and name-handling settings.
+*
+* @returns An effect producing the root element's content as an {@link XmlValue}.
+*/
+const parseXml = (text, options = {}) => Effect.suspend(() => Effect.fromResult(parseDocumentResult(text, options))).pipe(Effect.map((document) => document.value), Effect.withSpan("XmlCodec.parseXml", { attributes: { "xml.length": text.length } }));
+/**
+* @description Whether a character is XML whitespace. XML defines exactly four, and they are the only ones a parser may treat as insignificant.
+*
+* @param code - A UTF-16 code unit.
+*
+* @returns Whether the character is XML whitespace.
+*/
+const isWhitespace = (code) => code === 32 || code === 10 || code === 9 || code === 13;
+/**
+* @description `<`
+*/
+const LT = 60;
+/**
+* @description `>`
+*/
+const GT = 62;
+/**
+* @description `/`
+*/
+const SLASH = 47;
+/**
+* @description `=`
+*/
+const EQUALS = 61;
+/**
+* @description Parses a whole document: a prolog, exactly one root element, and nothing but whitespace after it. The walk is synchronous and reports a malformed
+* document by throwing an {@link XmlParseError}; {@link parseXml} folds that into the effect's typed error channel.
+*
+* @param text - The document to read.
+* @param options - Whitespace, depth and name-handling settings.
+*
+* @returns The root element's name and content.
+*
+* @throws {XmlParseError} When the document is not well-formed.
+*/
+const parseDocument = (text, options) => {
+	const resolved = {
+		preserveWhitespace: options.preserveWhitespace ?? false,
+		maxDepth: options.maxDepth ?? 256,
+		name: options.name ?? "repair",
+		xmlVersion: options.xmlVersion ?? "1.0"
+	};
+	let at = 0;
+	/**
+	* @description The options every name is resolved with, built once. They cannot change during a parse, and building them per name would allocate one object per
+	* element and per attribute in the document.
+	*/
+	const nameOptions = {
+		mode: resolved.name,
+		xmlVersion: resolved.xmlVersion
+	};
+	/**
+	* @description Names already resolved by this parse. A document repeats names — every one of five hundred rows has a `sku` — and a validator that ran per
+	* occurrence would pay for the same answer five hundred times.
+	*/
+	const nameCache = /* @__PURE__ */ new Map();
+	const resolve = (raw, what, position) => {
+		const cached = nameCache.get(raw);
+		if (cached !== void 0) return cached;
+		let name;
+		try {
+			name = resolveNameSync(raw, nameOptions);
+		} catch (failure) {
+			const reason = Predicate.isError(failure) ? failure.message : String(failure);
+			throw new XmlParseError({
+				message: `${what} ${JSON.stringify(raw)} is not a legal XML name: ${reason}`,
+				position,
+				input: text
+			});
+		}
+		nameCache.set(raw, name);
+		return name;
+	};
+	/**
+	* @description Reads to the end of a `<!-- -->`, `<? ?>` or `<!DOCTYPE >` construct, and reports the one past its last character.
+	*/
+	const skipUntil = (marker, start, what) => {
+		const end = text.indexOf(marker, start);
+		if (end === -1) throw new XmlParseError({
+			message: `Unterminated ${what}`,
+			position: start,
+			input: text
+		});
+		return end + marker.length;
+	};
+	const skipDoctype = (start) => {
+		let depth = 0;
+		for (let i = start + 9; i < text.length; i++) {
+			const char = text[i];
+			if (char === "[") depth++;
+			else if (char === "]") depth--;
+			else if (char === ">" && depth <= 0) return i + 1;
+		}
+		throw new XmlParseError({
+			message: "Unterminated DOCTYPE declaration",
+			position: start,
+			input: text
+		});
+	};
+	/**
+	* @description Consumes whitespace, comments, processing instructions and a DOCTYPE, leaving the cursor on the first character that is none of them — or at the
+	* end of the document.
+	*/
+	const skipMisc = () => {
+		for (;;) {
+			while (at < text.length && isWhitespace(text.charCodeAt(at))) at++;
+			if (at >= text.length) return;
+			if (text.charCodeAt(at) !== LT) return;
+			if (text.startsWith("<!--", at)) at = skipUntil("-->", at + 4, "comment");
+			else if (text.startsWith("<?", at)) at = skipUntil("?>", at + 2, "processing instruction");
+			else if (text.startsWith("<!DOCTYPE", at)) at = skipDoctype(at);
+			else return;
+		}
+	};
+	/**
+	* @description Reads a name up to the character that ends it, advancing the cursor past it.
+	*/
+	const readName = (what) => {
+		const start = at;
+		while (at < text.length) {
+			const char = text.charCodeAt(at);
+			if (isWhitespace(char) || char === SLASH || char === EQUALS || char === GT) break;
+			at++;
+		}
+		if (at === start) throw new XmlParseError({
+			message: `Expected a ${what}`,
+			position: start,
+			input: text
+		});
+		return text.slice(start, at);
+	};
+	const skipSpaces = () => {
+		while (at < text.length && isWhitespace(text.charCodeAt(at))) at++;
+	};
+	const readAttributeValue = (name, nameStart) => {
+		const quote = text[at];
+		if (quote !== "\"" && quote !== "'") throw new XmlParseError({
+			message: `Attribute "${name}" has no quoted value`,
+			position: nameStart,
+			input: text
+		});
+		at++;
+		const end = text.indexOf(quote ?? "", at);
+		if (end === -1) throw new XmlParseError({
+			message: `Unterminated value for attribute "${name}"`,
+			position: at,
+			input: text
+		});
+		const raw = text.slice(at, end);
+		at = end + 1;
+		return decodeEntities(raw);
+	};
+	const readStartTag = () => {
+		const record = {};
+		let hasAttributes = false;
+		for (;;) {
+			skipSpaces();
+			if (at >= text.length) throw new XmlParseError({
+				message: "Unterminated start tag",
+				position: at,
+				input: text
+			});
+			if (text.charCodeAt(at) === GT) {
+				at++;
+				return {
+					record,
+					selfClosing: false,
+					hasAttributes
+				};
+			}
+			if (text.charCodeAt(at) === SLASH && text[at + 1] === ">") {
+				at += 2;
+				return {
+					record,
+					selfClosing: true,
+					hasAttributes
+				};
+			}
+			const nameStart = at;
+			const name = resolve(readName("attribute name"), "Attribute", nameStart);
+			skipSpaces();
+			if (text.charCodeAt(at) !== EQUALS) throw new XmlParseError({
+				message: `Attribute "${name}" has no "="`,
+				position: at,
+				input: text
+			});
+			at++;
+			skipSpaces();
+			record["@" + name] = readAttributeValue(name, nameStart);
+			hasAttributes = true;
+		}
+	};
+	const readElement = (depth) => {
+		if (depth > resolved.maxDepth) throw new XmlParseError({
+			message: `Element nesting exceeded maxDepth (${resolved.maxDepth})`,
+			position: at,
+			input: text
+		});
+		if (text.charCodeAt(at) !== LT) throw new XmlParseError({
+			message: "Expected an element",
+			position: at,
+			input: text
+		});
+		at++;
+		const name = resolve(readName("element name"), "Element", at);
+		const { record, selfClosing, hasAttributes } = readStartTag();
+		if (selfClosing) return {
+			name,
+			value: finishElement(record, hasAttributes, "", false)
+		};
+		const content = readContent(name, record, depth);
+		return {
+			name,
+			value: finishElement(record, hasAttributes, content.text, content.hasChildren)
+		};
+	};
+	/**
+	* @description Reads an element's body up to and including its closing tag, folding what it finds into the record the start tag produced. Returns when the
+	* closing tag has been consumed; failing on it is {@link readClosingTag}'s job, so that a mismatched or unclosed tag is reported the same way
+	* wherever it was found.
+	*
+	* @param name - The name the start tag gave the element, which its closing tag has to match.
+	* @param record - The record to fold the children into.
+	* @param depth - The depth the element sits at; its children are one deeper.
+	*
+	* @returns The body as character data, and whether it held any child element.
+	*/
+	const readContent = (name, record, depth) => {
+		let childText = "";
+		let hasChildren = false;
+		for (;;) switch (classifyContent(name)) {
+			case "text":
+				childText += readTextRun();
+				break;
+			case "close":
+				readClosingTag(name);
+				return {
+					text: childText,
+					hasChildren
+				};
+			case "comment":
+				at = skipUntil("-->", at + 4, "comment");
+				break;
+			case "cdata":
+				childText += readCdata();
+				break;
+			case "instruction":
+				at = skipUntil("?>", at + 2, "processing instruction");
+				break;
+			case "child":
+				hasChildren = true;
+				addChild(record, readElement(depth + 1));
+		}
+	};
+	/**
+	* @description What the cursor is sitting on inside an element's body. The two things the loop cannot read are refused here rather than in it: running out of
+	* document and a declaration, which is markup the parser does not accept inside an element. Recognising the constructs that _are_ read is the rest,
+	* and the order is the one that rules out the shorter prefixes first — `</` before `<?` before any other `<!`, and `<![CDATA[` before the `<!` that
+	* would otherwise match it.
+	*
+	* @param name - The name the enclosing element's start tag gave it, for the unterminated-body message.
+	*
+	* @returns What the cursor is on.
+	*/
+	const classifyContent = (name) => {
+		if (at >= text.length) throw new XmlParseError({
+			message: `Unclosed element <${name}>`,
+			position: at,
+			input: text
+		});
+		if (text.charCodeAt(at) !== LT) return "text";
+		if (text.startsWith("</", at)) return "close";
+		if (text.startsWith("<!--", at)) return "comment";
+		if (text.startsWith("<![CDATA[", at)) return "cdata";
+		if (text.startsWith("<?", at)) return "instruction";
+		if (text.startsWith("<!", at)) throw new XmlParseError({
+			message: "A declaration is not allowed inside an element",
+			position: at,
+			input: text
+		});
+		return "child";
+	};
+	/**
+	* @description Consumes a `</name>`, checking on the way that it is the tag that closes this element and that it is well-formed.
+	*
+	* @param name - The name the start tag gave the element, which the closing tag has to match.
+	*/
+	const readClosingTag = (name) => {
+		const closeStart = at;
+		at += 2;
+		const closing = readName("element name");
+		if (closing !== name) throw new XmlParseError({
+			message: `Closing tag </${closing}> does not match <${name}>`,
+			position: closeStart,
+			input: text
+		});
+		skipSpaces();
+		if (text.charCodeAt(at) !== GT) throw new XmlParseError({
+			message: `Malformed closing tag </${closing}>`,
+			position: at,
+			input: text
+		});
+		at++;
+	};
+	/**
+	* @description Reads the run of character data up to the next `<`, or to the end of the document.
+	*
+	* @returns The run, with its character references expanded.
+	*/
+	const readTextRun = () => {
+		const next = text.indexOf("<", at);
+		const end = next === -1 ? text.length : next;
+		const run = decodeEntities(text.slice(at, end));
+		at = end;
+		return run;
+	};
+	/**
+	* @description Reads a `<![CDATA[…]]>` section. CDATA is character data, and character data is what it holds, so it joins the element's text as it stands — the
+	* entities in it are literal text and must not be expanded.
+	*
+	* @returns The section's contents.
+	*/
+	const readCdata = () => {
+		const end = text.indexOf("]]>", at + 9);
+		if (end === -1) throw new XmlParseError({
+			message: "Unterminated CDATA section",
+			position: at,
+			input: text
+		});
+		const data = text.slice(at + 9, end);
+		at = end + 3;
+		return data;
+	};
+	/**
+	* @description Adds a child to its parent's record. Two children under one name make an array, and the first one does not: a schema can tell a repeated field
+	* from a single one by the shape, and an array of one is not what a single value encodes to.
+	*
+	* @param record - The parent's record, added to in place.
+	* @param child - The child element as it was read.
+	*/
+	const addChild = (record, child) => {
+		const existing = record[child.name];
+		if (existing === void 0) record[child.name] = child.value;
+		else if (Array.isArray(existing)) existing.push(child.value);
+		else record[child.name] = [existing, child.value];
+	};
+	/**
+	* @description Decides what an element with the given attributes, text and children reduces to.
+	*/
+	const finishElement = (record, hasAttributes, text, hasChildren) => {
+		const content = resolved.preserveWhitespace ? text : text.trim();
+		if (!hasAttributes && !hasChildren) return content;
+		if (content !== "") record[TEXT_KEY] = content;
+		return record;
+	};
+	skipMisc();
+	if (at >= text.length || text.charCodeAt(at) !== LT) throw new XmlParseError({
+		message: "Document has no root element",
+		position: at,
+		input: text
+	});
+	const root = readElement(0);
+	skipMisc();
+	if (at < text.length) throw new XmlParseError({
+		message: "Unexpected content after the root element",
+		position: at,
+		input: text
+	});
+	return {
+		name: root.name,
+		value: root.value
+	};
+};
+/**
+* @description Runs the synchronous walk and folds the one failure it reports into a {@link Result}, which {@link parseXml} turns back into an `Effect`. Kept
+* separate so the walk itself can throw without the public API ever throwing.
+*
+* @param text - The document to read.
+* @param options - The options as the caller wrote them.
+*
+* @returns The document, or the failure to report.
+*/
+const parseDocumentResult = (text, options) => {
+	try {
+		return Result.succeed(parseDocument(text, options));
+	} catch (cause) {
+		if (cause instanceof XmlParseError) return Result.fail(cause);
+		return Result.fail(new XmlParseError({
+			message: Predicate.isError(cause) ? cause.message : String(cause),
+			position: -1,
+			input: text
+		}));
+	}
+};
+/**
+* @description Decodes character references, falling back to the raw text when the reference is not one the decoder recognises. The fallback is what makes a bare
+* `&` survivable: the decoder treats it as a malformed reference and fails, and a document containing one is far more likely to be worth reading than
+* to be rejected. The `&` is escaped on the way out, so the value still round-trips. The decoder answers with an `Effect`, and this is the one place
+* a parse still runs one. It is only reached when the raw text holds an `&` — the common case returns before it — and the effect is synchronous, so
+* the run is cheap next to the decoder's own work.
+*
+* @param raw - Text read straight from the source, with references unexpanded.
+*
+* @returns The decoded text, which cannot fail.
+*/
+const decodeEntities = (raw) => {
+	if (raw.indexOf("&") === -1) return raw;
+	return Effect.runSync(Effect.orElseSucceed(decoder.decode(raw), () => raw));
+};
+//#endregion
+export { parseXml };
+
+//# sourceMappingURL=parse.js.map

package/dist/parse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.js","names":[],"sources":["../src/parse.ts"],"sourcesContent":["import { Effect, Predicate, Result } from 'effect';\n\nimport type { NameMode } from './conventions.ts';\nimport type { XmlVersion } from './naming.ts';\nimport type { XmlValue } from './xml-value.ts';\n\nimport { ATTRIBUTE_PREFIX, resolveNameSync, TEXT_KEY } from './conventions.ts';\nimport { EntityDecoder } from './entities/entity-decoder.ts';\nimport { XmlParseError } from './errors.ts';\n\nconst decoder = EntityDecoder.make().pipe(Effect.runSync);\n\n/**\n * @description A parsed document: the root element's name, and its content as an {@link XmlValue}.\n */\nexport interface XmlDocument {\n  /**\n   * @description The root element's name as it appeared in the source, after name resolution.\n   */\n  readonly name: string;\n\n  /**\n   * @description The root element's content. The root's own name is not part of it, the same way a schema's encoded form does not carry a name for the value it\n   * describes.\n   */\n  readonly value: XmlValue;\n}\n\n/**\n * @description Options for {@link parseXml} and {@link parseXmlDocument}.\n */\nexport interface XmlParseOptions {\n  /**\n   * @description Keep the whitespace at the edges of every text run.\n   *\n   * @default false\\\n   * which trims it — and trimming is what makes a pretty-printed document\n   * read as the same value as an unindented one, because the indentation around a child element and around a closing tag lands at the edges of its\n   * parent's text. Whitespace _inside_ a run is content and is never touched either way, so `'one two'` and a paragraph with a newline in the middle\n   * of it survive. Set it to `true` to keep leading and trailing spaces in text exactly as written, at the cost of a document that was laid out on\n   * several lines no longer reading the same as one that was not.\n   */\n  readonly preserveWhitespace?: boolean | undefined;\n\n  /**\n   * @description How deep to nest before giving up. Guards against a document crafted to exhaust the stack.\n   *\n   * @default 256\n   */\n  readonly maxDepth?: number | undefined;\n\n  /**\n   * @description What to do with an element or attribute name that is not a legal XML name.\n   *\n   * @default 'repair'\\\n   * the same default {@link renderXml} uses, so a name that renders and a name that parses come out the same.\n   */\n  readonly name?: NameMode | undefined;\n\n  /**\n   * @description XML version to validate names against.\n   *\n   * @default '1.0'\n   */\n  readonly xmlVersion?: XmlVersion | undefined;\n}\n\n/**\n * @description Parses an XML document into its root element's content.\\\n * The walk itself is synchronous, but it reports a malformed document by failing with an {@link XmlParseError} rather than by throwing, so the failure lands in the effect's error channel where `catchTag`, `retry` and a fallback can all\n * see it. A failed parse is an expected outcome of reading untrusted text — it is what those combinators key off — and only a defect would hide it.\n * The span is the boundary a performance trace hangs off: it carries the document's length, which is the size that drives the parser's cost, so a\n * slow parse in a profile can be attributed to the input that produced it. A caller that wants the value outside an `Effect` uses\n * {@link parseXmlDocument}, which runs the same walk synchronously and throws instead. The walk is plain recursive descent rather than a chain of\n * `yield*`es. Publicly `parseXml` is still an `Effect` — it suspends the walk so it runs lazily under the span, and folds the failure the walk throws\n * into the typed error channel — but inside a document there is no effect boundary per tag, attribute or text run. A 500-row report is thousands of\n * those, and a fiber step for each of them was most of what the `parse 500 rows` row measured. The typed failure survives: the walk throws an\n * {@link XmlParseError} and `parseXml` catches it into `Effect.fail`.\n *\n * @param text - The document to read.\n * @param options - Whitespace, depth and name-handling settings.\n *\n * @returns An effect producing the root element's content as an {@link XmlValue}.\n */\nexport const parseXml = (text: string, options: XmlParseOptions = {}): Effect.Effect<XmlValue, XmlParseError> =>\n  Effect.suspend(() => Effect.fromResult(parseDocumentResult(text, options))).pipe(\n    Effect.map(document => document.value),\n    Effect.withSpan('XmlCodec.parseXml', { attributes: { 'xml.length': text.length } })\n  );\n\n/**\n * @description Parses an XML document, keeping the root element's name. This is the synchronous form of {@link parseXml}: it runs the same walk and throws the\n * {@link XmlParseError} the effect would have failed with, for a caller that is not already in an `Effect`.\n *\n * @deprecated\n *\n * @param text - The document to read.\n * @param options - Whitespace, depth and name-handling settings.\n *\n * @returns The root element's name and content.\n *\n * @throws {XmlParseError} When the document is not well-formed.\n */\nexport const parseXmlDocument = (text: string, options: XmlParseOptions = {}): XmlDocument => parseDocument(text, options);\n\n/**\n * @description Options every parse call needs, with the defaults already applied.\n */\ninterface ResolvedOptions {\n  readonly preserveWhitespace: boolean;\n  readonly maxDepth: number;\n  readonly name: NameMode;\n  readonly xmlVersion: XmlVersion;\n}\n\n/**\n * @description Whether a character is XML whitespace. XML defines exactly four, and they are the only ones a parser may treat as insignificant.\n *\n * @param code - A UTF-16 code unit.\n *\n * @returns Whether the character is XML whitespace.\n */\nconst isWhitespace = (code: number): boolean => code === 32 || code === 10 || code === 9 || code === 13;\n\n/**\n * @description `<`\n */\nconst LT = 60;\n/**\n * @description `>`\n */\nconst GT = 62;\n/**\n * @description `/`\n */\nconst SLASH = 47;\n/**\n * @description `=`\n */\nconst EQUALS = 61;\n\n/**\n * @description One element as the parser saw it: the name it was written under, and the value it holds. Carrying the name alongside the value is what lets the\n * parent file it correctly — the value alone cannot say, because a text-only element reduces to a bare string.\n */\ninterface Element {\n  readonly name: string;\n  readonly value: XmlValue;\n}\n\n/**\n * @description What a start tag yielded: the record its attributes went into, which becomes the element's value, and whether the tag closed itself.\n */\ninterface StartTag {\n  readonly record: Record<string, XmlValue>;\n  readonly selfClosing: boolean;\n\n  /**\n   * @description Whether the tag carried any attribute. Counted as they are read rather than asked of the record afterwards, which would mean a key array per\n   * element.\n   */\n  readonly hasAttributes: boolean;\n}\n\n/**\n * @description An element's body as the parser read it: the character data it accumulated, and whether any child element went into the record.\n */\ninterface Content {\n  /**\n   * @description Every text run in the body, concatenated in the order they appeared.\n   */\n  readonly text: string;\n\n  /**\n   * @description Whether the body held at least one child element. Counted rather than asked of the record afterwards, because a child whose fields are all absent\n   * leaves no trace of itself in the record and must still keep its element from being written self-closing.\n   */\n  readonly hasChildren: boolean;\n}\n\n/**\n * @description What sits at the cursor inside an element's body. Naming what is there before deciding what to do with it is what lets the content loop stay a\n * dispatch: each construct is recognised in one place, against the ones that cannot be confused with it, rather than by a chain of `startsWith`\n * guesses where each had to remember what the last had already ruled out.\n */\ntype Construct = 'text' | 'close' | 'comment' | 'cdata' | 'instruction' | 'child';\n\n/**\n * @description Parses a whole document: a prolog, exactly one root element, and nothing but whitespace after it. The walk is synchronous and reports a malformed\n * document by throwing an {@link XmlParseError}; {@link parseXml} folds that into the effect's typed error channel.\n *\n * @param text - The document to read.\n * @param options - Whitespace, depth and name-handling settings.\n *\n * @returns The root element's name and content.\n *\n * @throws {XmlParseError} When the document is not well-formed.\n */\nconst parseDocument = (text: string, options: XmlParseOptions): XmlDocument => {\n  const resolved: ResolvedOptions = {\n    preserveWhitespace: options.preserveWhitespace ?? false,\n    maxDepth: options.maxDepth ?? 256,\n    name: options.name ?? 'repair',\n    xmlVersion: options.xmlVersion ?? '1.0',\n  };\n\n  let at = 0;\n\n  /**\n   * @description The options every name is resolved with, built once. They cannot change during a parse, and building them per name would allocate one object per\n   * element and per attribute in the document.\n   */\n  const nameOptions = { mode: resolved.name, xmlVersion: resolved.xmlVersion };\n\n  /**\n   * @description Names already resolved by this parse. A document repeats names — every one of five hundred rows has a `sku` — and a validator that ran per\n   * occurrence would pay for the same answer five hundred times.\n   */\n  const nameCache = new Map<string, string>();\n\n  const resolve = (raw: string, what: string, position: number): string => {\n    const cached = nameCache.get(raw);\n    if (cached !== undefined) return cached;\n\n    // `resolveNameSync` reports an illegal name by throwing an `XmlParseError`; the failure is reworded\n    // here so it names the position in the document and whether the name belonged to an element or\n    // an attribute, which a generic name resolver cannot know.\n    let name: string;\n    try {\n      name = resolveNameSync(raw, nameOptions);\n    } catch (failure) {\n      const reason = Predicate.isError(failure) ? failure.message : String(failure);\n      throw new XmlParseError({ message: `${what} ${JSON.stringify(raw)} is not a legal XML name: ${reason}`, position, input: text });\n    }\n\n    nameCache.set(raw, name);\n    return name;\n  };\n\n  /**\n   * @description Reads to the end of a `<!-- -->`, `<? ?>` or `<!DOCTYPE >` construct, and reports the one past its last character.\n   */\n  const skipUntil = (marker: string, start: number, what: string): number => {\n    const end = text.indexOf(marker, start);\n    if (end === -1) throw new XmlParseError({ message: `Unterminated ${what}`, position: start, input: text });\n    return end + marker.length;\n  };\n\n  const skipDoctype = (start: number): number => {\n    let depth = 0;\n    for (let i = start + 9; i < text.length; i++) {\n      const char = text[i];\n      if (char === '[') depth++;\n      else if (char === ']') depth--;\n      else if (char === '>' && depth <= 0) return i + 1;\n    }\n    throw new XmlParseError({ message: 'Unterminated DOCTYPE declaration', position: start, input: text });\n  };\n\n  /**\n   * @description Consumes whitespace, comments, processing instructions and a DOCTYPE, leaving the cursor on the first character that is none of them — or at the\n   * end of the document.\n   */\n  const skipMisc = (): void => {\n    for (;;) {\n      while (at < text.length && isWhitespace(text.charCodeAt(at))) {\n        at++;\n      }\n\n      if (at >= text.length) {\n        return; // whitespace ran to the end of the document: consumed, and that is the end\n      }\n\n      if (text.charCodeAt(at) !== LT) {\n        return; // real content: leave the cursor on it for the caller\n      }\n\n      if (text.startsWith('<!--', at)) {\n        at = skipUntil('-->', at + 4, 'comment');\n      } else if (text.startsWith('<?', at)) {\n        at = skipUntil('?>', at + 2, 'processing instruction');\n      } else if (text.startsWith('<!DOCTYPE', at)) {\n        at = skipDoctype(at);\n      } else {\n        return; // the start of the root element, or of a closing tag\n      }\n    }\n  };\n\n  /**\n   * @description Reads a name up to the character that ends it, advancing the cursor past it.\n   */\n  const readName = (what: string): string => {\n    const start = at;\n    while (at < text.length) {\n      const char = text.charCodeAt(at);\n      // Whitespace, `/`, `=` and `>` all end a name. Stopping on `/` and `>` is what lets `<a/>` and `<a>` share one loop.\n      if (isWhitespace(char) || char === SLASH || char === EQUALS || char === GT) {\n        break;\n      }\n      at++;\n    }\n    if (at === start) {\n      throw new XmlParseError({ message: `Expected a ${what}`, position: start, input: text });\n    }\n    return text.slice(start, at);\n  };\n\n  const skipSpaces = (): void => {\n    while (at < text.length && isWhitespace(text.charCodeAt(at))) at++;\n  };\n\n  const readAttributeValue = (name: string, nameStart: number): string => {\n    const quote = text[at];\n    // `indexOf` below is only reached once `quote` is known to be a real quote,\n    // which the guard establishes; the `?? ''` is unreachable and exists only to\n    // keep the type of the index lookup a `string`.\n    if (quote !== '\"' && quote !== \"'\") {\n      throw new XmlParseError({ message: `Attribute \"${name}\" has no quoted value`, position: nameStart, input: text });\n    }\n\n    at++;\n\n    const end = text.indexOf(quote ?? '', at);\n    // A raw quote cannot appear inside a quoted value — it would have to be written `&quot;` — so the next quote of the same kind always closes it.\n    if (end === -1) {\n      throw new XmlParseError({ message: `Unterminated value for attribute \"${name}\"`, position: at, input: text });\n    }\n\n    const raw = text.slice(at, end);\n    at = end + 1;\n\n    return decodeEntities(raw);\n  };\n\n  const readStartTag = (): StartTag => {\n    // Built as the record the element will end up holding rather than as a\n    // separate set of attributes, so that folding the text and the children into\n    // it later costs no copy. One object per element instead of two.\n    const record: Record<string, XmlValue> = {};\n    let hasAttributes = false;\n    for (;;) {\n      skipSpaces();\n      if (at >= text.length) throw new XmlParseError({ message: 'Unterminated start tag', position: at, input: text });\n      if (text.charCodeAt(at) === GT) {\n        at++;\n        return { record, selfClosing: false, hasAttributes };\n      }\n      if (text.charCodeAt(at) === SLASH && text[at + 1] === '>') {\n        at += 2;\n        return { record, selfClosing: true, hasAttributes };\n      }\n      const nameStart = at;\n      const name = resolve(readName('attribute name'), 'Attribute', nameStart);\n      skipSpaces();\n      if (text.charCodeAt(at) !== EQUALS) throw new XmlParseError({ message: `Attribute \"${name}\" has no \"=\"`, position: at, input: text });\n      at++;\n      skipSpaces();\n      record[ATTRIBUTE_PREFIX + name] = readAttributeValue(name, nameStart);\n      hasAttributes = true;\n    }\n  };\n\n  const readElement = (depth: number): Element => {\n    if (depth > resolved.maxDepth)\n      throw new XmlParseError({ message: `Element nesting exceeded maxDepth (${resolved.maxDepth})`, position: at, input: text });\n    if (text.charCodeAt(at) !== LT) throw new XmlParseError({ message: 'Expected an element', position: at, input: text });\n    at++;\n\n    const name = resolve(readName('element name'), 'Element', at);\n    const { record, selfClosing, hasAttributes } = readStartTag();\n\n    if (selfClosing) return { name, value: finishElement(record, hasAttributes, '', false) };\n\n    // The parser folds character data and child elements into the record the\n    // start tag produced, as it goes rather than in passes, because the order\n    // they appear in is the only order available: attributes always come first on\n    // the tag, but text and children interleave freely.\n    const content = readContent(name, record, depth);\n\n    return { name, value: finishElement(record, hasAttributes, content.text, content.hasChildren) };\n  };\n\n  /**\n   * @description Reads an element's body up to and including its closing tag, folding what it finds into the record the start tag produced. Returns when the\n   * closing tag has been consumed; failing on it is {@link readClosingTag}'s job, so that a mismatched or unclosed tag is reported the same way\n   * wherever it was found.\n   *\n   * @param name - The name the start tag gave the element, which its closing tag has to match.\n   * @param record - The record to fold the children into.\n   * @param depth - The depth the element sits at; its children are one deeper.\n   *\n   * @returns The body as character data, and whether it held any child element.\n   */\n  const readContent = (name: string, record: Record<string, XmlValue>, depth: number): Content => {\n    let childText = '';\n    let hasChildren = false;\n\n    for (;;) {\n      switch (classifyContent(name)) {\n        case 'text':\n          childText += readTextRun();\n          break;\n        case 'close':\n          readClosingTag(name);\n          return { text: childText, hasChildren };\n        case 'comment':\n          at = skipUntil('-->', at + 4, 'comment');\n          break;\n        case 'cdata':\n          childText += readCdata();\n          break;\n        case 'instruction':\n          at = skipUntil('?>', at + 2, 'processing instruction');\n          break;\n        case 'child': {\n          hasChildren = true;\n          addChild(record, readElement(depth + 1));\n          break;\n        }\n      }\n    }\n  };\n\n  /**\n   * @description What the cursor is sitting on inside an element's body. The two things the loop cannot read are refused here rather than in it: running out of\n   * document and a declaration, which is markup the parser does not accept inside an element. Recognising the constructs that _are_ read is the rest,\n   * and the order is the one that rules out the shorter prefixes first — `</` before `<?` before any other `<!`, and `<![CDATA[` before the `<!` that\n   * would otherwise match it.\n   *\n   * @param name - The name the enclosing element's start tag gave it, for the unterminated-body message.\n   *\n   * @returns What the cursor is on.\n   */\n  const classifyContent = (name: string): Construct => {\n    if (at >= text.length) {\n      throw new XmlParseError({ message: `Unclosed element <${name}>`, position: at, input: text });\n    }\n    if (text.charCodeAt(at) !== LT) {\n      return 'text';\n    }\n    if (text.startsWith('</', at)) {\n      return 'close';\n    }\n    if (text.startsWith('<!--', at)) {\n      return 'comment';\n    }\n    if (text.startsWith('<![CDATA[', at)) {\n      return 'cdata';\n    }\n    if (text.startsWith('<?', at)) {\n      return 'instruction';\n    }\n    if (text.startsWith('<!', at)) {\n      throw new XmlParseError({ message: 'A declaration is not allowed inside an element', position: at, input: text });\n    }\n    return 'child';\n  };\n\n  /**\n   * @description Consumes a `</name>`, checking on the way that it is the tag that closes this element and that it is well-formed.\n   *\n   * @param name - The name the start tag gave the element, which the closing tag has to match.\n   */\n  const readClosingTag = (name: string): void => {\n    const closeStart = at;\n    at += 2;\n    const closing = readName('element name');\n    if (closing !== name) {\n      throw new XmlParseError({ message: `Closing tag </${closing}> does not match <${name}>`, position: closeStart, input: text });\n    }\n    skipSpaces();\n    if (text.charCodeAt(at) !== GT) {\n      throw new XmlParseError({ message: `Malformed closing tag </${closing}>`, position: at, input: text });\n    }\n    at++;\n  };\n\n  /**\n   * @description Reads the run of character data up to the next `<`, or to the end of the document.\n   *\n   * @returns The run, with its character references expanded.\n   */\n  const readTextRun = (): string => {\n    const next = text.indexOf('<', at);\n    const end = next === -1 ? text.length : next;\n    const run = decodeEntities(text.slice(at, end));\n    at = end;\n    return run;\n  };\n\n  /**\n   * @description Reads a `<![CDATA[…]]>` section. CDATA is character data, and character data is what it holds, so it joins the element's text as it stands — the\n   * entities in it are literal text and must not be expanded.\n   *\n   * @returns The section's contents.\n   */\n  const readCdata = (): string => {\n    const end = text.indexOf(']]>', at + 9);\n    if (end === -1) throw new XmlParseError({ message: 'Unterminated CDATA section', position: at, input: text });\n    const data = text.slice(at + 9, end);\n    at = end + 3;\n    return data;\n  };\n\n  /**\n   * @description Adds a child to its parent's record. Two children under one name make an array, and the first one does not: a schema can tell a repeated field\n   * from a single one by the shape, and an array of one is not what a single value encodes to.\n   *\n   * @param record - The parent's record, added to in place.\n   * @param child - The child element as it was read.\n   */\n  const addChild = (record: Record<string, XmlValue>, child: Element): void => {\n    const existing = record[child.name];\n    if (existing === undefined) record[child.name] = child.value;\n    else if (Array.isArray(existing)) (existing as Array<XmlValue>).push(child.value);\n    else record[child.name] = [existing, child.value];\n  };\n\n  /**\n   * @description Decides what an element with the given attributes, text and children reduces to.\n   */\n  const finishElement = (record: Record<string, XmlValue>, hasAttributes: boolean, text: string, hasChildren: boolean): XmlValue => {\n    // Whitespace at the edges of a text run is dropped unless the caller asked to\n    // keep it. This is what makes a pretty-printed document round trip: the\n    // indentation a renderer puts around a child element and around a closing tag\n    // lands at the edges of its parent's text, and trimming removes exactly that\n    // and nothing else. Whitespace *inside* the run — between two words, or a\n    // newline in the middle of a paragraph — is content and stays.\n    const content = resolved.preserveWhitespace ? text : text.trim();\n\n    if (!hasAttributes && !hasChildren) {\n      // A leaf is character data on its own. Returning the string rather than a `{ '#text': … }` record is what lets\n      // `Schema.Struct({ name: Schema.String })` round-trip.\n      return content;\n    }\n\n    // Folded in place: the record is the one the start tag built and that the children were added to, so there is\n    // nothing left to copy.\n    if (content !== '') record[TEXT_KEY] = content;\n    return record;\n  };\n\n  skipMisc();\n  if (at >= text.length || text.charCodeAt(at) !== LT) {\n    throw new XmlParseError({ message: 'Document has no root element', position: at, input: text });\n  }\n\n  const root = readElement(0);\n\n  skipMisc();\n  if (at < text.length) {\n    throw new XmlParseError({ message: 'Unexpected content after the root element', position: at, input: text });\n  }\n\n  return { name: root.name, value: root.value };\n};\n\n/**\n * @description Runs the synchronous walk and folds the one failure it reports into a {@link Result}, which {@link parseXml} turns back into an `Effect`. Kept\n * separate so the walk itself can throw without the public API ever throwing.\n *\n * @param text - The document to read.\n * @param options - The options as the caller wrote them.\n *\n * @returns The document, or the failure to report.\n */\nconst parseDocumentResult = (text: string, options: XmlParseOptions): Result.Result<XmlDocument, XmlParseError> => {\n  try {\n    return Result.succeed(parseDocument(text, options));\n  } catch (cause) {\n    if (cause instanceof XmlParseError) {\n      return Result.fail(cause);\n    }\n    return Result.fail(new XmlParseError({ message: Predicate.isError(cause) ? cause.message : String(cause), position: -1, input: text }));\n  }\n};\n\n/**\n * @description Decodes character references, falling back to the raw text when the reference is not one the decoder recognises. The fallback is what makes a bare\n * `&` survivable: the decoder treats it as a malformed reference and fails, and a document containing one is far more likely to be worth reading than\n * to be rejected. The `&` is escaped on the way out, so the value still round-trips. The decoder answers with an `Effect`, and this is the one place\n * a parse still runs one. It is only reached when the raw text holds an `&` — the common case returns before it — and the effect is synchronous, so\n * the run is cheap next to the decoder's own work.\n *\n * @param raw - Text read straight from the source, with references unexpanded.\n *\n * @returns The decoded text, which cannot fail.\n */\nconst decodeEntities = (raw: string): string => {\n  if (raw.indexOf('&') === -1) return raw; // nothing to expand: the common case, and no work\n  // `orElseSucceed` rather than `try`/`catch`: the decoder reports a malformed\n  // reference by failing in its error channel, and a document containing a bare\n  // `&` is far more likely to be worth reading than to be rejected. The `&` is\n  // escaped on the way out, so the value still round-trips.\n  return Effect.runSync(Effect.orElseSucceed(decoder.decode(raw), () => raw));\n};\n"],"mappings":"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"}