@thomasfosterau/effect-rdf 0.0.0-stage → 0.1.0

package/dist/Xml-B7iihYCS.mjs

@@ -0,0 +1,976 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import * as Arr from "effect/Array";
+import { constFalse } from "effect/Function";
+import * as HashMap from "effect/HashMap";
+import * as HashSet from "effect/HashSet";
+import * as Iterable from "effect/Iterable";
+import * as MutableHashMap from "effect/MutableHashMap";
+import * as MutableHashSet from "effect/MutableHashSet";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+import * as Schema from "effect/Schema";
+import * as Effect from "effect/Effect";
+import * as Match from "effect/Match";
+import * as Order from "effect/Order";
+import * as Result from "effect/Result";
+import * as Compiler from "@thomasfosterau/effect-parse/Compiler";
+import * as Parser from "@thomasfosterau/effect-parse/Parser";
+import * as Token from "@thomasfosterau/effect-parse/Token";
+// src/rdfxml/internal/chars.ts
+/**
+* XML 1.0 character classes, as regular expressions (for the predicates) and
+* as `@thomasfosterau/effect-parse` token sets (for the grammar).
+*
+* @internal
+*/
+/** @internal */
+const NAME_START$1 = "A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\u{10000}-\\u{EFFFF}";
+/** @internal */
+const NAME_CHAR$1 = `${NAME_START$1}\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040`;
+const NAME_RE = new RegExp(`^[:${NAME_START$1}][:${NAME_CHAR$1}]*$`, "u");
+const NCNAME_RE = new RegExp(`^[${NAME_START$1}][${NAME_CHAR$1}]*$`, "u");
+/** @internal */
+const NMTOKEN_RE = new RegExp(`^[:${NAME_CHAR$1}]+$`, "u");
+/** @internal */
+const INVALID_CHAR_RE = /* @__PURE__ */ new RegExp("[^\\t\\n\\r\\u0020-\\uD7FF\\uE000-\\uFFFD\\u{10000}-\\u{10FFFF}]", "u");
+/** @internal */
+const PUBID_RE = /^[ \r\na-zA-Z0-9\-'()+,./:=?;!*#@$_%]*$/;
+/** @internal */
+const isNCName$1 = (value) => NCNAME_RE.test(value);
+/** @internal */
+const isName$1 = (value) => NAME_RE.test(value);
+/** @internal */
+const isValidText$1 = (value) => !INVALID_CHAR_RE.test(value);
+/** `NameStartChar` (with `:`). */
+const nameStart = [[
+	Token.range("A", "Z"),
+	"_",
+	Token.range("a", "z"),
+	Token.range("À", "Ö"),
+	Token.range("Ø", "ö"),
+	Token.range("ø", "˿"),
+	Token.range("Ͱ", "ͽ"),
+	Token.range("Ϳ", "῿"),
+	Token.range("‌", "‍"),
+	Token.range("⁰", "↏"),
+	Token.range("Ⰰ", "⿯"),
+	Token.range("、", "퟿"),
+	Token.range("豈", "﷏"),
+	Token.range("ﷰ", "�"),
+	Token.range("𐀀", "󯿿")
+], ":"];
+/** `NameChar` (with `:`). */
+const nameChar = [
+	nameStart,
+	"-.",
+	Token.range("0", "9"),
+	"·",
+	Token.range("̀", "ͯ"),
+	Token.range("‿", "⁀")
+];
+/** `S` */
+const space = " 	\n\r";
+// src/rdfxml/internal/loop.ts
+/**
+* A loop as a function, for the scans that step a cursor until a condition
+* holds (the line starts of a document, the canonical form of a long run of
+* nodes).
+*
+* @internal
+*/
+const BLOCK = 1024;
+/** `0 … BLOCK - 1`: the steps of one block run as an array scan, which engines optimise well. */
+const offsets = Array.from({ length: BLOCK }, (_, i) => i);
+/** The first step of each block after the first: `BLOCK, 2 * BLOCK, …`. */
+const blocks = Iterable.makeBy((b) => (b + 1) * BLOCK);
+/** Calls `step` with 0, 1, 2, … until it returns `false`. */
+const loop = (step) => {
+	if (offsets.every((i) => step(i))) Iterable.some(blocks, (base) => offsets.some((i) => !step(base + i)));
+};
+// src/rdfxml/internal/parser.ts
+/**
+* The XML 1.0 parser behind `Xml.parse`: a compiled
+* `@thomasfosterau/effect-parse` grammar over the (line-end normalised)
+* input, building the document tree as it reads.
+*
+* Element content is read by one loop over start tags, end tags, text and
+* the other markup, with the open elements on an explicit stack, so deeply
+* nested documents cannot exhaust the call stack. Errors are thrown (as a
+* `Failure` at an offset) out of the grammar.
+*
+* The parser guards against hostile documents:
+*
+* - external entities and parameter entities are never loaded;
+* - the replacement text of entity references may add up to at most
+*   `MAX_ENTITY_EXPANSION` characters (which defeats "billion laughs");
+* - entity references nest at most `MAX_ENTITY_DEPTH` deep, and elements at
+*   most `MAX_ELEMENT_DEPTH` deep;
+* - the replacement text of an entity that contains markup is parsed with
+*   the document's tables, not copies of them, so that many such entities
+*   and references cost time in proportion to the text expanded.
+*
+* @internal
+*/
+const XML_NAMESPACE$1 = "http://www.w3.org/XML/1998/namespace";
+const XMLNS_NAMESPACE$1 = "http://www.w3.org/2000/xmlns/";
+/** A well-formedness error at an offset, thrown out of the grammar. */
+var Failure = class {
+	message;
+	offset;
+	/** Where in the document the error is: set by `parseText`, from `offset`. */
+	position;
+	constructor(message, offset) {
+		this.message = message;
+		this.offset = offset;
+		this.position = {
+			offset,
+			line: 0,
+			column: 0
+		};
+	}
+};
+/** The replacement text of a predefined entity, or `''` if `entity` is not one. */
+const predefined = (entity) => entity === "lt" ? "<" : entity === "gt" ? ">" : entity === "amp" ? "&" : entity === "apos" ? "'" : entity === "quot" ? "\"" : "";
+const baseFrame = (inScope) => ({
+	qname: "",
+	position: {
+		offset: 0,
+		line: 0,
+		column: 0
+	},
+	prefix: "",
+	localName: "",
+	namespace: Option.none(),
+	attributes: [],
+	declarations: [],
+	inScope,
+	children: [],
+	text: "",
+	textStart: -1,
+	endsWithText: false,
+	floor: 0
+});
+/** Whether `offset` is on line `l` (from 0) of the text whose line starts are `starts`. */
+const onLine = (starts, l, offset) => (starts[l] ?? Infinity) <= offset && offset < (starts[l + 1] ?? Infinity);
+/** The line (from 0) of `offset` among lines `lo … hi` of the text whose line starts are `starts`. */
+const lineIndex = (starts, offset, lo, hi) => {
+	if (lo >= hi) return lo;
+	const mid = lo + hi + 1 >> 1;
+	return (starts[mid] ?? 0) <= offset ? lineIndex(starts, offset, mid, hi) : lineIndex(starts, offset, lo, mid - 1);
+};
+const keepChild = () => false;
+/** Up to how many attributes a start tag's duplicates are found by searching its list. */
+const SMALL = 16;
+/** Stands for the declarations of an `<!ATTLIST>` until one is read. */
+const NO_ATTRIBUTE_LIST = {
+	types: MutableHashMap.empty(),
+	defaults: []
+};
+/** Stands for the set of a start tag's expanded names while it has too few to need one. */
+const UNUSED = MutableHashSet.empty();
+/** The document being parsed. */
+var Context = class {
+	/** The text being parsed: the document, or an entity's replacement text. */
+	src;
+	lineStarts;
+	entities = MutableHashMap.empty();
+	externalEntities = MutableHashSet.empty();
+	/** The `<!ATTLIST>` declarations, by element name. */
+	attributeLists = MutableHashMap.empty();
+	expanded = 0;
+	hasExternalSubset = false;
+	/** Takes a finished child of the root element instead of adding it to the root (`true`). */
+	onRootChild = keepChild;
+	/** The frames of the open elements; those below `base` belong to enclosing text. */
+	stack;
+	base = 1;
+	/** The entities whose replacement text is being parsed. */
+	entityStack = HashSet.empty();
+	version = Option.none();
+	encoding = Option.none();
+	standalone = Option.none();
+	doctype = Option.none();
+	prolog = [];
+	epilog = [];
+	root = Option.none();
+	tagStart = 0;
+	qname = "";
+	raw = [];
+	/** The qualified names read so far, split (`nameParts`). */
+	qnames = MutableHashMap.empty();
+	/** The names in `namesOf`, once it is too long to search. */
+	names = MutableHashSet.empty();
+	/** The attributes whose names `names` holds (cleared and refilled for each long start tag). */
+	namesOf = [];
+	/** The declarations of the `<!ATTLIST>` being read (set as each is begun). */
+	attributeList = NO_ATTRIBUTE_LIST;
+	attributeName = "";
+	attributeType = "";
+	tokenized = false;
+	constructor(src, lineStarts) {
+		this.src = src;
+		this.lineStarts = lineStarts;
+		this.stack = [baseFrame(/* @__PURE__ */ new Map())];
+	}
+	/** The line of the last position, where the next one usually is (offsets mostly increase). */
+	line = 0;
+	position(offset) {
+		const starts = this.lineStarts;
+		const line = this.line;
+		const lo = onLine(starts, line, offset) ? line : onLine(starts, line + 1, offset) ? line + 1 : line > 0 && onLine(starts, line - 1, offset) ? line - 1 : lineIndex(starts, offset, 0, starts.length - 1);
+		this.line = lo;
+		return {
+			offset,
+			line: lo + 1,
+			column: offset - (starts[lo] ?? 0) + 1
+		};
+	}
+	/** Whether the start tag being read has an attribute `name` (adding it if not). */
+	hasAttribute(attribute) {
+		if (this.raw.length < SMALL) return this.raw.some((a) => a.name === attribute);
+		const names = this.names;
+		if (this.namesOf !== this.raw) {
+			MutableHashSet.clear(names);
+			this.raw.forEach((a) => MutableHashSet.add(names, a.name));
+			this.namesOf = this.raw;
+		}
+		if (MutableHashSet.has(names, attribute)) return true;
+		MutableHashSet.add(names, attribute);
+		return false;
+	}
+	top() {
+		return Arr.lastNonEmpty(this.stack);
+	}
+};
+let x = new Context("", [0]);
+const fail = (message, offset) => {
+	throw new Failure(message, offset);
+};
+const lit = Token.literal;
+/** Runs `f` at the current offset, consuming nothing. */
+const act = (f) => Parser.tap(Parser.location, f);
+/** Throws `message` at the current offset. */
+const failHere = (message) => Parser.map(Parser.location, (pos) => fail(message, pos));
+const at = (s) => Parser.peek(lit(s));
+const ws = Token.takeWhile(space);
+const requireWs = Parser.alt(Token.takeWhile(space, { min: 1 }), failHere("Expected white space"));
+/** Fails unless white space was just read (`ws` may have read none). */
+const afterWs = Parser.make((state) => {
+	const c = state.input.charCodeAt(state.pos - 1);
+	if (c !== 32 && c !== 9 && c !== 10 && c !== 13) fail("Expected white space", state.pos);
+});
+const expect = (s) => Parser.alt(lit(s), failHere(`Expected "${s}"`));
+const xmlName = Parser.alt(Parser.taken(Parser.seq(Token.oneOf(nameStart), Token.takeWhile(nameChar))), failHere("Expected a name"));
+const eq = Parser.seq(ws, expect("="), ws);
+/** A quoted string, without its quotes. */
+const quoted = Parser.alt(Parser.preceded(Parser.peek(Token.oneOf("\"'")), Parser.alt(Parser.delimited(lit("\""), Token.takeTill("\""), lit("\"")), Parser.delimited(lit("'"), Token.takeTill("'"), lit("'")), failHere("Unterminated quoted string"))), failHere("Expected a quoted string"));
+/** `p`, then `check` with its value and the offset after it. */
+const checked = (p, check) => Parser.seq(p, Parser.location).pipe(Parser.tap(([a, pos]) => check(a, pos)), Parser.map(([a]) => a));
+const collapse = (value) => value.replace(/ +/g, " ").replace(/^ | $/g, "");
+const CHAR_REF_RE = /^#(x[0-9a-fA-F]+|[0-9]+)$/;
+const charRef = (body, offset) => {
+	const code = body.startsWith("#x") ? parseInt(body.slice(2), 16) : parseInt(body.slice(1), 10);
+	if (!(code <= 1114111)) fail("Invalid character reference", offset);
+	const ch = String.fromCodePoint(code);
+	if (!isValidText$1(ch)) fail("Character reference to an invalid character", offset);
+	return ch;
+};
+/** Expands the character references in an entity value, leaving entity references. */
+const expandCharRefs = (raw, offset) => raw.replace(/&(#x[0-9a-fA-F]+|#[0-9]+|[^;]*);|&/g, (m, body, i) => {
+	if (m.length === 1) fail("Invalid reference", offset + i);
+	if (body.startsWith("#")) return charRef(body, offset + i);
+	if (!isName$1(body)) fail("Invalid entity reference", offset + i);
+	return m;
+});
+/** The replacement text of a reference to `entity`, counted against the expansion limit. */
+const entityText = (entity, offset, stack) => {
+	if (!isName$1(entity)) fail("Invalid entity reference", offset);
+	const builtIn = predefined(entity);
+	if (builtIn !== "") return builtIn === "<" ? "&#60;" : builtIn === "&" ? "&#38;" : builtIn;
+	if (MutableHashSet.has(x.externalEntities, entity)) fail(`External entity "${entity}" is not supported`, offset);
+	const value = Option.getOrElse(MutableHashMap.get(x.entities, entity), () => fail(`Undefined entity "${entity}"`, offset));
+	if (HashSet.has(stack, entity)) fail(`Recursive entity "${entity}"`, offset);
+	if (HashSet.size(stack) >= 64) fail("Entity references are nested too deeply", offset);
+	x.expanded += value.length;
+	if (x.expanded > 1e6) fail("Entity expansion limit exceeded", offset);
+	return value;
+};
+/**
+* What attribute-value normalisation replaces: a reference (to the first `;`
+* after its `&`), an `&` with no `;` after it, `<`, and white space other
+* than a space. The matches are found before any is replaced, so the nested
+* normalisation of an entity's replacement text may reuse it.
+*/
+const ATTRIBUTE_SPECIAL_RE = /&([^;]*);|[&<\t\n\r]/g;
+const ATTRIBUTE_SPECIAL_TEST_RE = /[&<\t\n\r]/;
+/** Normalises an attribute value (XML 1.0 §3.3.3). */
+const normalizeAttribute = (raw, offset, stack) => !ATTRIBUTE_SPECIAL_TEST_RE.test(raw) ? raw : raw.replace(ATTRIBUTE_SPECIAL_RE, (m, body, i) => {
+	if (m === "<") return fail("\"<\" is not allowed in attribute values", offset + i);
+	if (m === "&") return fail("Unterminated reference", offset + i);
+	if (m.length === 1) return " ";
+	if (body.startsWith("#")) {
+		if (!CHAR_REF_RE.test(body)) fail("Invalid character reference", offset + i);
+		return charRef(body, offset + i);
+	}
+	const replacement = entityText(body, offset + i, stack);
+	return normalizeAttribute(replacement, offset + i, HashSet.add(stack, body));
+});
+/** An attribute value literal, normalised. */
+const attributeValue = Parser.alt(Parser.preceded(Parser.peek(Token.oneOf("\"'")), Parser.alt(Parser.seq(Parser.location, Parser.delimited(lit("\""), Token.takeTill("\""), lit("\""))), Parser.seq(Parser.location, Parser.delimited(lit("'"), Token.takeTill("'"), lit("'"))), failHere("Unterminated attribute value"))), failHere("Expected a quoted attribute value")).pipe(Parser.map(([quote, raw]) => normalizeAttribute(raw, quote + 1, HashSet.empty())));
+const comment = Parser.terminated(Parser.seq(Parser.location, Parser.preceded(lit("<!--"), Parser.opt(Token.takeUntil("--"))), Parser.location).pipe(Parser.map(([start, body, end]) => {
+	const value = Option.getOrElse(body, () => fail("Unterminated comment", start));
+	if (x.src.charCodeAt(end + 2) !== 62) fail("\"--\" is not allowed in comments", end);
+	return {
+		_tag: "Comment",
+		value,
+		position: x.position(start)
+	};
+})), lit("-->"));
+const pi = Parser.terminated(Parser.seq(Parser.location, Parser.preceded(lit("<?"), checked(xmlName, (target, pos) => {
+	if (target.toLowerCase() === "xml") fail("Reserved processing instruction target", pos - target.length - 2);
+	if (target.includes(":")) fail("Processing instruction targets cannot contain \":\"", pos);
+})), Parser.alt(Parser.preceded(at("?>"), Parser.succeed(Option.some(""))), Parser.preceded(requireWs, Parser.opt(Token.takeUntil("?>"))))).pipe(Parser.map(([start, target, data]) => ({
+	_tag: "ProcessingInstruction",
+	target,
+	data: Option.getOrElse(data, () => fail("Unterminated processing instruction", start)),
+	position: x.position(start)
+}))), lit("?>"));
+/** `ExternalID`: `[publicId, systemId]`. */
+const externalId = Parser.alt(Parser.preceded(Parser.seq(lit("SYSTEM"), requireWs), quoted).pipe(Parser.map((system) => [Option.none(), Option.some(system)])), Parser.preceded(Parser.seq(expect("PUBLIC"), requireWs), Parser.seq(checked(quoted, (pub, pos) => {
+	if (!PUBID_RE.test(pub)) fail("Invalid public identifier", pos);
+}), Parser.preceded(Parser.seq(ws, afterWs), quoted)).pipe(Parser.map(([pub, system]) => [Option.some(pub), Option.some(system)]))));
+const skipParens = Parser.preceded(expect("("), Parser.seq(Parser.location, Token.takeTill(")"), Parser.opt(lit(")"))).pipe(Parser.tap(([pos, tokens, close]) => {
+	if (Option.isNone(close)) fail("Unterminated enumeration", pos);
+	if (tokens.split("|").some((t) => !NMTOKEN_RE.test(t.trim()))) fail("Invalid enumeration", pos);
+})));
+const TOKENIZED_TYPES = HashSet.make("ID", "IDREF", "IDREFS", "ENTITY", "ENTITIES", "NMTOKEN", "NMTOKENS");
+const defaultDecl = Parser.alt(Parser.preceded(lit("#REQUIRED"), Parser.succeed(Option.none())), Parser.preceded(lit("#IMPLIED"), Parser.succeed(Option.none())), Parser.preceded(Parser.opt(Parser.seq(lit("#FIXED"), requireWs)), Parser.map(attributeValue, Option.some)));
+const notation = Parser.make((state) => x.attributeType === "NOTATION" ? void 0 : state.backtrack("Verify", ["NOTATION"]));
+const attributeDef = Parser.seq(Parser.tap(xmlName, (n) => {
+	x.attributeName = n;
+	x.tokenized = true;
+}), requireWs, Parser.alt(Parser.preceded(at("("), skipParens), Parser.seq(checked(xmlName, (type, pos) => {
+	x.attributeType = type;
+	if (type === "CDATA") x.tokenized = false;
+	else if (type !== "NOTATION" && !HashSet.has(TOKENIZED_TYPES, type)) fail(`Unknown attribute type "${type}"`, pos);
+}), Parser.opt(Parser.preceded(notation, Parser.seq(requireWs, skipParens))))), requireWs, defaultDecl).pipe(Parser.tap(([, , , , defaultValue]) => {
+	const { types, defaults } = x.attributeList;
+	const attribute = x.attributeName;
+	if (MutableHashMap.has(types, attribute)) return;
+	const tokenized = x.tokenized;
+	MutableHashMap.set(types, attribute, tokenized);
+	if (Option.isSome(defaultValue)) {
+		const value = defaultValue.value;
+		defaults.push({
+			name: attribute,
+			value: tokenized ? collapse(value) : value,
+			tokenized
+		});
+	}
+}));
+const attlistDecl = Parser.preceded(Parser.seq(lit("<!ATTLIST"), requireWs), Parser.seq(Parser.tap(xmlName, (element) => {
+	const known = MutableHashMap.get(x.attributeLists, element);
+	if (Option.isSome(known)) x.attributeList = known.value;
+	else {
+		const list = {
+			types: MutableHashMap.empty(),
+			defaults: []
+		};
+		MutableHashMap.set(x.attributeLists, element, list);
+		x.attributeList = list;
+	}
+}), Parser.repeat(Parser.preceded(Parser.seq(ws, Parser.not(lit(">")), afterWs), attributeDef)), ws, lit(">")));
+const entityDecl = Parser.preceded(Parser.seq(lit("<!ENTITY"), requireWs), Parser.seq(Parser.alt(Parser.preceded(Parser.seq(lit("%"), requireWs), Parser.succeed(true)), Parser.succeed(false)), checked(xmlName, (n, pos) => {
+	if (n.includes(":")) fail("Entity names cannot contain \":\"", pos);
+}), requireWs, Parser.alt(Parser.preceded(Parser.peek(Token.oneOf("\"'")), Parser.seq(Parser.location, quoted).pipe(Parser.map(([quote, raw]) => {
+	if (raw.includes("%")) fail("Parameter entity references are not supported", quote + 1);
+	return Option.some(expandCharRefs(raw, quote + 1));
+}))), Parser.preceded(externalId, Parser.opt(Parser.preceded(Parser.seq(Token.takeWhile(space, { min: 1 }), lit("NDATA")), Parser.seq(requireWs, xmlName)))).pipe(Parser.as(Option.none()))), ws, expect(">"))).pipe(Parser.tap(([parameter, entity, , value]) => {
+	if (parameter) return;
+	if (MutableHashMap.has(x.entities, entity) || MutableHashSet.has(x.externalEntities, entity)) return;
+	if (Option.isSome(value)) MutableHashMap.set(x.entities, entity, value.value);
+	else MutableHashSet.add(x.externalEntities, entity);
+}));
+/** `<!ELEMENT …>` and `<!NOTATION …>`, skipped. */
+const skippedDecl = Parser.seq(Parser.repeat(Parser.alt(Parser.preceded(Parser.peek(Token.oneOf("\"'")), quoted), Token.takeTill(">\"'", { min: 1 }))), Parser.alt(lit(">"), failHere("Unterminated markup declaration")));
+const internalSubset = Parser.terminated(Parser.repeat(Parser.preceded(Parser.seq(ws, Parser.not(lit("]"))), Parser.alt(Parser.preceded(Parser.eof, failHere("Unterminated internal subset")), Parser.preceded(at("<!ENTITY"), entityDecl), Parser.preceded(at("<!ATTLIST"), attlistDecl), Parser.preceded(Parser.alt(at("<!ELEMENT"), at("<!NOTATION")), skippedDecl), Parser.preceded(at("<!--"), comment), Parser.preceded(at("<?"), pi), Parser.preceded(at("%"), failHere("Parameter entity references are not supported")), failHere("Invalid markup in the internal subset")))), Parser.seq(ws, lit("]")));
+const doctype = Parser.seq(Parser.preceded(Parser.seq(lit("<!DOCTYPE"), requireWs), xmlName), Parser.alt(Parser.preceded(Parser.seq(ws, Parser.peek(Parser.alt(lit("SYSTEM"), lit("PUBLIC"))), afterWs), Parser.terminated(externalId, ws)).pipe(Parser.tap(() => {
+	x.hasExternalSubset = true;
+})), Parser.preceded(ws, Parser.succeed([Option.none(), Option.none()]))), Parser.opt(Parser.preceded(lit("["), Parser.terminated(internalSubset, ws))), expect(">")).pipe(Parser.tap(([doctypeName, [publicId, systemId]]) => {
+	x.doctype = Option.some({
+		name: doctypeName,
+		publicId: Option.getOrUndefined(publicId),
+		systemId: Option.getOrUndefined(systemId),
+		entities: new Map(x.entities)
+	});
+}));
+const pushText = (frame, s, offset) => {
+	if (s === "") return;
+	if (frame.textStart === -1) frame.textStart = offset;
+	frame.text += s;
+};
+const isText = Predicate.isTagged("Text");
+const flush = (frame) => {
+	if (frame.text !== "") {
+		const children = frame.children;
+		const prev = frame.endsWithText && children.length > frame.floor ? children.at(-1) : void 0;
+		if (isText(prev)) children[children.length - 1] = {
+			...prev,
+			value: prev.value + frame.text
+		};
+		else {
+			children.push({
+				_tag: "Text",
+				value: frame.text,
+				position: x.position(frame.textStart)
+			});
+			frame.endsWithText = true;
+		}
+	}
+	frame.text = "";
+	frame.textStart = -1;
+};
+/** Adds a child that is not text to `frame`, after its text. */
+const pushChild = (frame, node) => {
+	flush(frame);
+	frame.children.push(node);
+	frame.endsWithText = false;
+};
+/** A child that is not text. */
+const pushNode = (node) => {
+	pushChild(x.top(), node);
+};
+/**
+* The prefix (`''` if none) and local part of a valid qualified name. The
+* names of a document repeat, so each is checked and split once, and its
+* parts are the same strings each time.
+*/
+const splitName = (qname, offset) => {
+	const i = qname.indexOf(":");
+	if (i === -1) {
+		if (!isNCName$1(qname)) fail(`Invalid name "${qname}"`, offset);
+		return ["", qname];
+	}
+	const prefix = qname.slice(0, i);
+	const local = qname.slice(i + 1);
+	if (!isNCName$1(prefix) || !isNCName$1(local)) fail(`Invalid qualified name "${qname}"`, offset);
+	if (prefix === "xmlns") fail("Elements and attributes cannot use the \"xmlns\" prefix", offset);
+	return [prefix, local];
+};
+const nameParts = (qname, offset) => {
+	const known = MutableHashMap.get(x.qnames, qname);
+	if (Option.isSome(known)) return known.value;
+	const parts = splitName(qname, offset);
+	MutableHashMap.set(x.qnames, qname, parts);
+	return parts;
+};
+const XML_NAMESPACE_OPTION = Option.some(XML_NAMESPACE$1);
+/** The namespace of a name with `prefix` (an element's default namespace if `''`). */
+const namespaceOf = (prefix, ns, isElement, offset) => {
+	if (prefix === "") return isElement ? Option.fromUndefinedOr(ns.get("")) : Option.none();
+	if (prefix === "xml") return XML_NAMESPACE_OPTION;
+	const uri = ns.get(prefix);
+	if (uri === void 0) fail(`Unbound namespace prefix "${prefix}"`, offset);
+	return Option.some(uri);
+};
+/** The namespace prefix an `xmlns` / `xmlns:…` attribute declares, or none for any other attribute. */
+const declaredPrefix = (attribute) => attribute === "xmlns" ? Option.some("") : attribute.startsWith("xmlns:") ? Option.some(attribute.slice(6)) : Option.none();
+const isDeclaration = (attribute) => attribute === "xmlns" || attribute.startsWith("xmlns:");
+/** The namespaces in scope of an element that makes `declarations` (which are not empty). */
+const declare = (parentNs, declarations) => {
+	const own = new Map(parentNs);
+	declarations.forEach((d) => {
+		if (d.namespace === "") own.delete("");
+		else own.set(d.prefix, d.namespace);
+	});
+	return own;
+};
+/** Checks a namespace declaration, which declares `prefix` to be `uri`. */
+const checkDeclaration = (prefix, uri, offset) => {
+	if (prefix !== "" && !isNCName$1(prefix)) fail("Invalid namespace prefix", offset);
+	if (prefix === "xmlns") fail("The \"xmlns\" prefix cannot be declared", offset);
+	if (prefix === "xml" && uri !== XML_NAMESPACE$1) fail("The \"xml\" prefix cannot be rebound", offset);
+	if (prefix !== "xml" && uri === XML_NAMESPACE$1) fail("The XML namespace cannot be bound to another prefix", offset);
+	if (uri === XMLNS_NAMESPACE$1) fail("The xmlns namespace cannot be declared", offset);
+	if (prefix !== "" && uri === "") fail("Prefixed namespace declarations cannot be empty", offset);
+};
+/** Opens the element whose start tag was just read (closing it too if it was empty). */
+const openElement = (empty) => {
+	const start = x.tagStart;
+	const qname = x.qname;
+	const raw = x.raw;
+	if (!MutableHashMap.isEmpty(x.attributeLists)) {
+		const list = MutableHashMap.get(x.attributeLists, qname);
+		if (Option.isSome(list)) {
+			const { types, defaults } = list.value;
+			raw.forEach((a) => {
+				if (Option.getOrElse(MutableHashMap.get(types, a.name), constFalse)) a.value = collapse(a.value);
+			});
+			defaults.forEach((d) => {
+				if (!x.hasAttribute(d.name)) raw.push({
+					name: d.name,
+					value: d.value,
+					offset: start,
+					defaulted: true
+				});
+			});
+		}
+	}
+	const parent = x.top();
+	const parentNs = parent.inScope;
+	const declarations = [];
+	raw.forEach((a) => {
+		const declared = declaredPrefix(a.name);
+		if (Option.isNone(declared)) return;
+		const prefix = declared.value;
+		checkDeclaration(prefix, a.value, a.offset);
+		if (prefix !== "xml") declarations.push({
+			prefix,
+			namespace: a.value
+		});
+	});
+	const inScope = Arr.isArrayNonEmpty(declarations) ? declare(parentNs, declarations) : parentNs;
+	const [prefix, localName] = nameParts(qname, start + 1);
+	const namespace = namespaceOf(prefix, inScope, true, start + 1);
+	const attributes = [];
+	const large = raw.length >= SMALL;
+	const expanded = large ? MutableHashSet.empty() : UNUSED;
+	raw.forEach((a) => {
+		if (isDeclaration(a.name)) return;
+		const [ap, al] = nameParts(a.name, a.offset);
+		const ans = Option.getOrUndefined(namespaceOf(ap, inScope, false, a.offset));
+		const key = `${ans ?? ""} ${al}`;
+		if (large ? MutableHashSet.has(expanded, key) : attributes.some((b) => b.localName === al && b.namespace === ans)) fail(`Duplicate attribute "{${ans ?? ""}}${al}"`, a.offset);
+		if (large) MutableHashSet.add(expanded, key);
+		attributes.push({
+			_tag: "Attribute",
+			name: a.name,
+			prefix: ap,
+			localName: al,
+			namespace: ans,
+			value: a.value,
+			defaulted: a.defaulted,
+			position: x.position(a.offset)
+		});
+	});
+	flush(parent);
+	const frame = {
+		qname,
+		position: x.position(start),
+		prefix,
+		localName,
+		namespace,
+		attributes,
+		declarations,
+		inScope,
+		children: [],
+		text: "",
+		textStart: -1,
+		endsWithText: false,
+		floor: 0
+	};
+	if (empty) {
+		closeElement(frame);
+		return;
+	}
+	if (x.stack.length - x.base >= 1024) fail("Elements are nested too deeply", start);
+	x.stack.push(frame);
+};
+/** The element an open frame stands for (with the children it has so far). */
+const elementOf = (frame) => ({
+	_tag: "Element",
+	name: frame.qname,
+	prefix: frame.prefix,
+	localName: frame.localName,
+	namespace: Option.getOrUndefined(frame.namespace),
+	attributes: frame.attributes,
+	namespaceDeclarations: frame.declarations,
+	inScopeNamespaces: frame.inScope,
+	children: frame.children,
+	position: frame.position
+});
+/** Adds a finished element to its parent. */
+const closeElement = (frame) => {
+	flush(frame);
+	const element = elementOf(frame);
+	const inDocument = HashSet.isEmpty(x.entityStack);
+	if (x.stack.length === 1 && inDocument) {
+		x.root = Option.some(element);
+		return;
+	}
+	if (x.stack.length === 2 && inDocument && x.onRootChild(element, elementOf(x.top()))) {
+		const root = x.top();
+		root.floor = root.children.length;
+		return;
+	}
+	pushChild(x.top(), element);
+};
+const attribute = Parser.seq(Parser.location, xmlName, eq, attributeValue).pipe(Parser.tap(([offset, attributeName, , value]) => {
+	if (x.hasAttribute(attributeName)) fail(`Duplicate attribute "${attributeName}"`, offset);
+	x.raw.push({
+		name: attributeName,
+		value,
+		offset,
+		defaulted: false
+	});
+}));
+const startTag = Parser.seq(Parser.tap(Parser.seq(Parser.location, Parser.preceded(lit("<"), xmlName)), ([start, qname]) => {
+	x.tagStart = start;
+	x.qname = qname;
+	x.raw = [];
+}), Parser.repeat(Parser.preceded(Parser.seq(ws, Parser.not(Parser.alt(lit(">"), lit("/>")))), Parser.preceded(Parser.make((state) => {
+	const c = state.input.charCodeAt(state.pos - 1);
+	if (c !== 32 && c !== 9 && c !== 10 && c !== 13) fail("Expected white space between attributes", state.pos);
+}), attribute))), Parser.preceded(ws, Parser.alt(Parser.tap(lit("/>"), () => openElement(true)), Parser.tap(lit(">"), () => openElement(false)))));
+const endTag = Parser.seq(Parser.seq(act((offset) => {
+	if (x.stack.length === x.base) fail("Unbalanced end tag in entity replacement text", offset);
+}), Parser.preceded(lit("</"), xmlName)).pipe(Parser.tap(([offset, endName]) => {
+	const frame = x.top();
+	if (endName !== frame.qname) fail(`Mismatched end tag: expected </${frame.qname}> but found </${endName}>`, offset);
+})), ws, expect(">")).pipe(Parser.tap(() => {
+	const frame = x.top();
+	x.stack.pop();
+	closeElement(frame);
+}));
+const cdata = Parser.seq(Parser.location, Parser.preceded(lit("<![CDATA["), Parser.opt(Parser.terminated(Token.takeUntil("]]>"), lit("]]>"))))).pipe(Parser.tap(([start, text]) => {
+	pushText(x.top(), Option.getOrElse(text, () => fail("Unterminated CDATA section", start)), start);
+}));
+const charData = Parser.seq(Parser.location, Token.takeTill("<&", { min: 1 })).pipe(Parser.tap(([start, text]) => {
+	const bad = text.indexOf("]]>");
+	if (bad !== -1) fail("\"]]>\" is not allowed in character data", start + bad);
+	pushText(x.top(), text, start);
+}));
+/** The content an entity's replacement text adds (parsed interpreted: it may nest). */
+const entityContent = Parser.suspend(() => Parser.terminated(Parser.repeat(Parser.preceded(Parser.not(Parser.eof), contentItem)), act((pos) => {
+	if (x.stack.length > x.base) fail("Unexpected end of input: unclosed element", pos);
+})));
+/** Parses the replacement text of an entity that contains markup. */
+const replacementNodes = (body, replacement, start) => {
+	const { src, lineStarts, stack, base, entityStack } = x;
+	const frame = baseFrame(x.top().inScope);
+	x.src = replacement;
+	x.lineStarts = [0];
+	x.stack = [frame];
+	x.base = 1;
+	x.entityStack = HashSet.add(entityStack, body);
+	const outcome = Result.try({
+		try: () => {
+			const result = Parser.parse(entityContent, replacement);
+			if (Result.isFailure(result)) fail("Invalid markup", result.failure.offset);
+			flush(frame);
+			return frame.children;
+		},
+		catch: (e) => e
+	});
+	x.src = src;
+	x.lineStarts = lineStarts;
+	x.stack = stack;
+	x.base = base;
+	x.entityStack = entityStack;
+	if (Result.isSuccess(outcome)) return outcome.success;
+	if (outcome.failure instanceof Failure) fail(`In entity "${body}": ${outcome.failure.message}`, start);
+	throw outcome.failure;
+};
+const reference = Parser.seq(Parser.location, Parser.preceded(lit("&"), Token.takeTill(";")), Parser.opt(lit(";"))).pipe(Parser.tap(([start, body, semi]) => {
+	if (Option.isNone(semi)) fail("Unterminated reference", start);
+	const frame = x.top();
+	if (body.startsWith("#")) {
+		if (!CHAR_REF_RE.test(body)) fail("Invalid character reference", start);
+		pushText(frame, charRef(body, start), start);
+		return;
+	}
+	const builtIn = predefined(body);
+	if (builtIn !== "") {
+		pushText(frame, builtIn, start);
+		return;
+	}
+	const replacement = entityText(body, start, x.entityStack);
+	if (!replacement.includes("<") && !replacement.includes("&")) {
+		pushText(frame, replacement, start);
+		return;
+	}
+	flush(frame);
+	const position = x.position(start);
+	replacementNodes(body, replacement, start).forEach((n) => {
+		if (isText(n)) pushText(frame, n.value, start);
+		else pushChild(frame, {
+			...n,
+			position
+		});
+	});
+}));
+const contentItem = Parser.alt(Parser.preceded(at("</"), endTag), Parser.preceded(at("<!--"), Parser.tap(comment, pushNode)), Parser.preceded(at("<![CDATA["), cdata), Parser.preceded(at("<?"), Parser.tap(pi, pushNode)), Parser.preceded(at("<!"), failHere("Unexpected markup declaration in content")), Parser.preceded(at("<"), startTag), Parser.preceded(at("&"), reference), charData);
+/** The root element: its start tag, then content until it is closed. */
+const rootElement = Parser.asVoid(Parser.seq(startTag, Parser.repeat(Parser.preceded(Parser.make((state) => x.stack.length > x.base ? void 0 : state.backtrack("Verify", ["content"])), Parser.alt(Parser.preceded(Parser.eof, failHere("Unexpected end of input: unclosed element")), contentItem)))));
+const xmlDecl = Parser.preceded(Parser.seq(lit("<?xml"), Parser.peek(Token.oneOf(space))), Parser.seq(requireWs, expect("version"), eq, checked(quoted, (version, pos) => {
+	if (!/^1\.[0-9]+$/.test(version)) fail(`Unsupported XML version "${version}"`, pos);
+	x.version = Option.some(version);
+}), ws, Parser.opt(Parser.preceded(Parser.seq(at("encoding"), afterWs, lit("encoding"), eq), Parser.terminated(checked(quoted, (encoding, pos) => {
+	if (!/^[A-Za-z][A-Za-z0-9._-]*$/.test(encoding)) fail("Invalid encoding name", pos);
+	x.encoding = Option.some(encoding);
+}), ws))), Parser.opt(Parser.preceded(Parser.seq(at("standalone"), afterWs, lit("standalone"), eq), Parser.terminated(checked(quoted, (sd, pos) => {
+	if (sd !== "yes" && sd !== "no") fail("standalone must be \"yes\" or \"no\"", pos);
+	x.standalone = Option.some(sd === "yes");
+}), ws))), expect("?>")));
+const prologOrEpilog = (node) => {
+	(Option.isNone(x.root) ? x.prolog : x.epilog).push(node);
+};
+const document = Compiler.jit(Parser.asVoid(Parser.seq(Parser.opt(xmlDecl), Parser.repeat(Parser.preceded(Parser.not(Parser.eof), Parser.alt(Token.takeWhile(space, { min: 1 }), Parser.preceded(at("<!--"), Parser.tap(comment, prologOrEpilog)), Parser.preceded(at("<?"), Parser.tap(pi, prologOrEpilog)), Parser.preceded(at("<!DOCTYPE"), Parser.preceded(act((pos) => {
+	if (Option.isSome(x.doctype) || Option.isSome(x.root)) fail("Unexpected DOCTYPE", pos);
+}), doctype)), Parser.preceded(at("<"), Parser.preceded(act((pos) => {
+	if (Option.isSome(x.root)) fail("Only one root element is allowed", pos);
+}), rootElement)), act((pos) => fail(Option.isNone(x.root) ? "Expected the root element" : "Content after the root element", pos))))), act((pos) => {
+	if (Option.isNone(x.root)) fail("No root element", pos);
+}))));
+/** Parses a (line-end normalised) document, throwing a `Failure`. */
+const parse$1 = (text, lineStarts, onRootChild) => {
+	x = new Context(text, lineStarts);
+	x.onRootChild = onRootChild;
+	const result = Parser.parse(document, text);
+	if (Result.isFailure(result)) fail("Invalid XML", result.failure.offset);
+	return {
+		_tag: "Document",
+		version: Option.getOrUndefined(x.version),
+		encoding: Option.getOrUndefined(x.encoding),
+		standalone: Option.getOrUndefined(x.standalone),
+		doctype: Option.getOrUndefined(x.doctype),
+		prolog: x.prolog,
+		root: Option.getOrElse(x.root, () => fail("No root element", text.length)),
+		epilog: x.epilog
+	};
+};
+/** The line and column of an offset, given the offsets at which lines start. */
+const positionAt = (lineStarts, offset) => {
+	const lo = lineIndex(lineStarts, offset, 0, lineStarts.length - 1);
+	return {
+		offset,
+		line: lo + 1,
+		column: offset - (lineStarts[lo] ?? 0) + 1
+	};
+};
+const lineStartsOf = (text) => {
+	const starts = [0];
+	let i = text.indexOf("\n");
+	loop(() => {
+		if (i === -1) return false;
+		starts.push(i + 1);
+		i = text.indexOf("\n", i + 1);
+		return true;
+	});
+	return starts;
+};
+/** @internal */
+const normalizeInput$1 = (input) => {
+	const noBom = input.charCodeAt(0) === 65279 ? input.slice(1) : input;
+	return noBom.includes("\r") ? noBom.replace(/\r\n?/g, "\n") : noBom;
+};
+/**
+* Parses a document (normalising its line ends first), throwing a `Failure`
+* with its position. `onRootChild` may take the root's children as they are
+* read.
+*
+* @internal
+*/
+const parseText = (input, onRootChild = keepChild) => {
+	const text = normalizeInput$1(input);
+	const lineStarts = lineStartsOf(text);
+	const outcome = Result.try({
+		try: () => {
+			const bad = INVALID_CHAR_RE.exec(text);
+			if (bad !== null) fail("Invalid XML character", bad.index);
+			return parse$1(text, lineStarts, onRootChild);
+		},
+		catch: (e) => e
+	});
+	if (Result.isSuccess(outcome)) return outcome.success;
+	const e = outcome.failure;
+	if (e instanceof Failure) e.position = positionAt(lineStarts, Math.min(e.offset, text.length));
+	throw e;
+};
+// src/rdfxml/Xml.ts
+/**
+* A small, namespace-aware, non-validating XML 1.0 parser producing an
+* immutable document tree, plus Exclusive XML Canonicalization (with
+* comments) of element content.
+*
+* Supported: the XML declaration, a document type declaration whose internal
+* subset may declare general entities and attribute defaults, elements,
+* attributes (with attribute-value normalisation), Namespaces in XML 1.0,
+* CDATA sections, comments, processing instructions, and character and
+* entity references. External entities and parameter entities are not
+* loaded (they are reported as errors when referenced).
+*
+* The parser is a compiled `@thomasfosterau/effect-parse` grammar; it is
+* pure and synchronous internally, and the public `parse` API returns an
+* `Effect` failing with `XmlParseError`. It is safe on hostile input:
+* entity replacement text may add at most 1,000,000 characters to a
+* document, entity references nest at most 64 deep and elements at most
+* 1,024 deep, and the time it takes grows with the text it expands.
+*
+* @since 0.1.0
+*/
+var Xml_exports = /* @__PURE__ */ __exportAll({
+	NAME_CHAR: () => NAME_CHAR,
+	NAME_START: () => NAME_START,
+	XMLNS_NAMESPACE: () => XMLNS_NAMESPACE,
+	XML_NAMESPACE: () => XML_NAMESPACE,
+	XmlParseError: () => XmlParseError,
+	canonicalize: () => canonicalize,
+	escapeAttribute: () => escapeAttribute,
+	escapeText: () => escapeText,
+	isNCName: () => isNCName,
+	isName: () => isName,
+	isValidText: () => isValidText,
+	isWhitespace: () => isWhitespace,
+	normalizeInput: () => normalizeInput,
+	parse: () => parse,
+	parseResult: () => parseResult
+});
+/**
+* The XML namespace, bound to the `xml` prefix.
+*
+* @since 0.1.0
+* @category constants
+*/
+const XML_NAMESPACE = "http://www.w3.org/XML/1998/namespace";
+/**
+* The namespace of namespace declarations (`xmlns`).
+*
+* @since 0.1.0
+* @category constants
+*/
+const XMLNS_NAMESPACE = "http://www.w3.org/2000/xmlns/";
+/**
+* A well-formedness or namespace error.
+*
+* @since 0.1.0
+* @category errors
+*/
+var XmlParseError = class extends Schema.TaggedError()("XmlParseError", {
+	message: Schema.String,
+	offset: Schema.Number,
+	line: Schema.Number,
+	column: Schema.Number
+}) {};
+/**
+* The XML `NameStartChar` production as a regular expression character
+* class body (without brackets), excluding `:`. Requires the `u` flag.
+*
+* @since 0.1.0
+* @category constants
+*/
+const NAME_START = NAME_START$1;
+/**
+* The XML `NameChar` production as a regular expression character class
+* body (without brackets), excluding `:`. Requires the `u` flag.
+*
+* @since 0.1.0
+* @category constants
+*/
+const NAME_CHAR = NAME_CHAR$1;
+/**
+* Whether a string is an XML `NCName` (a name without colons), as required
+* for namespace prefixes, local names, `rdf:ID` and `rdf:nodeID`.
+*
+* @since 0.1.0
+* @category predicates
+*/
+const isNCName = isNCName$1;
+/**
+* Whether a string is an XML `Name`.
+*
+* @since 0.1.0
+* @category predicates
+*/
+const isName = isName$1;
+/**
+* Whether a string consists only of characters allowed in XML 1.0 documents.
+*
+* @since 0.1.0
+* @category predicates
+*/
+const isValidText = isValidText$1;
+const WHITESPACE = /^[ \t\r\n]*$/;
+/**
+* Whether a string consists only of XML white space (`S`).
+*
+* @since 0.1.0
+* @category predicates
+*/
+const isWhitespace = (value) => WHITESPACE.test(value);
+/**
+* Normalises line ends (`\r\n` and `\r` become `\n`) and strips a leading
+* byte order mark, as an XML processor does before parsing.
+*
+* @since 0.1.0
+* @category parsing
+*/
+const normalizeInput = normalizeInput$1;
+/**
+* Parses an XML document, returning a `Result`.
+*
+* @since 0.1.0
+* @category parsing
+*/
+const parseResult = (input) => Result.try({
+	try: () => parseText(input),
+	catch: (e) => {
+		if (e instanceof Failure) return new XmlParseError({
+			message: e.message,
+			offset: e.position.offset,
+			line: e.position.line,
+			column: e.position.column
+		});
+		throw e;
+	}
+});
+/**
+* Parses an XML document.
+*
+* @since 0.1.0
+* @category parsing
+*/
+const parse = (input) => Effect.suspend(() => Effect.fromResult(parseResult(input)));
+/**
+* Escapes character data as in Canonical XML.
+*
+* @since 0.1.0
+* @category canonicalization
+*/
+const escapeText = (value) => value.replace(/[&<>\r]/g, (c) => c === "&" ? "&amp;" : c === "<" ? "&lt;" : c === ">" ? "&gt;" : "&#xD;");
+/**
+* Escapes an attribute value as in Canonical XML.
+*
+* @since 0.1.0
+* @category canonicalization
+*/
+const escapeAttribute = (value) => value.replace(/[&<"\t\n\r]/g, (c) => c === "&" ? "&amp;" : c === "<" ? "&lt;" : c === "\"" ? "&quot;" : c === "	" ? "&#x9;" : c === "\n" ? "&#xA;" : "&#xD;");
+const compareStrings = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+/**
+* Serialises a sequence of nodes (with all their descendants, but none of
+* their ancestors) using Exclusive XML Canonicalization 1.0 with comments
+* and an empty InclusiveNamespaces PrefixList. This is how RDF/XML computes
+* the lexical form of `rdf:parseType="Literal"` content.
+*
+* @since 0.1.0
+* @category canonicalization
+*/
+const canonicalize = (nodes) => nodes.map((n) => canonicalNode(n, HashMap.empty())).join("");
+const byPrefix = Order.make((a, b) => compareStrings(a[0], b[0]));
+const byExpandedName = Order.make((a, b) => compareStrings(a.namespace ?? "", b.namespace ?? "") || compareStrings(a.localName, b.localName));
+/** The prefixes an element visibly utilises: its own, and those of its prefixed attributes. */
+const utilizedPrefixes = (node) => Arr.dedupe(Arr.filter([node.prefix, ...node.attributes.map((a) => a.prefix).filter((p) => p !== "")], (p) => p !== "xml"));
+const canonicalNode = Match.fn((node, _rendered) => node).pipe(Match.withReturnType(), Match.tag("Text", (node) => escapeText(node.value)), Match.tag("Comment", (node) => `<!--${node.value}-->`), Match.tag("ProcessingInstruction", (node) => node.data === "" ? `<?${node.target}?>` : `<?${node.target} ${node.data}?>`), Match.tag("Element", (node, _node, rendered) => {
+	const decls = Arr.sort(Arr.filterMap(utilizedPrefixes(node), (p) => {
+		const uri = node.inScopeNamespaces.get(p) ?? "";
+		return Option.getOrElse(HashMap.get(rendered, p), () => "") === uri ? Result.failVoid : Result.succeed([p, uri]);
+	}), byPrefix);
+	const next = decls.reduce((m, [p, uri]) => HashMap.set(m, p, uri), rendered);
+	const namespaces = decls.map(([p, uri]) => p === "" ? ` xmlns="${escapeAttribute(uri)}"` : ` xmlns:${p}="${escapeAttribute(uri)}"`).join("");
+	const attributes = Arr.sort(node.attributes, byExpandedName).map((a) => ` ${a.name}="${escapeAttribute(a.value)}"`).join("");
+	const children = node.children.map((c) => canonicalNode(c, next)).join("");
+	return `<${node.name}${namespaces}${attributes}>${children}</${node.name}>`;
+}), Match.exhaustive);
+export { Failure as _, XmlParseError as a, escapeAttribute as c, isName as d, isValidText as f, parseResult as g, parse as h, XML_NAMESPACE as i, escapeText as l, normalizeInput as m, NAME_START as n, Xml_exports as o, isWhitespace as p, XMLNS_NAMESPACE as r, canonicalize as s, NAME_CHAR as t, isNCName as u, parseText as v };
+
+//# sourceMappingURL=Xml-B7iihYCS.mjs.map