@thomasfosterau/effect-rdf 0.0.0-stage → 0.1.0

package/dist/RdfXml-DJ9G4gOq.mjs

@@ -0,0 +1,1014 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { B as isNamedNode, E as compare, K as isTriple, N as isBlankNode, O as defaultGraph, P as isDefaultGraph, Y as literal, c as NamedNode, d as Quad, o as Literal, t as BlankNode, u as Order$1, y as Triple } from "./Term-CFLG1qu4.mjs";
+import { m as fromIterable } from "./Dataset-BlmlcI7J.mjs";
+import { l as resolve, s as relativize } from "./Iri-Cr92gsQV.mjs";
+import { i as empty, s as make } from "./PrefixMap-BHFPDLO-.mjs";
+import { C as withParseSpan, c as makeCodec, d as makeSerializer, l as makeFormat, n as RdfParseError, o as freshBlankNodePrefix, r as RdfSerializeError, u as makeParser, w as withSerializeSpan } from "./Serialization-DP9H5bYQ.mjs";
+import { _ as Failure, c as escapeAttribute, f as isValidText, l as escapeText, n as NAME_START, p as isWhitespace, s as canonicalize, t as NAME_CHAR, u as isNCName, v as parseText } from "./Xml-B7iihYCS.mjs";
+import * as Arr from "effect/Array";
+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 Effect from "effect/Effect";
+import * as Match from "effect/Match";
+import * as Order from "effect/Order";
+import * as Result from "effect/Result";
+// src/rdfxml/RdfXml.ts
+/**
+* RDF 1.2 XML Syntax (RDF/XML): parser and serializer.
+*
+* The parser implements the RDF/XML grammar of
+* https://www.w3.org/TR/rdf-syntax-grammar/ together with the RDF 1.2
+* additions: `rdf:version`, base direction via `its:dir`, triple terms via
+* `rdf:parseType="Triple"`, and annotations via `rdf:annotation` /
+* `rdf:annotationNodeID`. `rdf:parseType="Literal"` content is turned into
+* an `rdf:XMLLiteral` using Exclusive XML Canonicalization.
+*
+* The serializer writes readable RDF/XML: typed node elements, nested blank
+* nodes where a blank node is referenced exactly once, namespace
+* declarations taken from `options.prefixes` and generated namespaces for the
+* rest.
+*
+* @since 0.1.0
+*/
+var RdfXml_exports = /* @__PURE__ */ __exportAll({
+	codec: () => codec,
+	format: () => format,
+	parse: () => parse,
+	parseDocument: () => parseDocument,
+	parseQuads: () => parseQuads,
+	parser: () => parser,
+	serialize: () => serialize,
+	serializer: () => serializer,
+	splitIri: () => splitIri
+});
+const RDF = "http://www.w3.org/1999/02/22-rdf-syntax-ns#";
+const ITS = "http://www.w3.org/2005/11/its";
+const XSD_STRING = "http://www.w3.org/2001/XMLSchema#string";
+const FORMAT_NAME = "RDF/XML";
+/**
+* The RDF/XML format description (`application/rdf+xml`).
+*
+* @since 0.1.0
+* @category formats
+*/
+const format = makeFormat({
+	name: FORMAT_NAME,
+	mediaType: "application/rdf+xml",
+	extensions: ["rdf", "owl"],
+	datasets: false
+});
+const trace = {
+	module: "RdfXml",
+	format
+};
+const rdf = (local) => RDF + local;
+/** The core syntax terms and the old terms, which are never node, property or attribute names. */
+const RESERVED_TERMS = MutableHashSet.fromIterable([
+	"RDF",
+	"ID",
+	"about",
+	"annotation",
+	"annotationNodeID",
+	"parseType",
+	"resource",
+	"nodeID",
+	"datatype",
+	"version",
+	"aboutEach",
+	"aboutEachPrefix",
+	"bagID"
+].map(rdf));
+const UNQUALIFIED_RDF_ATTRIBUTES = MutableHashSet.make("ID", "about", "resource", "parseType", "type", "version");
+const RDF_DESCRIPTION = rdf("Description");
+const RDF_LI = rdf("li");
+const RDF_TYPE = rdf("type");
+const RDF_ID = rdf("ID");
+const RDF_NODE_ID = rdf("nodeID");
+const RDF_ABOUT = rdf("about");
+const RDF_VERSION = rdf("version");
+const RDF_ANNOTATION = rdf("annotation");
+const RDF_ANNOTATION_NODE_ID = rdf("annotationNodeID");
+const RDF_PARSE_TYPE = rdf("parseType");
+const RDF_RESOURCE = rdf("resource");
+const RDF_DATATYPE = rdf("datatype");
+const isReserved = (iri) => MutableHashSet.has(RESERVED_TERMS, iri);
+const isForbiddenNodeElement = (iri) => isReserved(iri) || iri === RDF_LI;
+const isForbiddenPropertyElement = (iri) => isReserved(iri) || iri === RDF_DESCRIPTION;
+const isForbiddenPropertyAttribute = (iri) => isReserved(iri) || iri === RDF_DESCRIPTION || iri === RDF_LI;
+const isElement = Predicate.isTagged("Element");
+const isText = Predicate.isTagged("Text");
+var ParseFailure = class {
+	message;
+	position;
+	constructor(message, position) {
+		this.message = message;
+		this.position = position;
+	}
+};
+/** Resolves `reference` against the base IRI of `ctx`, if it has one. */
+const resolveIn = (reference, base) => resolve(reference, Option.getOrUndefined(base));
+const isRdf12 = (version) => Option.isSome(version) && version.value !== "1.0" && version.value !== "1.1";
+const rdfType = new NamedNode(rdf("type"));
+const rdfFirst = new NamedNode(rdf("first"));
+const rdfRest = new NamedNode(rdf("rest"));
+const rdfNil = new NamedNode(rdf("nil"));
+const rdfStatement = new NamedNode(rdf("Statement"));
+const rdfSubject = new NamedNode(rdf("subject"));
+const rdfPredicate = new NamedNode(rdf("predicate"));
+const rdfObject = new NamedNode(rdf("object"));
+const rdfReifies = new NamedNode(rdf("reifies"));
+const rdfXmlLiteral = new NamedNode(rdf("XMLLiteral"));
+/**
+* Adds an attribute that is not a syntax attribute of its element to `props`
+* (`rdf:version` aside, which `context` reads).
+*/
+const propertyAttr = (a, parser, props) => {
+	if (a.iri === RDF_VERSION) return;
+	if (isForbiddenPropertyAttribute(a.iri)) parser.fail(`${a.attribute.name} is not allowed as a property attribute`, a.attribute);
+	props.push(a);
+};
+/** Gathers an attribute of a node element (run for every one, so a chain of comparisons). */
+const nodeAttribute = (a, parser, attrs) => {
+	const iri = a.iri;
+	if (iri !== RDF_ID && iri !== RDF_NODE_ID && iri !== RDF_ABOUT) {
+		propertyAttr(a, parser, attrs.props);
+		return;
+	}
+	if (Option.isSome(attrs.idAttr)) parser.fail(`rdf:${attrs.idAttr.value.attribute.localName} and rdf:${a.attribute.localName} cannot be used together`, a.attribute);
+	attrs.idAttr = Option.some(a);
+};
+/** Gathers an attribute of a property element (run for every one, so a chain of comparisons). */
+const propertyAttribute = (a, parser, attrs) => {
+	const iri = a.iri;
+	if (iri === RDF_ID) attrs.id = Option.some(a);
+	else if (iri === RDF_ANNOTATION || iri === RDF_ANNOTATION_NODE_ID) {
+		if (Option.isSome(attrs.annotation)) parser.fail("rdf:annotation and rdf:annotationNodeID cannot be used together", a.attribute);
+		attrs.annotation = Option.some(a);
+	} else if (iri === RDF_PARSE_TYPE) attrs.parseType = Option.some(a);
+	else if (iri === RDF_RESOURCE) attrs.resource = Option.some(a);
+	else if (iri === RDF_NODE_ID) attrs.nodeId = Option.some(a);
+	else if (iri === RDF_DATATYPE) attrs.datatype = Option.some(a);
+	else propertyAttr(a, parser, attrs.props);
+};
+const isRdfRoot = (root) => root.namespace === RDF && root.localName === "RDF";
+var RdfXmlParser = class {
+	sink = [];
+	ids = MutableHashSet.empty();
+	counter = 0;
+	blankNodePrefix;
+	defaultVersion;
+	constructor(blankNodePrefix, defaultVersion) {
+		this.blankNodePrefix = blankNodePrefix;
+		this.defaultVersion = defaultVersion;
+	}
+	fail(message, node) {
+		throw new ParseFailure(message, node.position);
+	}
+	/** Fails if any of `attrs` is present: the first `<name> <why>`. */
+	reject(attrs, why) {
+		const other = Option.firstSomeOf(attrs);
+		if (Option.isSome(other)) {
+			const { attribute } = other.value;
+			this.fail(`${attribute.name} ${why}`, attribute);
+		}
+	}
+	emit(s, p, o) {
+		const t = new Triple(s, p, o);
+		this.sink.push(t);
+		return t;
+	}
+	fresh() {
+		return new BlankNode(`${this.blankNodePrefix}${this.counter++}`);
+	}
+	blank(id, node) {
+		if (!isNCName(id)) this.fail(`Invalid blank node identifier "${id}"`, node);
+		return new BlankNode(`${this.blankNodePrefix}${id}`);
+	}
+	/** The IRIs of names and datatypes seen so far, which repeat throughout a document. */
+	names = MutableHashMap.empty();
+	/**
+	* The IRIs of the names read so far, by local name, then namespace (a
+	* local name rarely has more than one).
+	*/
+	qualifiedNames = MutableHashMap.empty();
+	/**
+	* The IRI of a name (`namespace` + `localName`), the same string each time
+	* it is read: names repeat throughout a document, and each later lookup of
+	* the IRI (in the reserved-term set, the node cache) then hashes nothing.
+	*/
+	qualified(namespace, localName) {
+		const byLocalName = MutableHashMap.get(this.qualifiedNames, localName);
+		if (Option.isNone(byLocalName)) {
+			const iri = namespace + localName;
+			MutableHashMap.set(this.qualifiedNames, localName, [[namespace, iri]]);
+			return iri;
+		}
+		const byNamespace = byLocalName.value;
+		const known = byNamespace.find(([ns]) => ns === namespace);
+		if (known !== void 0) return known[1];
+		const iri = namespace + localName;
+		byNamespace.push([namespace, iri]);
+		return iri;
+	}
+	/** The node for the IRI of an element or attribute name, or of a datatype. */
+	named(iri) {
+		const known = MutableHashMap.get(this.names, iri);
+		if (Option.isSome(known)) return known.value;
+		const node = new NamedNode(iri);
+		MutableHashMap.set(this.names, iri, node);
+		return node;
+	}
+	iri(value, ctx) {
+		return new NamedNode(resolveIn(value, ctx.base));
+	}
+	idIri(id, ctx, node) {
+		if (!isNCName(id)) this.fail(`Invalid rdf:ID "${id}"`, node);
+		const iri = resolveIn(`#${id}`, ctx.base);
+		if (MutableHashSet.has(this.ids, iri)) this.fail(`Duplicate rdf:ID "${id}"`, node);
+		MutableHashSet.add(this.ids, iri);
+		return new NamedNode(iri);
+	}
+	literal(value, ctx) {
+		if (ctx.language === "") return literal(value);
+		return ctx.direction === "" ? literal(value, ctx.language) : literal(value, {
+			language: ctx.language,
+			direction: ctx.direction
+		});
+	}
+	/** Computes the evaluation context of an element. */
+	context(el, parent) {
+		if (Arr.isReadonlyArrayEmpty(el.attributes)) return parent;
+		let base = parent.base;
+		let language = parent.language;
+		let direction = parent.direction;
+		let version = parent.version;
+		let dir = Option.none();
+		el.attributes.forEach((a) => {
+			if (a.namespace === "http://www.w3.org/XML/1998/namespace") {
+				if (a.localName === "base") base = Option.some(resolveIn(a.value, base));
+				else if (a.localName === "lang") language = a.value;
+			} else if (a.namespace === ITS && a.localName === "dir") dir = Option.some(a);
+			else if ((a.namespace === RDF || a.namespace === void 0) && a.localName === "version") version = Option.some(a.value);
+		});
+		if (Option.isSome(dir) && isRdf12(version)) {
+			const value = dir.value.value;
+			if (value !== "ltr" && value !== "rtl" && value !== "") this.fail(`Invalid its:dir value "${value}"`, dir.value);
+			direction = value;
+		}
+		return {
+			base,
+			language,
+			direction,
+			version
+		};
+	}
+	/** The RDF-relevant attributes of an element, with their IRIs. */
+	attributes(el) {
+		const out = [];
+		el.attributes.forEach((a) => {
+			if (a.namespace === "http://www.w3.org/XML/1998/namespace") return;
+			if (a.prefix.toLowerCase().startsWith("xml")) return;
+			if (a.namespace === void 0) {
+				if (a.localName.toLowerCase().startsWith("xml")) return;
+				if (!MutableHashSet.has(UNQUALIFIED_RDF_ATTRIBUTES, a.localName)) this.fail(`Unqualified attribute "${a.localName}" is not allowed`, a);
+				out.push({
+					iri: this.qualified(RDF, a.localName),
+					value: a.value,
+					attribute: a
+				});
+				return;
+			}
+			if (a.namespace === ITS && (a.localName === "dir" || a.localName === "version")) return;
+			out.push({
+				iri: this.qualified(a.namespace, a.localName),
+				value: a.value,
+				attribute: a
+			});
+		});
+		return out;
+	}
+	elementIri(el) {
+		if (el.namespace === void 0) this.fail(`Element "${el.name}" is not in a namespace`, el);
+		return this.qualified(el.namespace, el.localName);
+	}
+	document(doc, base) {
+		const root = doc.root;
+		const ctx = {
+			base,
+			language: "",
+			direction: "",
+			version: this.defaultVersion
+		};
+		if (isRdfRoot(root)) this.nodeElementList(root.children, this.rdfRoot(root, ctx));
+		else this.nodeElement(root, ctx);
+	}
+	/** The context of the node elements in an `rdf:RDF` root, after checking its attributes. */
+	rdfRoot(root, ctx) {
+		const rootCtx = this.context(root, ctx);
+		this.attributes(root).forEach((a) => {
+			if (a.iri !== RDF_VERSION) this.fail(`Unexpected attribute on rdf:RDF`, a.attribute);
+		});
+		return rootCtx;
+	}
+	nodeElementList(children, ctx) {
+		const subjects = [];
+		children.forEach((c) => {
+			if (isElement(c)) subjects.push(this.nodeElement(c, ctx));
+			else if (isText(c) && !isWhitespace(c.value)) this.fail("Unexpected text where node elements are expected", c);
+		});
+		return subjects;
+	}
+	nodeElement(el, parentCtx) {
+		const ctx = this.context(el, parentCtx);
+		const iri = this.elementIri(el);
+		if (isForbiddenNodeElement(iri)) this.fail(`<${el.name}> is not allowed as a node element`, el);
+		const attrs = {
+			idAttr: Option.none(),
+			props: []
+		};
+		this.attributes(el).forEach((a) => nodeAttribute(a, this, attrs));
+		const s = Option.match(attrs.idAttr, {
+			onNone: () => this.fresh(),
+			onSome: (idAttr) => {
+				const local = idAttr.iri.slice(43);
+				return local === "ID" ? this.idIri(idAttr.value, ctx, idAttr.attribute) : local === "nodeID" ? this.blank(idAttr.value, idAttr.attribute) : this.iri(idAttr.value, ctx);
+			}
+		});
+		if (iri !== RDF_DESCRIPTION) this.emit(s, rdfType, this.named(iri));
+		attrs.props.forEach((a) => {
+			this.emit(s, this.named(a.iri), a.iri === RDF_TYPE ? this.iri(a.value, ctx) : this.literal(a.value, ctx));
+		});
+		this.propertyEltList(el, s, ctx);
+		return s;
+	}
+	propertyEltList(el, subject, ctx) {
+		let li = 1;
+		el.children.forEach((c) => {
+			if (isElement(c)) {
+				const name = this.elementIri(c);
+				this.propertyElt(c, name === RDF_LI ? rdf(`_${li++}`) : name, subject, ctx);
+			} else if (isText(c) && !isWhitespace(c.value)) this.fail("Unexpected text where property elements are expected", c);
+		});
+	}
+	propertyElt(el, iri, subject, parentCtx) {
+		if (isForbiddenPropertyElement(iri)) this.fail(`<${el.name}> is not allowed as a property element`, el);
+		const ctx = this.context(el, parentCtx);
+		const predicate = this.named(iri);
+		const attrs = {
+			id: Option.none(),
+			annotation: Option.none(),
+			parseType: Option.none(),
+			resource: Option.none(),
+			nodeId: Option.none(),
+			datatype: Option.none(),
+			props: []
+		};
+		this.attributes(el).forEach((a) => propertyAttribute(a, this, attrs));
+		const { id, annotation, parseType, resource, nodeId, datatype, props } = attrs;
+		const elements = [];
+		let text = "";
+		let hasText = false;
+		el.children.forEach((c) => {
+			if (isElement(c)) elements.push(c);
+			else if (isText(c)) {
+				text += c.value;
+				hasText = true;
+			}
+		});
+		const finish = (object) => {
+			const statement = this.emit(subject, predicate, object);
+			this.reify(statement, id, annotation, ctx);
+		};
+		const firstProp = Arr.head(props);
+		if (Option.isSome(parseType)) {
+			this.reject([
+				resource,
+				nodeId,
+				datatype,
+				firstProp
+			], "cannot be used with rdf:parseType");
+			Match.value(parseType.value.value).pipe(Match.when("Resource", () => {
+				const n = this.fresh();
+				finish(n);
+				this.propertyEltList(el, n, ctx);
+			}), Match.when("Collection", () => {
+				const items = this.nodeElementList(el.children, ctx);
+				if (!Arr.isArrayNonEmpty(items)) {
+					finish(rdfNil);
+					return;
+				}
+				const cells = Arr.map(items, () => this.fresh());
+				finish(Arr.headNonEmpty(cells));
+				Arr.zip(cells, items).forEach(([cell, item], i) => {
+					this.emit(cell, rdfFirst, item);
+					this.emit(cell, rdfRest, cells[i + 1] ?? rdfNil);
+				});
+			}), Match.when("Triple", () => {
+				const saved = this.sink;
+				this.sink = [];
+				if (!Arr.isArrayNonEmpty(elements) || elements.length !== 1 || hasText && !isWhitespace(text)) this.fail("rdf:parseType=\"Triple\" must contain exactly one node element", el);
+				this.nodeElement(Arr.headNonEmpty(elements), ctx);
+				const triples = this.sink;
+				this.sink = saved;
+				if (!isRdf12(ctx.version)) return;
+				if (!Arr.isArrayNonEmpty(triples) || triples.length !== 1) this.fail(`rdf:parseType="Triple" content must describe exactly one triple, found ${triples.length}`, el);
+				finish(Arr.headNonEmpty(triples));
+			}), Match.orElse(() => {
+				finish(new Literal(canonicalize(el.children), rdfXmlLiteral));
+			}));
+			return;
+		}
+		if (Arr.isArrayNonEmpty(elements)) {
+			if (elements.length > 1) this.fail("A property element can contain only one node element", el);
+			if (!isWhitespace(text)) this.fail("Mixed content is not allowed in a property element", el);
+			this.reject([
+				resource,
+				nodeId,
+				datatype,
+				firstProp
+			], "is not allowed on a property element with content");
+			finish(this.nodeElement(Arr.headNonEmpty(elements), ctx));
+			return;
+		}
+		if (hasText && text !== "") {
+			this.reject([
+				resource,
+				nodeId,
+				firstProp
+			], "is not allowed on a literal property element");
+			finish(Option.isSome(datatype) ? literal(text, this.named(resolveIn(datatype.value.value, ctx.base))) : this.literal(text, ctx));
+			return;
+		}
+		if (Option.isSome(resource) && Option.isSome(nodeId)) this.fail("rdf:resource and rdf:nodeID cannot be used together", nodeId.value.attribute);
+		if (Option.isSome(datatype)) {
+			this.reject([
+				resource,
+				nodeId,
+				firstProp
+			], "cannot be used with rdf:datatype");
+			finish(literal("", this.named(resolveIn(datatype.value.value, ctx.base))));
+			return;
+		}
+		if (Option.isNone(resource) && Option.isNone(nodeId) && Arr.isReadonlyArrayEmpty(props)) {
+			finish(this.literal("", ctx));
+			return;
+		}
+		const r = Option.isSome(resource) ? this.iri(resource.value.value, ctx) : Option.isSome(nodeId) ? this.blank(nodeId.value.value, nodeId.value.attribute) : this.fresh();
+		props.forEach((a) => {
+			this.emit(r, this.named(a.iri), a.iri === RDF_TYPE ? this.iri(a.value, ctx) : this.literal(a.value, ctx));
+		});
+		finish(r);
+	}
+	reify(statement, id, annotation, ctx) {
+		if (Option.isSome(id)) {
+			const i = this.idIri(id.value.value, ctx, id.value.attribute);
+			this.emit(i, rdfType, rdfStatement);
+			this.emit(i, rdfSubject, statement.subject);
+			this.emit(i, rdfPredicate, statement.predicate);
+			this.emit(i, rdfObject, statement.object);
+		}
+		if (Option.isSome(annotation)) {
+			const { iri, value, attribute } = annotation.value;
+			const reifier = iri === RDF_ANNOTATION ? this.iri(value, ctx) : this.blank(value, attribute);
+			this.emit(reifier, rdfReifies, statement);
+		}
+	}
+};
+const toParseError = (message, position) => new RdfParseError({
+	format: FORMAT_NAME,
+	message,
+	line: position.line,
+	column: position.column
+});
+const parseTriples = (doc, options) => Effect.try({
+	try: () => {
+		const parser = new RdfXmlParser(options?.blankNodePrefix ?? freshBlankNodePrefix(), Option.fromUndefinedOr(options?.version));
+		parser.document(doc, Option.fromUndefinedOr(options?.baseIri));
+		return parser.sink;
+	},
+	catch: (e) => {
+		if (e instanceof ParseFailure) return toParseError(e.message, e.position);
+		throw e;
+	}
+});
+/**
+* Adds the namespace declarations of the elements among `nodes` (at
+* `depth`, the root's being 0) and of their descendants down to `maxDepth`
+* to `prefixes`, keeping the first declaration of each prefix.
+*/
+const declarePrefixes = (prefixes, nodes, depth, maxDepth) => {
+	nodes.forEach((node) => {
+		if (!isElement(node)) return;
+		node.namespaceDeclarations.forEach((d) => {
+			if (d.prefix !== "" && d.namespace !== "" && !prefixes.some(([p]) => p === d.prefix)) prefixes.push([d.prefix, d.namespace]);
+		});
+		if (depth < maxDepth) declarePrefixes(prefixes, node.children, depth + 1, maxDepth);
+	});
+};
+/** The prefixes declared on the root, its children and their children. */
+const collectPrefixes = (doc) => {
+	const prefixes = [];
+	declarePrefixes(prefixes, [doc.root], 0, 2);
+	return make(prefixes);
+};
+/**
+* Converts the node elements of an `rdf:RDF` root while the XML is read, as
+* each one is closed, so that no more than one of them is held at a time.
+* The order of conversion (and so of triples, blank nodes and prefixes) and
+* which error is reported are as for a whole document: an XML error anywhere
+* comes first, so the first RDF/XML error is kept until the XML has been
+* read.
+*/
+var RootStream = class {
+	parser;
+	/** The context outside the root, and then that of its node elements. */
+	ctx;
+	prefixes = [];
+	failures = [];
+	/** Whether the root has been seen, and whether it is `rdf:RDF`. */
+	started = false;
+	streaming = false;
+	/** How many of the children the root kept have been converted. */
+	converted = 0;
+	constructor(parser, ctx) {
+		this.parser = parser;
+		this.ctx = ctx;
+	}
+	/** The `RootChildHook`: takes the child if the root is `rdf:RDF`. */
+	take = (child, root) => {
+		if (!this.begin(root)) return false;
+		this.guard(() => {
+			this.drain(root);
+			declarePrefixes(this.prefixes, [child], 1, 2);
+			this.parser.nodeElement(child, this.ctx);
+		});
+		return true;
+	};
+	/** Converts what is left once the document has been read. */
+	finish(doc) {
+		if (this.begin(doc.root)) this.guard(() => this.drain(doc.root));
+		else {
+			this.parser.document(doc, this.ctx.base);
+			declarePrefixes(this.prefixes, [doc.root], 0, 2);
+		}
+		const failure = this.failures.at(0);
+		if (failure !== void 0) throw failure;
+	}
+	begin(root) {
+		if (!this.started) {
+			this.started = true;
+			this.streaming = isRdfRoot(root);
+			if (this.streaming) {
+				declarePrefixes(this.prefixes, [root], 0, 0);
+				this.guard(() => {
+					this.ctx = this.parser.rdfRoot(root, this.ctx);
+				});
+			}
+		}
+		return this.streaming;
+	}
+	/** Converts the children the root kept (text, and elements from entities) since the last time. */
+	drain(root) {
+		const pending = root.children.slice(this.converted);
+		this.converted = root.children.length;
+		declarePrefixes(this.prefixes, pending, 1, 2);
+		this.parser.nodeElementList(pending, this.ctx);
+	}
+	/** Runs a conversion step unless one has failed, keeping its failure. */
+	guard(step) {
+		if (Arr.isReadonlyArrayNonEmpty(this.failures)) return;
+		const outcome = Result.try({
+			try: step,
+			catch: (e) => e
+		});
+		if (Result.isSuccess(outcome)) return;
+		if (!(outcome.failure instanceof ParseFailure)) throw outcome.failure;
+		this.failures.push(outcome.failure);
+	}
+};
+/**
+* Parses an already-parsed XML document as RDF/XML. The root element is
+* `rdf:RDF` or a single node element; `xml:base` on it is returned as the
+* base IRI and namespace declarations on it (and its children) as prefixes.
+* Formats that embed RDF/XML in a larger XML document (XMP, SVG metadata)
+* pass a document whose root is the embedded `rdf:RDF` element.
+*
+* @since 0.1.0
+* @category parsing
+*/
+const parseDocument = (doc, options) => Effect.map(parseTriples(doc, options), (triples) => toResult(toQuadsResult(triples, doc, collectPrefixes(doc), options)));
+/** The result of a parse: the triples in their graph, with the document's prefixes and base. */
+/** The quads of a parse, in their graph, with the document's prefixes and base. */
+const toQuadsResult = (triples, doc, prefixes, options) => {
+	const graph = options?.graph ?? defaultGraph;
+	let baseIri = options?.baseIri;
+	const xmlBase = doc.root.attributes.find((a) => a.namespace === "http://www.w3.org/XML/1998/namespace" && a.localName === "base");
+	if (xmlBase !== void 0) baseIri = resolve(xmlBase.value, baseIri);
+	return {
+		quads: triples.map((t) => new Quad(t.subject, t.predicate, t.object, graph)),
+		prefixes,
+		baseIri
+	};
+};
+const toResult = (quads) => ({
+	dataset: fromIterable(quads.quads),
+	prefixes: quads.prefixes,
+	baseIri: quads.baseIri
+});
+/**
+* Parses a complete RDF/XML document into its statements in document order,
+* without building a dataset. Node elements are converted as they are read,
+* so the XML tree is never held whole.
+*
+* @since 0.1.0
+* @category parsing
+* @example
+* ```ts
+* import * as Effect from 'effect/Effect';
+* import { RdfXml } from '@thomasfosterau/effect-rdf/rdfxml';
+*
+* const { quads } = Effect.runSync(
+*   RdfXml.parseQuads(
+*     `<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+*               xmlns:ex="http://example.org/">
+*        <rdf:Description rdf:about="http://example.org/a" ex:p="1"/>
+*      </rdf:RDF>`,
+*   ),
+* );
+* // quads.length === 1
+* ```
+*/
+const parseQuads = (input, options) => Effect.try({
+	try: () => {
+		const version = Option.fromUndefinedOr(options?.version);
+		const parser = new RdfXmlParser(options?.blankNodePrefix ?? freshBlankNodePrefix(), version);
+		const stream = new RootStream(parser, {
+			base: Option.fromUndefinedOr(options?.baseIri),
+			language: "",
+			direction: "",
+			version
+		});
+		const doc = parseText(input, stream.take);
+		stream.finish(doc);
+		return toQuadsResult(parser.sink, doc, make(stream.prefixes), options);
+	},
+	catch: (e) => {
+		if (e instanceof Failure) return toParseError(e.message, e.position);
+		if (e instanceof ParseFailure) return toParseError(e.message, e.position);
+		throw e;
+	}
+});
+/**
+* Parses a complete RDF/XML document. Namespace declarations on the root
+* element (and its children) are returned as prefixes.
+*
+* @since 0.1.0
+* @category parsing
+*/
+const parse = (input, options) => Effect.map(parseQuads(input, options), toResult).pipe(withParseSpan(trace, input));
+/**
+* The RDF/XML parser.
+*
+* @since 0.1.0
+* @category parsing
+*/
+const parser = makeParser({
+	format,
+	parse
+});
+var SerializeFailure = class {
+	message;
+	constructor(message) {
+		this.message = message;
+	}
+};
+const LOCAL_SUFFIX_RE = new RegExp(`[${NAME_START}][${NAME_CHAR}]*$`, "u");
+/**
+* Splits an IRI into a namespace and a local name that is an XML `NCName`,
+* choosing the longest possible local name. Returns `None` when the IRI does
+* not end with an `NCName` (such IRIs cannot be used as element or
+* attribute names).
+*
+* @since 0.1.0
+* @category serializing
+*/
+const splitIri = (iri) => {
+	const m = LOCAL_SUFFIX_RE.exec(iri);
+	if (m === null || m.index === 0) return Option.none();
+	return Option.some([iri.slice(0, m.index), m[0]]);
+};
+const escapeAttr = escapeAttribute;
+/** Whether `prefix` may be declared for `ns` as configured in `options.prefixes`. */
+const isConfigurable = (prefix, ns) => isNCName(prefix) && !prefix.toLowerCase().startsWith("xml") && ns !== ITS && isValidText(ns) && ns === RDF === (prefix === "rdf") && prefix !== "its";
+/** The first of `name(1)`, `name(2)`, … (counting on from `from`) that `taken` does not hold. */
+const freshName = (taken, from, name) => {
+	const candidate = name(from + 1);
+	return MutableHashSet.has(taken, candidate) ? freshName(taken, from + 1, name) : [candidate, from + 1];
+};
+var Writer = class {
+	namespaces;
+	blankLabels = MutableHashMap.empty();
+	/** The QName of each IRI written so far, while no namespace has been added since. */
+	qnames = MutableHashMap.empty();
+	needsVersion = false;
+	needsIts = false;
+	options;
+	constructor(options, prefixes) {
+		this.options = options;
+		const byNamespace = MutableHashMap.empty();
+		const used = MutableHashSet.empty();
+		prefixes.prefixes.forEach((ns, prefix) => {
+			if (isConfigurable(prefix, ns) && !MutableHashMap.has(byNamespace, ns) && !MutableHashSet.has(used, prefix)) {
+				MutableHashMap.set(byNamespace, ns, prefix);
+				MutableHashSet.add(used, prefix);
+			}
+		});
+		if (!MutableHashMap.has(byNamespace, RDF)) {
+			MutableHashMap.set(byNamespace, RDF, "rdf");
+			MutableHashSet.add(used, "rdf");
+		}
+		MutableHashSet.add(used, "its");
+		this.namespaces = {
+			byNamespace,
+			used,
+			declared: MutableHashSet.make(RDF),
+			counter: 0
+		};
+	}
+	fail(message) {
+		throw new SerializeFailure(message);
+	}
+	qname(iri, what) {
+		const known = MutableHashMap.get(this.qnames, iri);
+		if (Option.isSome(known)) return known.value;
+		const name = this.newQname(iri, what);
+		MutableHashMap.set(this.qnames, iri, name);
+		return name;
+	}
+	newQname(iri, what) {
+		if (!isValidText(iri)) this.fail(`The ${what} <${iri}> contains invalid XML characters`);
+		const { byNamespace, used, declared } = this.namespaces;
+		const configured = Arr.reduce(Arr.fromIterable(MutableHashMap.keys(byNamespace)), Option.none(), (best, ns) => iri.startsWith(ns) && (Option.isNone(best) || ns.length > best.value[0].length) && isNCName(iri.slice(ns.length)) ? Option.some([ns, iri.slice(ns.length)]) : best);
+		const [ns, local] = Option.getOrElse(Option.orElse(configured, () => splitIri(iri)), () => this.fail(`The ${what} <${iri}> cannot be written as an XML QName`));
+		MutableHashSet.add(declared, ns);
+		return `${Option.getOrElse(MutableHashMap.get(byNamespace, ns), () => {
+			const [generated, n] = freshName(used, this.namespaces.counter, (i) => `ns${i}`);
+			this.namespaces.counter = n;
+			MutableHashSet.add(used, generated);
+			MutableHashMap.set(byNamespace, ns, generated);
+			MutableHashMap.clear(this.qnames);
+			return generated;
+		})}:${local}`;
+	}
+	iriRef(iri) {
+		if (!isValidText(iri)) this.fail(`The IRI <${iri}> contains characters not allowed in XML`);
+		const base = this.options.baseIri;
+		if (base !== void 0) {
+			const rel = relativize(iri, base);
+			if (Option.isSome(rel)) return escapeAttr(rel.value);
+		}
+		return escapeAttr(iri);
+	}
+	blankLabel(node) {
+		const known = MutableHashMap.get(this.blankLabels, node.value);
+		if (Option.isSome(known)) return known.value;
+		const label = isNCName(node.value) && !MutableHashSet.has(this.usedLabels, node.value) ? node.value : this.freshLabel();
+		MutableHashSet.add(this.usedLabels, label);
+		MutableHashMap.set(this.blankLabels, node.value, label);
+		return label;
+	}
+	freshLabel() {
+		const [label, n] = freshName(this.usedLabels, this.labelCounter - 1, (i) => `b${i}`);
+		this.labelCounter = n + 1;
+		return label;
+	}
+	usedLabels = MutableHashSet.empty();
+	labelCounter = 0;
+};
+const text = (value, writer) => {
+	if (!isValidText(value)) writer.fail("A literal contains characters not allowed in XML 1.0");
+	return escapeText(value);
+};
+const sortByPredicateObject = (ts) => Arr.sort(ts, Order.combine(Order.mapInput(Order$1, (t) => t.predicate), Order.mapInput(Order$1, (t) => t.object)));
+/** Whether `t` gives its subject an `rdf:type` that can be the name of a typed node element. */
+const isTypeTriple = (t) => t.predicate.value === RDF_TYPE && isNamedNode(t.object) && !isForbiddenNodeElement(t.object.value) && Option.isSome(splitIri(t.object.value));
+const serializeGraph = (triples, options) => {
+	const writer = new Writer(options, options.prefixes ?? empty);
+	const indentUnit = options.indent ?? "  ";
+	const nest = options.nestBlankNodes ?? true;
+	const typed = options.typedNodes ?? true;
+	const graph = {
+		bySubject: MutableHashMap.empty(),
+		references: MutableHashMap.empty()
+	};
+	const referenceCount = (label) => {
+		const count = MutableHashMap.get(graph.references, label);
+		return Option.isSome(count) ? count.value : 0;
+	};
+	const inTripleTerm = MutableHashSet.empty();
+	const markTripleTerm = (t) => {
+		if (isBlankNode(t)) MutableHashSet.add(inTripleTerm, t.value);
+		else if (isTriple(t)) {
+			markTripleTerm(t.subject);
+			markTripleTerm(t.object);
+		}
+	};
+	triples.forEach((t) => {
+		if (isTriple(t.subject)) writer.fail("RDF/XML cannot represent triple terms in the subject position");
+		const subject = t.subject;
+		const key = subject.key;
+		const entry = MutableHashMap.get(graph.bySubject, key);
+		if (Option.isSome(entry)) entry.value.triples.push(t);
+		else MutableHashMap.set(graph.bySubject, key, {
+			subject,
+			triples: [t]
+		});
+		const o = t.object;
+		if (isBlankNode(o)) MutableHashMap.set(graph.references, o.value, referenceCount(o.value) + 1);
+		else if (isTriple(o)) markTripleTerm(o);
+	});
+	const nested = MutableHashSet.empty();
+	if (nest) {
+		MutableHashMap.forEach(graph.references, (count, label) => {
+			if (count === 1 && !MutableHashSet.has(inTripleTerm, label)) MutableHashSet.add(nested, label);
+		});
+		const reachable = MutableHashSet.empty();
+		const visit = (subjectKey) => {
+			const entry = MutableHashMap.get(graph.bySubject, subjectKey);
+			if (Option.isNone(entry)) return;
+			entry.value.triples.forEach((t) => {
+				const o = t.object;
+				if (isBlankNode(o) && MutableHashSet.has(nested, o.value) && !MutableHashSet.has(reachable, o.value)) {
+					MutableHashSet.add(reachable, o.value);
+					visit(o.key);
+				}
+			});
+		};
+		MutableHashMap.forEach(graph.bySubject, (entry, key) => {
+			const s = entry.subject;
+			if (!isBlankNode(s) || !MutableHashSet.has(nested, s.value)) visit(key);
+		});
+		MutableHashMap.forEach(graph.bySubject, (entry) => {
+			const s = entry.subject;
+			if (isBlankNode(s) && MutableHashSet.has(nested, s.value) && !MutableHashSet.has(reachable, s.value)) {
+				MutableHashSet.remove(nested, s.value);
+				visit(s.key);
+			}
+		});
+	}
+	const body = [];
+	/** Writes a node element for `subject` at `depth`. */
+	const node = (subject, depth, inline, lines) => {
+		const pad = indentUnit.repeat(depth);
+		const sorted = Option.match(MutableHashMap.get(graph.bySubject, subject.key), {
+			onNone: () => [],
+			onSome: (entry) => sortByPredicateObject(entry.triples)
+		});
+		const typeTriple = typed ? Arr.findFirst(sorted, (t) => isTypeTriple(t) && isValidText(t.object.value) ? Option.some([t, t.object.value]) : Option.none()) : Option.none();
+		const element = Option.match(typeTriple, {
+			onNone: () => "rdf:Description",
+			onSome: ([, type]) => writer.qname(type, "type")
+		});
+		const ts = Option.match(typeTriple, {
+			onNone: () => sorted,
+			onSome: ([typeT]) => sorted.filter((t) => t !== typeT)
+		});
+		const attrs = isNamedNode(subject) ? ` rdf:about="${writer.iriRef(subject.value)}"` : isBlankNode(subject) && !inline && (referenceCount(subject.value) > 0 || MutableHashSet.has(inTripleTerm, subject.value)) ? ` rdf:nodeID="${writer.blankLabel(subject)}"` : "";
+		if (Arr.isReadonlyArrayEmpty(ts)) {
+			lines.push(`${pad}<${element}${attrs}/>`);
+			return;
+		}
+		lines.push(`${pad}<${element}${attrs}>`);
+		ts.forEach((t) => property(t, depth + 1, lines));
+		lines.push(`${pad}</${element}>`);
+	};
+	const property = (t, depth, lines) => {
+		const pad = indentUnit.repeat(depth);
+		const p = t.predicate.value;
+		if (isForbiddenPropertyElement(p) || p === RDF_LI) writer.fail(`The predicate <${p}> cannot be used as an RDF/XML property element`);
+		const name = writer.qname(p, "predicate");
+		propertyObject(t.object, pad, name, depth, lines);
+	};
+	const propertyObject = Match.fn((o, _pad, _name, _depth, _lines) => o).pipe(Match.withReturnType(), Match.tag("NamedNode", (o, _o, pad, name, _depth, lines) => {
+		lines.push(`${pad}<${name} rdf:resource="${writer.iriRef(o.value)}"/>`);
+	}), Match.tag("BlankNode", (o, _o, pad, name, depth, lines) => {
+		if (MutableHashSet.has(nested, o.value) && !MutableHashSet.has(inTripleTerm, o.value)) {
+			const described = Option.match(MutableHashMap.get(graph.bySubject, o.key), {
+				onNone: () => [],
+				onSome: (entry) => entry.triples
+			});
+			if (Arr.isReadonlyArrayEmpty(described)) {
+				lines.push(`${pad}<${name} rdf:parseType="Resource"/>`);
+				return;
+			}
+			if (!(typed && described.some(isTypeTriple))) {
+				lines.push(`${pad}<${name} rdf:parseType="Resource">`);
+				sortByPredicateObject(described).forEach((x) => property(x, depth + 1, lines));
+				lines.push(`${pad}</${name}>`);
+				return;
+			}
+			lines.push(`${pad}<${name}>`);
+			node(o, depth + 1, true, lines);
+			lines.push(`${pad}</${name}>`);
+			return;
+		}
+		lines.push(`${pad}<${name} rdf:nodeID="${writer.blankLabel(o)}"/>`);
+	}), Match.tag("Literal", (o, _o, pad, name, _depth, lines) => {
+		let attrs = "";
+		if (o.language !== "") {
+			attrs += ` xml:lang="${escapeAttr(o.language)}"`;
+			if (o.direction !== void 0) {
+				writer.needsVersion = true;
+				writer.needsIts = true;
+				attrs += ` its:dir="${o.direction}"`;
+			}
+		} else if (o.datatype.value !== XSD_STRING) attrs += ` rdf:datatype="${writer.iriRef(o.datatype.value)}"`;
+		if (o.value === "") lines.push(`${pad}<${name}${attrs}/>`);
+		else lines.push(`${pad}<${name}${attrs}>${text(o.value, writer)}</${name}>`);
+	}), Match.tag("Triple", (o, _o, pad, name, depth, lines) => {
+		writer.needsVersion = true;
+		lines.push(`${pad}<${name} rdf:parseType="Triple">`);
+		tripleTerm(o, depth + 1, lines);
+		lines.push(`${pad}</${name}>`);
+	}), Match.exhaustive);
+	const tripleTerm = (t, depth, lines) => {
+		const pad = indentUnit.repeat(depth);
+		const s = t.subject;
+		const attrs = isNamedNode(s) ? ` rdf:about="${writer.iriRef(s.value)}"` : isBlankNode(s) ? ` rdf:nodeID="${writer.blankLabel(s)}"` : writer.fail("RDF/XML cannot represent triple terms in the subject position");
+		lines.push(`${pad}<rdf:Description${attrs}>`);
+		const o = t.object;
+		if (isBlankNode(o)) {
+			const name = writer.qname(t.predicate.value, "predicate");
+			if (isForbiddenPropertyElement(t.predicate.value) || t.predicate.value === RDF_LI) writer.fail(`The predicate <${t.predicate.value}> cannot be used as an RDF/XML property element`);
+			lines.push(`${pad}${indentUnit}<${name} rdf:nodeID="${writer.blankLabel(o)}"/>`);
+		} else property(t, depth + 1, lines);
+		lines.push(`${pad}</rdf:Description>`);
+	};
+	Arr.sort(Arr.map(Arr.fromIterable(MutableHashMap.values(graph.bySubject)), (e) => e.subject), Order.make((a, b) => a._tag === b._tag ? compare(a, b) : isNamedNode(a) ? -1 : 1)).forEach((s) => {
+		if (!isBlankNode(s) || !MutableHashSet.has(nested, s.value)) node(s, 1, false, body);
+	});
+	const decls = [
+		...Arr.sort(Arr.filter(Arr.fromIterable(writer.namespaces.byNamespace), ([ns]) => MutableHashSet.has(writer.namespaces.declared, ns)), Order.make((a, b) => a[1] === "rdf" ? -1 : b[1] === "rdf" ? 1 : a[1] < b[1] ? -1 : 1)).map(([ns, prefix]) => `xmlns:${prefix}="${escapeAttr(ns)}"`),
+		...writer.needsIts ? [`xmlns:its="${ITS}"`, "its:version=\"2.0\""] : [],
+		...options.baseIri === void 0 ? [] : [`xml:base="${escapeAttr(options.baseIri)}"`],
+		...writer.needsVersion ? ["rdf:version=\"1.2\""] : []
+	];
+	const sep = `\n${" ".repeat(9)}`;
+	const declaration = options.xmlDeclaration ?? true ? ["<?xml version=\"1.0\" encoding=\"utf-8\"?>"] : [];
+	return `${(Arr.isReadonlyArrayEmpty(body) ? [...declaration, `<rdf:RDF ${decls.join(sep)}/>`] : [
+		...declaration,
+		`<rdf:RDF ${decls.join(sep)}>`,
+		...body,
+		"</rdf:RDF>"
+	]).join("\n")}\n`;
+};
+/**
+* Serialises quads as an RDF/XML document. Fails with `RdfSerializeError`
+* for quads in named graphs, triple terms in the subject position, and
+* predicates that cannot be written as XML QNames.
+*
+* @since 0.1.0
+* @category serializing
+*/
+const serialize = (quads, options) => Effect.suspend(() => {
+	const all = Arr.fromIterable(quads);
+	const named = Arr.findFirst(all, (q) => !isDefaultGraph(q.graph));
+	if (Option.isSome(named)) return Effect.fail(new RdfSerializeError({
+		format: FORMAT_NAME,
+		message: `RDF/XML cannot represent named graphs (found graph ${named.value.graph.key})`
+	}));
+	const triples = all.map((q) => q.triple);
+	return Effect.try({
+		try: () => serializeGraph(triples, options ?? {}),
+		catch: (e) => {
+			if (e instanceof SerializeFailure) return new RdfSerializeError({
+				format: FORMAT_NAME,
+				message: e.message
+			});
+			throw e;
+		}
+	});
+}).pipe(withSerializeSpan(trace));
+/**
+* The RDF/XML serializer.
+*
+* @since 0.1.0
+* @category serializing
+*/
+const serializer = makeSerializer({
+	format,
+	serialize
+});
+/**
+* The RDF/XML codec, including a `Schema` transforming RDF/XML documents to
+* datasets and back.
+*
+* @since 0.1.0
+* @category codecs
+*/
+const codec = makeCodec(parser, serializer);
+export { parseDocument as a, serialize as c, parse as i, serializer as l, codec as n, parseQuads as o, format as r, parser as s, RdfXml_exports as t, splitIri as u };
+
+//# sourceMappingURL=RdfXml-DJ9G4gOq.mjs.map