@thomasfosterau/effect-rdf 0.0.0 → 0.1.0

package/dist/serialize-96KBvKaf.mjs

@@ -0,0 +1,1463 @@
+import { A as escapeString, B as isNamedNode, I as isGround, K as isTriple, N as isBlankNode, O as defaultGraph, P as isDefaultGraph, T as blankNode$1, Y as literal, c as NamedNode, d as Quad, k as escapeIri, o as Literal, t as BlankNode, y as Triple, z as isLiteral } from "./Term-CFLG1qu4.mjs";
+import { m as fromIterable } from "./Dataset-BlmlcI7J.mjs";
+import { i as rdf, n as commonPrefixes, o as xsd } from "./Vocab-DceKywpq.mjs";
+import { l as resolve, s as relativize } from "./Iri-Cr92gsQV.mjs";
+import { i as relabel } from "./Isomorphism-BmqxhKyJ.mjs";
+import { s as make } from "./PrefixMap-BHFPDLO-.mjs";
+import { C as withParseSpan, T as withStreamSpan, n as RdfParseError, o as freshBlankNodePrefix, r as RdfSerializeError, w as withSerializeSpan } from "./Serialization-DP9H5bYQ.mjs";
+import { d as iriRef, h as pnCharsBase, i as blankNodeLabel, m as pnChars, r as alphanumeric } from "./Grammar-mQ8CgE1M.mjs";
+import { a as double, d as pnPrefix, i as decimal, m as stringLiteral, p as skip$1, s as integer, u as pnLocal } from "./Grammar-CPlSxGH6.mjs";
+import { _ as makeLiteral, c as isAbsoluteIri, d as isHex, f as isIriChar, g as isWritableIri, h as isPnCharsU, i as decodeUchar, m as isPnCharsBase, n as blankNodeLabel$1, p as isPnChars, r as decodeEchar, u as isDigit, v as parseLanguageTag } from "./Lexical-Cg0JHrf6.mjs";
+import * as Arr from "effect/Array";
+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 Effect from "effect/Effect";
+import * as Order from "effect/Order";
+import * as Str from "effect/String";
+import * as Record from "effect/Record";
+import * as Stream from "effect/Stream";
+import * as Result from "effect/Result";
+import * as Ascii from "@thomasfosterau/effect-parse/Ascii";
+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/turtle/internal/loop.ts
+/**
+* A loop as a function, for the scans that step a cursor until a condition
+* holds (decoding an escape, walking a list, counting line breaks).
+*
+* @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/turtle/internal/parser.ts
+/**
+* The Turtle and TriG (RDF 1.2) parser: a compiled
+* `@thomasfosterau/effect-parse` grammar over the input string, built on the
+* terminals of `Grammar.ts`, that emits quads as it reads.
+*
+* What depends on the document so far (prefixes, the base IRI, blank node
+* labels and counters, the current graph) lives in a per-parser `Builder`
+* that the grammar's callbacks update, as the hand-written parser it replaces
+* did. Errors are thrown out of the grammar (as a `Stop` at an offset) at the
+* points, and with the messages, of that parser.
+*
+* Input can be fed incrementally. Each run parses as many statements as the
+* buffered text holds; a statement that ends too close to the end of the
+* buffer to be sure of (or fails there) is rolled back and retried with more
+* text, and a statement that fails before the input is complete is re-read in
+* partial mode to tell a real error from a statement that is merely cut off.
+*
+* @internal
+*/
+/** @internal */
+var SyntaxFailure = class extends Error {
+	line;
+	column;
+	constructor(message, line, column) {
+		super(message);
+		this.line = line;
+		this.column = column;
+	}
+};
+/** An error at an offset of the text being parsed, thrown out of the grammar. */
+var Stop = class {
+	message;
+	pos;
+	constructor(message, pos) {
+		this.message = message;
+		this.pos = pos;
+	}
+};
+/**
+* How far past the end of a statement, and past any dots there, the grammar
+* may look (`.%41`, `1.e+5`): a statement ending closer than this to the end
+* of incomplete input is retried once more text has arrived. (A run of dots
+* may continue a name, as in `ex:a...b`, however long it is.)
+*/
+const MARGIN = 3;
+const C_DOT = 46;
+const C_BACKSLASH = 92;
+const C_PERCENT = 37;
+const C_GT = 62;
+/** A run of dots, matched where it starts. */
+const DOTS = /\.*/y;
+/** The offset after any dots at `pos`. */
+const skipDots = (input, pos) => {
+	if (input.charCodeAt(pos) !== C_DOT) return pos;
+	DOTS.lastIndex = pos;
+	DOTS.test(input);
+	return DOTS.lastIndex;
+};
+/** The subject being described, with the predicate, object and reifier in progress. */
+var Frame = class {
+	subject = rdf.nil;
+	predicate = rdf.nil;
+	object = rdf.nil;
+	reifier = Option.none();
+	/** The triple of the current object, once built for a reifier. */
+	triple = Option.none();
+};
+const noReifier = Option.none();
+const noTriple = Option.none();
+var Builder = class {
+	options;
+	prefixes = MutableHashMap.empty();
+	base;
+	out = [];
+	labels = MutableHashMap.empty();
+	counter = 0;
+	graph;
+	inGraph = false;
+	/** Whether the input is complete, and the text being parsed. */
+	final = true;
+	input = "";
+	frames = [];
+	depth = -1;
+	/** A node read before it is known what it is (a TriG subject or graph name). */
+	pending = rdf.nil;
+	/** The state at the start of the current statement, to roll back to. */
+	open = false;
+	snapPos = 0;
+	snapOut = 0;
+	snapCounter = 0;
+	snapGraph;
+	snapInGraph = false;
+	snapBase = Option.none();
+	/** The prefix the statement bound, with its previous binding. */
+	snapPrefix = Option.none();
+	/** Registers for the terms being read (none of them nests). */
+	iriStart = 0;
+	iriEnd = 0;
+	nameStart = 0;
+	prefix = "";
+	stringStart = 0;
+	stringEnd = 0;
+	tagStart = 0;
+	literalStart = 0;
+	literalValue = "";
+	/** Where the last complete statement ended. */
+	lastEnd = 0;
+	/** The state at the start of the run, for a re-run. */
+	runOut = 0;
+	runCounter = 0;
+	runGraph;
+	runInGraph = false;
+	runBase = Option.none();
+	/** The prefixes set during the run, with their previous values. */
+	runPrefixes = [];
+	constructor(options) {
+		this.options = options;
+		this.base = options.baseIri;
+		this.graph = options.graph;
+		this.snapGraph = options.graph;
+		this.runGraph = options.graph;
+	}
+	/** Records the state at the start of a run. */
+	beginRun() {
+		this.open = false;
+		this.lastEnd = 0;
+		this.runOut = this.out.length;
+		this.runCounter = this.counter;
+		this.runGraph = this.graph;
+		this.runInGraph = this.inGraph;
+		this.runBase = this.base;
+		this.runPrefixes.length = 0;
+	}
+	/** Returns to the state at the start of the run (for the re-run of a failed one). */
+	restartRun() {
+		this.open = false;
+		this.lastEnd = 0;
+		this.depth = -1;
+		this.out.length = this.runOut;
+		this.counter = this.runCounter;
+		this.graph = this.runGraph;
+		this.inGraph = this.runInGraph;
+		this.base = this.runBase;
+		Arr.forEach(Arr.reverse(this.runPrefixes), (binding) => this.restorePrefix(binding));
+		this.runPrefixes.length = 0;
+	}
+	restorePrefix([prefix, previous]) {
+		if (Option.isSome(previous)) MutableHashMap.set(this.prefixes, prefix, previous.value);
+		else MutableHashMap.remove(this.prefixes, prefix);
+	}
+	frame() {
+		return this.frames[this.depth] ?? new Frame();
+	}
+	push(subject) {
+		const frame = this.frames[++this.depth] ??= new Frame();
+		frame.subject = subject;
+		frame.reifier = noReifier;
+		frame.triple = noTriple;
+	}
+	emit(s, p, o) {
+		this.out.push(new Quad(s, p, o, this.graph));
+	}
+	fresh() {
+		return new BlankNode(`${this.options.blankNodePrefix}_${(this.counter++).toString(36)}`);
+	}
+	snapshot(pos) {
+		this.open = true;
+		this.depth = -1;
+		this.snapPos = pos;
+		this.snapOut = this.out.length;
+		this.snapCounter = this.counter;
+		this.snapGraph = this.graph;
+		this.snapInGraph = this.inGraph;
+		this.snapBase = this.base;
+		this.snapPrefix = Option.none();
+	}
+	/** Undoes the statement in progress. */
+	rollback() {
+		if (!this.open) return;
+		this.out.length = this.snapOut;
+		this.counter = this.snapCounter;
+		this.graph = this.snapGraph;
+		this.inGraph = this.snapInGraph;
+		this.base = this.snapBase;
+		if (Option.isSome(this.snapPrefix)) {
+			this.restorePrefix(this.snapPrefix.value);
+			this.snapPrefix = Option.none();
+		}
+		this.depth = -1;
+	}
+	setPrefix(prefix, iri) {
+		const binding = [prefix, MutableHashMap.get(this.prefixes, prefix)];
+		if (Option.isNone(this.snapPrefix)) this.snapPrefix = Option.some(binding);
+		this.runPrefixes.push(binding);
+		MutableHashMap.set(this.prefixes, prefix, iri);
+	}
+	openGraph(graph) {
+		this.inGraph = true;
+		this.graph = graph;
+	}
+};
+/** The builder of the parser running the grammar. */
+let b = new Builder({
+	trig: false,
+	baseIri: Option.none(),
+	blankNodePrefix: "",
+	graph: defaultGraph
+});
+const lit = Token.literal;
+const skip = skip$1;
+/** Runs `f` at the current offset, consuming nothing (never skipped by the compiler). */
+const act = (f) => Parser.tap(Parser.location, f);
+/** Throws `message` at the current offset. */
+const failHere = (message) => Parser.make((state) => {
+	throw new Stop(message, state.pos);
+});
+/** Throws the error `diagnose` finds at the current offset. */
+const failWith = (diagnose) => Parser.make((state) => {
+	throw diagnose(state.input, state.pos);
+});
+const at = (s) => Parser.peek(lit(s));
+const nameChar = Token.oneOf([pnChars, ":"]);
+const notName = Parser.not(nameChar);
+/** A case-insensitive keyword followed by a character that cannot continue a name. */
+const keyword = (word) => Parser.terminated(Ascii.caseless(word), notName);
+/** An `@` keyword, not followed by a letter, digit or `-`. */
+const atKeyword = (word) => Parser.terminated(lit(word), Parser.not(Token.oneOf([alphanumeric, "-"])));
+/** `.` or the error "Expected `what`". */
+const expectDot = (what) => Parser.alt(lit("."), failHere(`Expected ${what}`));
+const nameStart = Parser.peek(Parser.alt(lit(":"), Token.oneOf(pnCharsBase)));
+const isDecodeError = Predicate.isTagged("Error");
+/**
+* Scans from `start` with `step`, which returns the next offset, or the
+* error found (`Some`) or the end of the term (`None`) to stop.
+*/
+const scan = (start, step) => {
+	let i = start;
+	let error = Option.none();
+	loop(() => {
+		const next = step(i);
+		if (Predicate.isNumber(next)) {
+			i = next;
+			return true;
+		}
+		error = next;
+		return false;
+	});
+	return error;
+};
+const fail = (message, pos) => Option.some(new Stop(message, pos));
+/** The error in the IRI at `start`, or `None`; `end` bounds an IRI that matched. */
+const iriError = (input, start, end = input.length) => scan(start + 1, (i) => {
+	if (i >= end) return end === input.length ? fail("Unterminated IRI", start) : Option.none();
+	const c = input.charCodeAt(i);
+	if (c === C_GT) return Option.none();
+	if (c === C_BACKSLASH) {
+		const decoded = decodeUchar(input, i);
+		if (isDecodeError(decoded)) return fail(decoded.message, i);
+		if (!isIriChar(decoded.value.codePointAt(0) ?? 0)) return fail("Escaped character is not allowed in an IRI", i);
+		return i + decoded.length;
+	}
+	if (!isIriChar(c)) return fail("Invalid character in IRI", i);
+	return i + 1;
+});
+/** The error in the string at `start`, or `None`; `end` bounds a string that matched. */
+const stringError = (input, start, end = input.length) => {
+	const q = input.charCodeAt(start);
+	const long = input.charCodeAt(start + 1) === q && input.charCodeAt(start + 2) === q;
+	if (!long && input.charCodeAt(start + 1) === q) return Option.none();
+	return scan(start + (long ? 3 : 1), (i) => {
+		if (i >= end) return end === input.length ? fail("Unterminated string literal", start) : Option.none();
+		const c = input.charCodeAt(i);
+		if (c === q) {
+			if (!long) return Option.none();
+			if (input.charCodeAt(i + 1) === q && input.charCodeAt(i + 2) === q) return Option.none();
+			return i + 1;
+		}
+		if (c === C_BACKSLASH) {
+			if (decodeEchar(input.charCodeAt(i + 1)) !== void 0) return i + 2;
+			const decoded = decodeUchar(input, i);
+			if (isDecodeError(decoded)) return fail(decoded.message, i);
+			return i + decoded.length;
+		}
+		if (!long && (c === 10 || c === 13)) return fail("Line break in string literal", i);
+		return i + 1;
+	});
+};
+const diagnosis = (find, message) => (input, pos) => Option.getOrElse(find(input, pos), () => new Stop(message, pos));
+/** `IRIREF` (at a `<`), resolved against the base. */
+const iri = Parser.preceded(act((pos) => {
+	b.iriStart = pos;
+}), Parser.terminated(Parser.alt(Parser.backtrack(iriRef), failWith(diagnosis(iriError, "Invalid IRI"))), act((pos) => {
+	b.iriEnd = pos;
+}))).pipe(Parser.map((value) => {
+	const start = b.iriStart;
+	if (b.iriEnd - start - 2 !== value.length) {
+		const error = iriError(b.input, start, b.iriEnd);
+		if (Option.isSome(error)) throw error.value;
+	}
+	if (Option.isNone(b.base)) {
+		if (!isAbsoluteIri(value)) throw new Stop(`Relative IRI <${value}> cannot be resolved without a base IRI`, start);
+		return new NamedNode(value);
+	}
+	return new NamedNode(resolve(value, b.base.value));
+}));
+/** Fails when a prefix name is followed by a dot (which `PN_PREFIX` cannot end with). */
+const noTrailingDot = Parser.make((state) => {
+	if (state.input.charCodeAt(state.pos) === C_DOT) throw new Stop("A prefix name must not end with \".\"", state.pos - b.prefix.length);
+});
+/** `PN_PREFIX` (possibly empty), before the colon. */
+const prefixLabel = Parser.alt(Parser.terminated(Parser.tap(pnPrefix, (prefix) => {
+	b.prefix = prefix;
+}), noTrailingDot), Parser.preceded(at(":"), Parser.succeed("")), failHere("Invalid prefix name"));
+/** Fails on the escapes that end a local name early: `%` or `\` (after any dots). */
+const localTail = Parser.make((state) => {
+	const input = state.input;
+	const i = skipDots(input, state.pos);
+	const c = input.charCodeAt(i);
+	if (c === C_PERCENT) throw new Stop("Invalid percent escape", i);
+	if (c === C_BACKSLASH) throw new Stop("Invalid escape in local name", i);
+});
+const prefixedName = Parser.preceded(Parser.seq(act((pos) => {
+	b.nameStart = pos;
+}), Parser.tap(prefixLabel, (prefix) => {
+	b.prefix = prefix;
+})), Parser.alt(Parser.preceded(lit(":"), Parser.terminated(Parser.alt(pnLocal, Parser.succeed("")), localTail)).pipe(Parser.map((local) => {
+	const ns = MutableHashMap.get(b.prefixes, b.prefix);
+	if (Option.isNone(ns)) throw new Stop(`Undefined prefix "${b.prefix}:"`, b.nameStart);
+	return new NamedNode(ns.value + local);
+})), Parser.make(() => {
+	throw new Stop("Expected a prefixed name", b.nameStart);
+})));
+const blankNode = Parser.alt(blankNodeLabel, Parser.preceded(lit("_:"), failHere("Invalid blank node label"))).pipe(Parser.map((label) => {
+	const found = MutableHashMap.get(b.labels, label);
+	if (Option.isSome(found)) return found.value;
+	const node = new BlankNode(b.options.blankNodePrefix + (label.startsWith("_") ? `_${label}` : label));
+	MutableHashMap.set(b.labels, label, node);
+	return node;
+}));
+/** An IRI or a blank node label (no anonymous nodes). */
+const resource = Parser.alt(Parser.preceded(at("<<"), failHere("Unexpected triple")), Parser.preceded(at("<"), iri), Parser.preceded(at("_:"), blankNode), prefixedName);
+/** Any of the four string forms (at a quote), returning the value. */
+const string = Parser.preceded(act((pos) => {
+	b.stringStart = pos;
+}), Parser.terminated(Parser.alt(Parser.backtrack(stringLiteral), failWith(diagnosis(stringError, "Invalid string literal"))), act((pos) => {
+	b.stringEnd = pos;
+}))).pipe(Parser.map((value) => {
+	const input = b.input;
+	const start = b.stringStart;
+	const q = input.charCodeAt(start);
+	const quotes = input.charCodeAt(start + 1) === q && input.charCodeAt(start + 2) === q ? 6 : 2;
+	if (b.stringEnd - start - quotes !== value.length) {
+		const error = stringError(input, start, b.stringEnd);
+		if (Option.isSome(error)) throw error.value;
+	}
+	return value;
+}));
+const datatype = Parser.alt(Parser.preceded(Parser.seq(Parser.not(lit("<<")), at("<")), iri), Parser.preceded(nameStart, prefixedName), failHere("Expected a datatype IRI"));
+const languageTag = Parser.preceded(lit("@"), Parser.preceded(act((pos) => {
+	b.tagStart = pos;
+}), Token.takeWhile([alphanumeric, "-"]))).pipe(Parser.map((text) => {
+	const tag = parseLanguageTag(text);
+	if (tag === void 0) throw new Stop("Invalid language tag", b.tagStart);
+	return tag;
+}));
+/** The literal read, with a language tag or datatype. */
+const annotatedLiteral = (annotation) => {
+	const result = makeLiteral(b.literalValue, annotation);
+	if (Predicate.isString(result)) throw new Stop(result, b.literalStart);
+	return result;
+};
+const rdfLiteral = Parser.preceded(Parser.seq(act((pos) => {
+	b.literalStart = pos;
+}), Parser.tap(string, (value) => {
+	b.literalValue = value;
+}), skip), Parser.alt(languageTag.pipe(Parser.map(annotatedLiteral)), Parser.preceded(Parser.alt(lit("^^"), Parser.preceded(at("^"), failHere("Expected '^^'"))), Parser.preceded(skip, datatype)).pipe(Parser.map(annotatedLiteral)), Parser.make(() => literal(b.literalValue))));
+const numericLiteral = Parser.alt(double.pipe(Parser.map((value) => new Literal(value, xsd.double))), decimal.pipe(Parser.map((value) => new Literal(value, xsd.decimal))), integer.pipe(Parser.map((value) => new Literal(value, xsd.integer))), failHere("Invalid number"));
+const trueLiteral = new Literal("true", xsd.boolean);
+const falseLiteral = new Literal("false", xsd.boolean);
+const booleanLiteral = Parser.alt(Parser.terminated(lit("true"), notName).pipe(Parser.as(trueLiteral)), Parser.terminated(lit("false"), notName).pipe(Parser.as(falseLiteral)));
+/** Numbers, booleans and prefixed names. */
+const simpleObject = Parser.alt(Parser.preceded(Parser.peek(Token.oneOf("0123456789+-.")), numericLiteral), booleanLiteral, Parser.preceded(nameStart, prefixedName), failHere("Expected an object"));
+const anon = Parser.seq(lit("["), Token.takeWhile(" 	\r\n"), lit("]")).pipe(Parser.map(() => b.fresh()));
+/** `iri | BlankNode`, including `[]`. */
+const iriOrBlankNode = (what) => Parser.alt(Parser.preceded(at("["), Parser.alt(anon, failHere(`Blank node property lists are not allowed in ${what}`))), Parser.preceded(at("<<"), failHere(`Unexpected triple in ${what}`)), Parser.preceded(at("("), failHere(`Collections are not allowed in ${what}`)), Parser.preceded(Parser.peek(Token.oneOf("<_:")), resource), Parser.preceded(Parser.seq(Parser.peek(Token.oneOf(pnCharsBase)), Parser.not(booleanLiteral)), resource), failHere(`Expected an IRI or blank node in ${what}`));
+const verb = Parser.alt(Parser.preceded(at("<<"), failHere("Triples are not allowed as predicates")), Parser.preceded(at("<"), iri), Parser.terminated(lit("a"), notName).pipe(Parser.as(rdf.type)), Parser.preceded(nameStart, prefixedName), failHere("Expected a predicate"));
+const tripleTerm = Parser.suspend(() => tripleTermDef);
+const reifiedTriple = Parser.suspend(() => reifiedTripleDef);
+const object = Parser.suspend(() => objectDef);
+const predicateObjectList = Parser.suspend(() => predicateObjectListDef);
+/** The object of a reified triple or triple term. */
+const innerObject = (reified) => {
+	const what = reified ? "reified triples" : "triple terms";
+	return Parser.alt(Parser.preceded(at("<<("), tripleTerm), Parser.preceded(at("<<"), reified ? reifiedTriple : failHere("Reified triples are not allowed in triple terms")), Parser.preceded(Parser.peek(Token.oneOf("<_")), resource), Parser.preceded(at("["), Parser.alt(anon, failHere(`Blank node property lists are not allowed in ${what}`))), Parser.preceded(at("("), failHere(`Collections are not allowed in ${what}`)), Parser.preceded(Parser.peek(Token.oneOf("\"'")), rdfLiteral), simpleObject);
+};
+const tripleTermDef = Parser.seq(Parser.preceded(Parser.seq(lit("<<("), skip), iriOrBlankNode("the subject of a triple term")), Parser.preceded(skip, verb), Parser.preceded(skip, innerObject(false)), Parser.preceded(skip, Parser.alt(lit(")>>"), failHere("Expected ')>>'")))).pipe(Parser.map(([s, p, o]) => new Triple(s, p, o)));
+const startsReifierId = Parser.peek(Parser.alt(Parser.preceded(Parser.not(lit("<<")), lit("<")), lit("_:"), anon, lit(":"), Token.oneOf(pnCharsBase)));
+/** A reifier IRI or blank node, including `[]`. */
+const reifierId = Parser.preceded(startsReifierId, Parser.alt(Parser.preceded(at("["), anon), resource));
+const reifiedTripleDef = Parser.seq(Parser.preceded(Parser.seq(lit("<<"), skip), Parser.alt(Parser.preceded(Parser.seq(at("<<"), Parser.not(lit("<<("))), reifiedTriple), iriOrBlankNode("the subject of a reified triple"))), Parser.preceded(skip, verb), Parser.preceded(skip, innerObject(true)), Parser.preceded(skip, Parser.opt(Parser.preceded(Parser.seq(lit("~"), skip), Parser.terminated(Parser.opt(reifierId), skip)))), Parser.alt(lit(">>"), failHere("Expected '>>'"))).pipe(Parser.map(([s, p, o, r]) => {
+	const reifier = Option.getOrElse(Option.flatten(r), () => b.fresh());
+	b.emit(reifier, rdf.reifies, new Triple(s, p, o));
+	return reifier;
+}));
+const blankNodePropertyList = Parser.seq(Parser.tap(lit("[").pipe(Parser.map(() => b.fresh())), (node) => b.push(node)), Parser.preceded(skip, predicateObjectList), Parser.preceded(skip, Parser.alt(lit("]"), failHere("Expected ']'")))).pipe(Parser.tap(() => {
+	b.depth--;
+}), Parser.map(([node]) => node));
+const collection = Parser.preceded(Parser.seq(lit("("), skip), Parser.terminated(Parser.repeat(Parser.preceded(Parser.seq(Parser.not(lit(")")), Parser.not(Parser.eof)), Parser.terminated(object, skip))), Parser.alt(lit(")"), failHere("Expected ')'")))).pipe(Parser.map((items) => {
+	if (Arr.isReadonlyArrayEmpty(items)) return rdf.nil;
+	const head = b.fresh();
+	Arr.reduce(items, head, (cell, item, i) => {
+		b.emit(cell, rdf.first, item);
+		const next = i + 1 < items.length ? b.fresh() : rdf.nil;
+		b.emit(cell, rdf.rest, next);
+		return next;
+	});
+	return head;
+}));
+/**
+* A parser as a rule of its own: the compiler inlines everything between
+* rules, and leaves inlined into the recursive productions would make their
+* stack frames (and so the nesting the parser supports) much larger.
+*/
+const rule = (p) => Parser.suspend(() => p);
+const objectDef = Parser.alt(Parser.preceded(at("<<("), tripleTerm), Parser.preceded(at("<<"), reifiedTriple), Parser.preceded(at("<"), rule(iri)), Parser.preceded(at("_:"), rule(blankNode)), Parser.preceded(at("_"), rule(prefixedName)), Parser.preceded(at("["), Parser.alt(rule(anon), rule(blankNodePropertyList))), Parser.preceded(at("("), rule(collection)), Parser.preceded(Parser.peek(Token.oneOf("\"'")), rule(rdfLiteral)), rule(simpleObject));
+const freshNode = Parser.make(() => b.fresh());
+const emitObject = Parser.tap(object, (o) => {
+	const frame = b.frame();
+	b.emit(frame.subject, frame.predicate, o);
+	frame.object = o;
+	frame.reifier = noReifier;
+	frame.triple = noTriple;
+});
+/** The triple of the frame's current object, built once. */
+const frameTriple = (frame) => {
+	if (Option.isSome(frame.triple)) return frame.triple.value;
+	const triple = new Triple(frame.subject, frame.predicate, frame.object);
+	frame.triple = Option.some(triple);
+	return triple;
+};
+const reifies = (frame, reifier) => {
+	b.emit(reifier, rdf.reifies, frameTriple(frame));
+};
+const annotation = Parser.repeat(Parser.preceded(skip, Parser.alt(Parser.tap(Parser.preceded(Parser.seq(lit("~"), skip), Parser.alt(reifierId, freshNode)), (reifier) => {
+	const frame = b.frame();
+	reifies(frame, reifier);
+	frame.reifier = Option.some(reifier);
+}), Parser.seq(Parser.tap(lit("{|"), () => {
+	const frame = b.frame();
+	if (Option.isSome(frame.reifier)) {
+		b.push(frame.reifier.value);
+		return;
+	}
+	const reifier = b.fresh();
+	frame.reifier = Option.some(reifier);
+	reifies(frame, reifier);
+	b.push(reifier);
+}), Parser.preceded(skip, predicateObjectList), Parser.preceded(skip, Parser.alt(lit("|}"), failHere("Expected '|}'")))).pipe(Parser.tap(() => {
+	b.depth--;
+	b.frame().reifier = noReifier;
+})))));
+const objectList = Parser.seq(emitObject, rule(annotation), skip, Parser.repeat(Parser.preceded(Parser.seq(lit(","), skip), Parser.seq(emitObject, annotation, skip))));
+const setPredicate = Parser.tap(rule(verb), (p) => {
+	b.frame().predicate = p;
+});
+const startsVerb = Parser.peek(Parser.alt(Parser.preceded(Parser.not(lit("<<")), lit("<")), lit(":"), Token.oneOf(pnCharsBase)));
+const predicateObjectListDef = Parser.seq(setPredicate, skip, objectList, Parser.repeat(Parser.preceded(Parser.repeat(Parser.seq(lit(";"), skip), { min: 1 }), Parser.opt(Parser.preceded(startsVerb, Parser.seq(setPredicate, skip, objectList))))));
+/** `subject` (pushed while `rest` describes it). */
+const describing = (subject, rest) => Parser.terminated(Parser.preceded(Parser.tap(subject, (s) => b.push(s)), rest), act(() => {
+	b.depth--;
+}));
+const notEnd = Parser.not(Token.oneOf(".}"));
+const properties = Parser.preceded(skip, predicateObjectList);
+const optionalProperties = Parser.preceded(skip, Parser.opt(Parser.preceded(notEnd, predicateObjectList)));
+/** The `triples` production. */
+const triples = Parser.alt(Parser.preceded(at("["), Parser.alt(describing(anon, properties), describing(blankNodePropertyList, optionalProperties))), Parser.preceded(at("("), describing(collection, properties)), Parser.preceded(at("<<("), failHere("Triple terms are not allowed as subjects")), Parser.preceded(at("<<"), describing(reifiedTriple, optionalProperties)), describing(resource, properties));
+const prefixDirective = (turtle) => Parser.seq(Parser.tap(Parser.preceded(skip, Parser.seq(Parser.location, prefixLabel, Parser.opt(lit(":")))), ([start, , colon]) => {
+	if (Option.isNone(colon)) throw new Stop("Expected a prefix name ending with \":\"", start);
+}), Parser.preceded(skip, Parser.alt(Parser.preceded(at("<"), iri), failHere("Expected an IRI"))), turtle ? Parser.preceded(skip, expectDot("'.' after @prefix")) : Parser.succeed(void 0)).pipe(Parser.tap(([[, prefix], ref]) => {
+	b.setPrefix(prefix, ref.value);
+}));
+const baseDirective = (turtle) => Parser.seq(Parser.preceded(skip, Parser.alt(Parser.preceded(at("<"), iri), failHere("Expected an IRI"))), turtle ? Parser.preceded(skip, expectDot("'.' after @base")) : Parser.succeed(void 0)).pipe(Parser.tap(([ref]) => {
+	b.base = Option.some(ref.value);
+}));
+const versionDirective = (turtle) => Parser.seq(Parser.preceded(skip, Parser.alt(Parser.preceded(Parser.peek(Parser.alt(lit("\"\"\""), lit("'''"))), failHere("Long strings are not allowed as version specifiers")), Parser.preceded(Parser.peek(Token.oneOf("\"'")), string), failHere("Expected a version string"))), turtle ? Parser.preceded(skip, expectDot("'.' after @version")) : Parser.succeed(void 0));
+const directive = Parser.alt(Parser.preceded(at("@"), Parser.alt(Parser.preceded(atKeyword("@prefix"), prefixDirective(true)), Parser.preceded(atKeyword("@base"), baseDirective(true)), Parser.preceded(atKeyword("@version"), versionDirective(true)), failHere("Unknown directive"))), Parser.preceded(keyword("prefix"), prefixDirective(false)), Parser.preceded(keyword("base"), baseDirective(false)), Parser.preceded(keyword("version"), versionDirective(false)));
+const endOfStatement = Parser.preceded(skip, expectDot("'.' at the end of the statement"));
+const turtleStatement = Parser.alt(directive, Parser.seq(triples, endOfStatement));
+const pending = (p) => Parser.tap(p, (node) => {
+	b.pending = node;
+});
+/** A graph block opened with `{` after `pending`, or properties of `pending`. */
+const graphOrProperties = Parser.preceded(skip, Parser.alt(Parser.tap(lit("{"), () => b.openGraph(b.pending)), Parser.seq(describing(Parser.make(() => b.pending), predicateObjectList), endOfStatement)));
+const graphLabel = Parser.alt(Parser.preceded(at("["), Parser.alt(anon, failHere("Expected a graph name"))), resource);
+/** A TriG block outside graphs. */
+const block = Parser.alt(Parser.tap(lit("{"), () => b.openGraph(defaultGraph)), Parser.preceded(keyword("graph"), Parser.seq(pending(Parser.preceded(skip, graphLabel)), Parser.preceded(skip, Parser.alt(lit("{"), failHere("Expected '{' after graph name")))).pipe(Parser.tap(() => b.openGraph(b.pending)))), Parser.preceded(at("["), Parser.alt(Parser.preceded(pending(anon), graphOrProperties), Parser.seq(describing(blankNodePropertyList, Parser.preceded(skip, Parser.opt(Parser.preceded(Parser.not(lit(".")), predicateObjectList)))), endOfStatement))), Parser.preceded(at("("), Parser.seq(describing(collection, properties), endOfStatement)), Parser.preceded(at("<<("), failHere("Triple terms are not allowed as subjects")), Parser.preceded(at("<<"), Parser.seq(describing(reifiedTriple, Parser.preceded(skip, Parser.opt(Parser.preceded(Parser.not(lit(".")), predicateObjectList)))), endOfStatement)), Parser.preceded(pending(resource), graphOrProperties));
+/** Whether a TriG graph block is open (consuming nothing). */
+const inGraph = Parser.make((state) => b.inGraph ? void 0 : state.backtrack("Verify", ["a graph block"]));
+const graphStatement = Parser.alt(Parser.tap(lit("}"), () => {
+	b.inGraph = false;
+	b.graph = b.options.graph;
+}), Parser.seq(triples, skip, Parser.alt(lit("."), at("}"), failHere("Expected '.' or '}'"))));
+const trigStatement = Parser.alt(Parser.preceded(inGraph, graphStatement), directive, block);
+/** Records the state at the start of a statement. */
+const beginStatement = Parser.make((state) => {
+	b.snapshot(state.pos);
+});
+/**
+* Ends a statement, unless the input may continue so close to its end that
+* the statement could still turn out differently.
+*/
+const endStatement = Parser.make((state) => {
+	if (!b.final) {
+		const input = state.input;
+		if (skipDots(input, state.pos) + MARGIN > input.length) return state.backtrack("Verify", ["more input"]);
+	}
+	b.open = false;
+	b.lastEnd = state.pos;
+});
+/** Starts a run: the compiled run, or the interpreted re-run after it fails. */
+const startRun = Parser.make((state) => {
+	b.input = state.input;
+	b.restartRun();
+});
+const statements = (statement) => Compiler.jit(Parser.preceded(startRun, Parser.preceded(Parser.repeat(Parser.preceded(skip, Parser.preceded(Parser.not(Parser.eof), Parser.delimited(beginStatement, statement, endStatement)))), Parser.preceded(skip, Parser.location))));
+const turtleStatements = statements(turtleStatement);
+const trigStatements = statements(trigStatement);
+/** One statement, for the partial-mode check (setting the input first). */
+const single = (statement) => Parser.preceded(Parser.make((state) => {
+	b.input = state.input;
+}), statement);
+const turtleSingle = single(turtleStatement);
+const trigSingle = single(trigStatement);
+/** @internal */
+var TurtleParser = class {
+	input = "";
+	pos = 0;
+	final = true;
+	/** Lines and columns consumed before the start of `input`. */
+	lineOffset = 0;
+	columnOffset = 0;
+	started = false;
+	builder;
+	/** How much text the failing statement at `pos` had when it was last checked (or -1). */
+	checked = -1;
+	options;
+	constructor(options) {
+		this.options = options;
+		this.builder = new Builder(options);
+	}
+	get prefixes() {
+		return this.builder.prefixes;
+	}
+	get base() {
+		return this.builder.base;
+	}
+	/** Parses a complete document. */
+	parseDocument(input) {
+		this.input = input;
+		this.pos = 0;
+		this.final = true;
+		this.skipBom();
+		this.run();
+		return this.finish();
+	}
+	/** Adds a chunk of input and returns the statements completed so far. */
+	feed(chunk) {
+		this.discardConsumed();
+		this.input += chunk;
+		this.final = false;
+		this.skipBom();
+		this.run();
+		return this.take();
+	}
+	/** Signals the end of input and returns the remaining statements. */
+	end() {
+		this.final = true;
+		this.run();
+		return this.finish();
+	}
+	finish() {
+		if (this.builder.inGraph) this.fail("Unterminated graph block: expected '}'");
+		return this.take();
+	}
+	take() {
+		const out = this.builder.out;
+		this.builder.out = [];
+		return out;
+	}
+	skipBom() {
+		if (this.started) return;
+		if (Str.isEmpty(this.input)) return;
+		this.started = true;
+		if (this.input.charCodeAt(0) === 65279) this.pos = 1;
+	}
+	discardConsumed() {
+		if (this.pos === 0) return;
+		const consumed = this.input.slice(0, this.pos);
+		const lastBreak = Math.max(consumed.lastIndexOf("\n"), consumed.lastIndexOf("\r"));
+		if (lastBreak === -1) this.columnOffset += consumed.length;
+		else {
+			this.lineOffset += countLines(consumed);
+			this.columnOffset = consumed.length - lastBreak - 1;
+		}
+		this.input = this.input.slice(this.pos);
+		this.pos = 0;
+	}
+	/** Parses the statements of the buffered input. */
+	run() {
+		const base = this.pos;
+		const input = base === 0 ? this.input : this.input.slice(base);
+		const builder = this.builder;
+		b = builder;
+		builder.final = this.final;
+		builder.beginRun();
+		const outcome = Result.try({
+			try: () => {
+				const result = Parser.parsePeek(this.options.trig ? trigStatements : turtleStatements, input);
+				if (Result.isFailure(result)) this.fail("Invalid syntax", base + result.failure.offset);
+				const [, end] = result.success;
+				if (this.final) {
+					if (end < input.length) this.fail("Invalid syntax", base + end);
+					this.pos = base + end;
+				} else {
+					builder.rollback();
+					this.pos = base + builder.lastEnd;
+					this.checked = -1;
+				}
+			},
+			catch: (e) => {
+				if (e instanceof Stop) return e;
+				throw e;
+			}
+		});
+		if (Result.isFailure(outcome)) {
+			const e = outcome.failure;
+			builder.rollback();
+			if (this.final) this.fail(e.message, base + e.pos);
+			const start = builder.snapPos;
+			const remaining = input.length - start;
+			if (start !== 0 || this.checked < 0 || remaining < 2 * this.checked) {
+				if (start !== 0 || this.checked < 0) this.checked = remaining;
+				this.pos = base + start;
+				return;
+			}
+			this.checked = remaining;
+			this.check(input, base);
+		}
+	}
+	/**
+	* Before the input is complete, re-reads the statement that failed in
+	* partial mode: it fails again if the error is real, and runs out of input
+	* if the statement is only cut off.
+	*/
+	check(input, base) {
+		const builder = this.builder;
+		const start = builder.snapPos;
+		builder.open = true;
+		const outcome = Result.try({
+			try: () => {
+				const result = Parser.parsePartial(this.options.trig ? trigSingle : turtleSingle, input.slice(start));
+				if (Result.isFailure(result)) this.fail("Invalid syntax", base + start + result.failure.offset);
+			},
+			catch: (e) => {
+				if (e instanceof Stop) return e;
+				throw e;
+			}
+		});
+		if (Result.isFailure(outcome)) {
+			builder.rollback();
+			this.fail(outcome.failure.message, base + start + outcome.failure.pos);
+		}
+		builder.rollback();
+		builder.open = false;
+		this.pos = base + start;
+	}
+	fail(message, pos = this.pos) {
+		const before = this.input.slice(0, pos);
+		const lines = countLines(before);
+		const lastBreak = Math.max(before.lastIndexOf("\n"), before.lastIndexOf("\r"));
+		const column = lines === 0 ? this.columnOffset + pos + 1 : pos - lastBreak;
+		throw new SyntaxFailure(message, this.lineOffset + lines + 1, column);
+	}
+};
+/** A line break: `\r\n`, `\r` or `\n`. */
+const LINE_BREAK = /\r\n?|\n/g;
+const countLines = (text) => {
+	let n = 0;
+	LINE_BREAK.lastIndex = 0;
+	loop(() => {
+		if (!LINE_BREAK.test(text)) return false;
+		n++;
+		return true;
+	});
+	return n;
+};
+// src/turtle/internal/parse.ts
+const makeParser = (syntax, options) => new TurtleParser({
+	trig: syntax.trig,
+	baseIri: Option.fromUndefinedOr(options?.baseIri),
+	blankNodePrefix: options?.blankNodePrefix ?? freshBlankNodePrefix(),
+	graph: (syntax.trig ? void 0 : options?.graph) ?? defaultGraph
+});
+/**
+* Maps what a parse threw — a `SyntaxFailure`, or a defect as an `Error` or
+* its string form — to an `RdfParseError`.
+*/
+const toParseError = (syntax, error) => error instanceof SyntaxFailure ? new RdfParseError({
+	format: syntax.name,
+	message: error.message,
+	line: error.line,
+	column: error.column
+}) : new RdfParseError({
+	format: syntax.name,
+	message: Predicate.isString(error) ? error : error.message
+});
+/** @internal */
+const parseQuads = (syntax, input, options) => Effect.try({
+	try: () => {
+		const parser = makeParser(syntax, options);
+		return {
+			quads: parser.parseDocument(input),
+			prefixes: make(parser.prefixes),
+			baseIri: Option.getOrUndefined(parser.base)
+		};
+	},
+	catch: (error) => toParseError(syntax, Predicate.isError(error) ? error : String(error))
+});
+/** @internal */
+const parse = (syntax, input, options) => Effect.map(parseQuads(syntax, input, options), (result) => ({
+	dataset: fromIterable(result.quads),
+	prefixes: result.prefixes,
+	baseIri: result.baseIri
+})).pipe(withParseSpan(Option.getOrUndefined(syntax.trace), input));
+const END = Symbol("end");
+/** @internal */
+const parseStream = (syntax) => (input, options) => Stream.suspend(() => {
+	const parser = makeParser(syntax, options);
+	return Stream.concat(input, Stream.succeed(END)).pipe(Stream.mapAccumArrayEffect(() => void 0, (_, chunks) => Effect.try({
+		try: () => [void 0, Arr.flatMap(chunks, (chunk) => chunk === END ? parser.end() : parser.feed(chunk))],
+		catch: (error) => toParseError(syntax, Predicate.isError(error) ? error : String(error))
+	})));
+}).pipe(withStreamSpan(Option.getOrUndefined(syntax.trace), "parseStream"));
+// src/turtle/internal/writer.ts
+/**
+* Pretty-printing writer shared by the Turtle and TriG serializers.
+*
+* @internal
+*/
+/** @internal */
+var SerializeFailure = class extends Error {};
+const RDF_TYPE = rdf.type.value;
+const RDF_FIRST = rdf.first.value;
+const RDF_REST = rdf.rest.value;
+const RDF_NIL = rdf.nil.value;
+const RDF_REIFIES = rdf.reifies.value;
+const XSD_INTEGER = xsd.integer.value;
+const XSD_DECIMAL = xsd.decimal.value;
+const XSD_DOUBLE = xsd.double.value;
+const XSD_BOOLEAN = xsd.boolean.value;
+const INTEGER = /^[+-]?[0-9]+$/;
+const DECIMAL = /^[+-]?[0-9]*\.[0-9]+$/;
+const DOUBLE = /^[+-]?(?:[0-9]+\.[0-9]*[eE][+-]?[0-9]+|\.[0-9]+[eE][+-]?[0-9]+|[0-9]+[eE][+-]?[0-9]+)$/;
+/** Characters that may be backslash-escaped in a local name (minus URL delimiters). */
+const LOCAL_ESCAPABLE = "_~.-!$&'()*+,;=@";
+/** An ASCII local name that is already a `PN_LOCAL` (or empty): no character needs encoding. */
+const PLAIN_LOCAL = /^(?:[A-Za-z0-9_:](?:[A-Za-z0-9_:.-]*[A-Za-z0-9_:-])?)?$/;
+/**
+* The characters a long (`"""`) string escapes: `\`, `"`, controls other than
+* tab and line feed, and the noncharacters U+FFFE and U+FFFF. Written as what
+* is kept, so that it names no control character.
+*/
+const LONG_ESCAPED = /[\\"]|[^\t\n -~\x80-\u{fffd}\u{10000}-\u{10ffff}]/gu;
+/** The code point of a one-character string. */
+const codePoint = (ch) => ch.codePointAt(0) ?? 0;
+/** Whether `prefix` is a valid `PN_PREFIX` (or empty). */
+const isPrefixName = (prefix) => {
+	if (prefix === "") return true;
+	const chars = Array.from(prefix, codePoint);
+	return Arr.isReadonlyArrayNonEmpty(chars) && isPnCharsBase(Arr.headNonEmpty(chars)) && Arr.lastNonEmpty(chars) !== 46 && chars.every((c) => isPnChars(c) || c === 46);
+};
+/** Encodes a local name character by character, escaping what `PN_LOCAL` needs escaped. */
+const encodeLocalChars = (local) => {
+	const chars = Array.from(local);
+	const last = chars.length - 1;
+	let out = "";
+	let i = 0;
+	let ok = true;
+	loop(() => {
+		if (i > last) return false;
+		const ch = chars[i] ?? "";
+		const c = codePoint(ch);
+		if (i === 0 ? isPnCharsU(c) || c === 58 || isDigit(c) : isPnChars(c) || c === 58 || c === 46 && i !== last) {
+			out += ch;
+			i += 1;
+			return true;
+		}
+		const h1 = chars[i + 1] ?? "";
+		const h2 = chars[i + 2] ?? "";
+		if (c === 37 && i + 2 < chars.length && isHex(h1.charCodeAt(0)) && isHex(h2.charCodeAt(0))) {
+			out += ch + h1 + h2;
+			i += 3;
+			return true;
+		}
+		if (LOCAL_ESCAPABLE.includes(ch)) {
+			out += `\\${ch}`;
+			i += 1;
+			return true;
+		}
+		ok = false;
+		return false;
+	});
+	return ok ? Option.some(out) : Option.none();
+};
+/** Encodes a local name as `PN_LOCAL`, or returns `None` if it cannot be. */
+const encodeLocalName = (local) => PLAIN_LOCAL.test(local) ? Option.some(local) : encodeLocalChars(local);
+const hex4 = (c) => `\\u${c.toString(16).toUpperCase().padStart(4, "0")}`;
+const escapeLong = (ch) => ch === "\\" ? "\\\\" : ch === "\"" ? "\\\"" : ch === "\r" ? "\\r" : hex4(ch.charCodeAt(0));
+/** Formats a string as a Turtle string literal, using `"""` for multi-line text. */
+const quoteString = (value) => value.includes("\n") ? `"""${value.replace(LONG_ESCAPED, escapeLong)}"""` : `"${escapeString(value)}"`;
+/** Calls `f` for every blank node in `t`, looking inside triple terms. */
+const visitBlankNodes = (t, f) => {
+	if (isBlankNode(t)) f(t);
+	else if (isTriple(t)) {
+		visitBlankNodes(t.subject, f);
+		visitBlankNodes(t.object, f);
+	}
+};
+/** Throws when a triple term's subject is itself a triple term, at any depth of objects. */
+const checkTriple = (t) => {
+	if (isTriple(t.subject)) throw new SerializeFailure(`Triple terms cannot be the subject of a triple term in Turtle 1.2: ${t.key}`);
+	if (isTriple(t.object)) checkTriple(t.object);
+};
+/** @internal */
+const checkQuad = (q, trig) => {
+	if (isTriple(q.subject)) throw new SerializeFailure(`Triple terms cannot be subjects in Turtle 1.2: ${q.key}`);
+	if (!isGround(q)) throw new SerializeFailure(`Cannot serialise non-ground quad ${q.key}`);
+	if (isTriple(q.object)) checkTriple(q.object);
+	if (!trig && !isDefaultGraph(q.graph)) throw new SerializeFailure(`Turtle cannot represent quads in named graphs: ${q.key}`);
+};
+const isIdAnnotation = Predicate.isTagged("Id");
+/** Appends `value` to the list at `key`, creating the list on first use. */
+const pushAt = (map, key, value) => {
+	const list = MutableHashMap.get(map, key);
+	if (Option.isSome(list)) list.value.push(value);
+	else MutableHashMap.set(map, key, [value]);
+};
+/**
+* Groups `values` by key, in order of first appearance, calling `onFirst`
+* with the first value of each group. A run of values with the same key
+* (statements arrive grouped) is appended without a lookup.
+*/
+const groupBy = (values, keyOf, onFirst = () => void 0) => {
+	const groups = MutableHashMap.empty();
+	let lastKey = "";
+	let last = [];
+	values.forEach((value) => {
+		const key = keyOf(value);
+		if (Arr.isReadonlyArrayNonEmpty(last) && key === lastKey) {
+			last.push(value);
+			return;
+		}
+		const found = MutableHashMap.get(groups, key);
+		if (Option.isSome(found)) {
+			found.value.push(value);
+			last = found.value;
+		} else {
+			last = [value];
+			MutableHashMap.set(groups, key, last);
+			onFirst(value, key);
+		}
+		lastKey = key;
+	});
+	return groups;
+};
+/** The list at `key`, or an empty one. */
+const listAt = (map, key) => Option.getOrElse(MutableHashMap.get(map, key), () => []);
+const byNamespaceLength = Order.flip(Order.mapInput(Order.Number, (c) => c.ns.length));
+/** `rdf:type` first (written `a`), then by IRI. */
+const byVerb = (a, b) => a === RDF_TYPE ? -1 : b === RDF_TYPE ? 1 : a < b ? -1 : a > b ? 1 : 0;
+/** @internal */
+var Writer = class {
+	prefixes;
+	/** Whether each of `prefixes` has been written. */
+	usedPrefixes = [];
+	/** The prefixes, longest namespace first (in declaration order for equal lengths). */
+	byLength;
+	blanks = MutableHashMap.empty();
+	/** The keys of the quads written, built when the first reifier is planned. */
+	assertedKeys = Option.none();
+	plan;
+	labels = MutableHashMap.empty();
+	rendered = MutableHashSet.empty();
+	options;
+	quads;
+	relabel;
+	constructor(options, quads, relabel = true) {
+		this.options = options;
+		this.quads = quads;
+		this.relabel = relabel;
+		const declared = MutableHashMap.empty();
+		if (options.autoPrefixes) Arr.forEach(detectPrefixes(quads, options.baseIri), ([p, ns]) => {
+			MutableHashMap.set(declared, p, ns);
+		});
+		if (Option.isSome(options.prefixes)) Iterable.forEach(options.prefixes.value.prefixes, ([p, ns]) => {
+			Arr.forEach(Arr.filter(Arr.fromIterable(declared), ([q, other]) => other === ns && q !== p), ([q]) => {
+				MutableHashMap.remove(declared, q);
+			});
+			MutableHashMap.set(declared, p, ns);
+		});
+		this.prefixes = Arr.filter(Arr.fromIterable(declared), ([p, ns]) => isPrefixName(p) && isWritableIri(ns));
+		this.byLength = Arr.sort(this.prefixes.map(([prefix, ns], index) => ({
+			prefix,
+			ns,
+			index
+		})), byNamespaceLength);
+		if (Option.isSome(options.baseIri) && !isWritableIri(options.baseIri.value)) throw new SerializeFailure(`Invalid base IRI <${options.baseIri.value}>`);
+	}
+	write() {
+		this.quads.forEach((q) => {
+			checkQuad(q, this.options.trig);
+			this.index(q);
+		});
+		const names = MutableHashMap.empty();
+		const byGraph = groupBy(this.quads, (q) => q.graph.key, (q, key) => MutableHashMap.set(names, key, q.graph));
+		const graphs = Arr.sort(Arr.fromIterable(names), Order.mapInput(compareTerms, ([, graph]) => graph)).map(([key, graph]) => ({
+			graph,
+			quads: listAt(byGraph, key)
+		}));
+		const body = Arr.reduce(graphs, "", (out, { graph, quads }) => isDefaultGraph(graph) ? out + this.writeGraph(graph, quads, 0) : `${out}${out === "" ? "" : "\n"}${this.term(graph)} {\n${this.writeGraph(graph, quads, 1)}}\n`);
+		return this.header() + body;
+	}
+	asserted() {
+		if (Option.isSome(this.assertedKeys)) return this.assertedKeys.value;
+		const keys = MutableHashSet.empty();
+		this.quads.forEach((q) => MutableHashSet.add(keys, q.key));
+		this.assertedKeys = Option.some(keys);
+		return keys;
+	}
+	header() {
+		const sparql = this.options.sparqlDirectives;
+		const out = Option.match(this.options.baseIri, {
+			onNone: () => "",
+			onSome: (iri) => sparql ? `BASE <${escapeIri(iri)}>\n` : `@base <${escapeIri(iri)}> .\n`
+		}) + Arr.sort(this.prefixes.filter((_, i) => this.usedPrefixes[i] === true), byPrefixName).map(([p, ns]) => sparql ? `PREFIX ${p}: <${escapeIri(ns)}>\n` : `@prefix ${p}: <${escapeIri(ns)}> .\n`).join("");
+		return out === "" ? "" : `${out}\n`;
+	}
+	info(b) {
+		const found = MutableHashMap.get(this.blanks, b.value);
+		if (Option.isSome(found)) return found.value;
+		const info = {
+			objectRefs: [],
+			inTripleTerm: false,
+			asGraph: false,
+			subjectGraph: Option.none(),
+			manyGraphs: false
+		};
+		MutableHashMap.set(this.blanks, b.value, info);
+		return info;
+	}
+	index(q) {
+		if (isBlankNode(q.subject)) {
+			const info = this.info(q.subject);
+			if (Option.isNone(info.subjectGraph)) info.subjectGraph = Option.some(q.graph.key);
+			else if (info.subjectGraph.value !== q.graph.key) info.manyGraphs = true;
+		}
+		if (isBlankNode(q.object)) this.info(q.object).objectRefs.push(q);
+		if (isTriple(q.object)) visitBlankNodes(q.object, (b) => {
+			this.info(b).inTripleTerm = true;
+		});
+		if (isBlankNode(q.graph)) this.info(q.graph).asGraph = true;
+	}
+	/** Whether a blank node is local to `graph` and appears in no triple term or graph name. */
+	isLocal(b, graph) {
+		const info = this.info(b);
+		return !info.inTripleTerm && !info.asGraph && !info.manyGraphs && (Option.isNone(info.subjectGraph) || info.subjectGraph.value === graph.key);
+	}
+	planGraph(graph, quads, demoted) {
+		const subjects = MutableHashMap.empty();
+		const bySubject = groupBy(quads, (q) => q.subject.key, (q, key) => MutableHashMap.set(subjects, key, q.subject));
+		const consumed = /* @__PURE__ */ new WeakSet();
+		const inline = MutableHashSet.empty();
+		quads.forEach((q) => {
+			const o = q.object;
+			if (!isBlankNode(o) || MutableHashSet.has(demoted, o.value) || !this.isLocal(o, graph)) return;
+			const refs = this.info(o).objectRefs;
+			if (refs.length === 1 && refs[0]?.graph.key === graph.key) MutableHashSet.add(inline, o.value);
+		});
+		const lists = MutableHashMap.empty();
+		const listCells = MutableHashSet.empty();
+		const listShape = (label) => {
+			if (!MutableHashSet.has(inline, label)) return Option.none();
+			const own = listAt(bySubject, `_:${label}`);
+			if (own.length !== 2) return Option.none();
+			const first = Arr.findFirst(own, (q) => q.predicate.value === RDF_FIRST);
+			const rest = Arr.findFirst(own, (q) => q.predicate.value === RDF_REST);
+			return Option.isSome(first) && Option.isSome(rest) ? Option.some([first.value.object, rest.value.object]) : Option.none();
+		};
+		Iterable.forEach(inline, (label) => {
+			if (Option.isNone(listShape(label))) return;
+			const ref = Arr.head(this.info(blankNode$1(label)).objectRefs);
+			if (Option.isNone(ref) || ref.value.predicate.value === RDF_REST && isBlankNode(ref.value.subject) && Option.isSome(listShape(ref.value.subject.value))) return;
+			const items = [];
+			const cells = [];
+			let current = label;
+			let ok = false;
+			loop(() => {
+				const shape = listShape(current);
+				if (Option.isNone(shape) || cells.includes(current)) return false;
+				const [item, next] = shape.value;
+				cells.push(current);
+				items.push(item);
+				if (isNamedNode(next) && next.value === RDF_NIL) {
+					ok = true;
+					return false;
+				}
+				if (!isBlankNode(next)) return false;
+				current = next.value;
+				return true;
+			});
+			if (!ok) return;
+			MutableHashMap.set(lists, label, items);
+			Arr.forEach(cells, (cell) => {
+				MutableHashSet.add(listCells, cell);
+				Arr.forEach(listAt(bySubject, `_:${cell}`), (q) => {
+					consumed.add(q);
+				});
+			});
+		});
+		const annotations = MutableHashMap.empty();
+		const blockReifiers = MutableHashSet.empty();
+		const reifiedSubjects = MutableHashMap.empty();
+		const idReifiers = MutableHashSet.empty();
+		/** A blank reifier of nothing else, described only here: written as a block or a subject. */
+		const isStandalone = (r) => !MutableHashSet.has(demoted, r.value) && this.isLocal(r, graph) && Arr.isReadonlyArrayEmpty(this.info(r).objectRefs) && listAt(bySubject, r.key).filter((x) => x.predicate.value === RDF_REIFIES && !consumed.has(x)).length === 1;
+		quads.forEach((q) => {
+			if (q.predicate.value !== RDF_REIFIES || !isTriple(q.object)) return;
+			const t = q.object;
+			if (isTriple(t.subject)) return;
+			const r = q.subject;
+			if (isTriple(r)) return;
+			const assertedKey = new Quad(t.subject, t.predicate, t.object, graph).key;
+			const isAsserted = MutableHashSet.has(this.asserted(), assertedKey);
+			if (isBlankNode(r) && isStandalone(r)) {
+				consumed.add(q);
+				if (isAsserted) {
+					MutableHashSet.add(blockReifiers, r.value);
+					pushAt(annotations, assertedKey, {
+						_tag: "Block",
+						reifier: r
+					});
+				} else MutableHashMap.set(reifiedSubjects, r.value, t);
+			} else if (isAsserted && (isNamedNode(r) || !MutableHashSet.has(inline, r.value) && !MutableHashSet.has(listCells, r.value))) {
+				consumed.add(q);
+				if (isBlankNode(r)) MutableHashSet.add(idReifiers, r.value);
+				pushAt(annotations, assertedKey, {
+					_tag: "Id",
+					reifier: r
+				});
+			}
+		});
+		return {
+			graph,
+			bySubject,
+			subjects,
+			inline,
+			lists,
+			listCells,
+			annotations,
+			blockReifiers,
+			idReifiers,
+			reifiedSubjects,
+			consumed
+		};
+	}
+	writeGraph(graph, quads, level) {
+		const demoted = MutableHashSet.empty();
+		let out = "";
+		loop(() => {
+			this.plan = this.planGraph(graph, quads, demoted);
+			this.rendered = MutableHashSet.empty();
+			out = this.renderGraph(level);
+			const before = MutableHashSet.size(demoted);
+			Iterable.forEach(this.plan.inline, (label) => {
+				if (!MutableHashSet.has(this.rendered, label) && !MutableHashSet.has(this.plan.listCells, label)) MutableHashSet.add(demoted, label);
+			});
+			Iterable.forEach(MutableHashMap.keys(this.plan.lists), (label) => {
+				if (!MutableHashSet.has(this.rendered, label)) MutableHashSet.add(demoted, label);
+			});
+			return MutableHashSet.size(demoted) !== before;
+		});
+		return out;
+	}
+	renderGraph(level) {
+		const plan = this.plan;
+		const unsorted = Arr.filter(Arr.fromIterable(MutableHashMap.values(plan.subjects)), (s) => !(isBlankNode(s) && (MutableHashSet.has(plan.inline, s.value) || MutableHashSet.has(plan.listCells, s.value) || MutableHashSet.has(plan.blockReifiers, s.value))));
+		const roots = Arr.sort(unsorted, compareTerms);
+		return Arr.flatMap(roots, (s) => {
+			const quads = listAt(plan.bySubject, s.key).filter((q) => !plan.consumed.has(q));
+			const reified = isBlankNode(s) ? MutableHashMap.get(plan.reifiedSubjects, s.value) : Option.none();
+			const head = Option.isSome(reified) ? this.reifiedTriple(reified.value) : this.term(s);
+			if (Arr.isReadonlyArrayEmpty(quads)) return Option.isSome(reified) ? [`${this.pad(level)}${head} .\n`] : [];
+			if (isBlankNode(s) && Option.isNone(reified) && !MutableHashSet.has(plan.idReifiers, s.value) && Arr.isReadonlyArrayEmpty(this.info(s).objectRefs) && this.isLocal(s, plan.graph)) return [`${this.pad(level)}${this.bracketed("[", "]", quads, level)} .\n`];
+			return [`${this.pad(level)}${head} ${this.predicateObjectList(quads, level + 1)} .\n`];
+		}).join(level === 0 ? "\n" : "");
+	}
+	pad(level) {
+		return this.options.indent.repeat(level);
+	}
+	/** Renders `p o, o ; p o` with continuation lines at `level`. */
+	predicateObjectList(quads, level) {
+		const byPredicate = groupBy(quads, (q) => q.predicate.value);
+		return Arr.sort(byPredicate, Order.mapInput(byVerb, ([p]) => p)).map(([p, list]) => {
+			const objects = Arr.sort(list, Order.mapInput(compareTerms, (q) => q.object)).map((q) => this.objectWithAnnotations(q, level));
+			return `${p === RDF_TYPE ? "a" : this.iri(p)} ${objects.join(", ")}`;
+		}).join(` ;\n${this.pad(level)}`);
+	}
+	objectWithAnnotations(q, level) {
+		let out = this.object(q.object, level);
+		const annotations = MutableHashMap.get(this.plan.annotations, q.key);
+		if (Option.isNone(annotations)) return out;
+		let bare = "";
+		let ids = "";
+		Arr.forEach(Arr.sort(annotations.value, Order.mapInput(compareTerms, (x) => x.reifier)), (annotation) => {
+			if (isIdAnnotation(annotation)) {
+				ids += ` ~ ${this.term(annotation.reifier)}`;
+				return;
+			}
+			const own = listAt(this.plan.bySubject, annotation.reifier.key).filter((x) => !this.plan.consumed.has(x));
+			if (Arr.isReadonlyArrayEmpty(own)) bare += " ~";
+			else out += ` ${this.bracketed("{|", "|}", own, level)}`;
+		});
+		return out + bare + ids;
+	}
+	/** Renders a bracketed property list (`[ ... ]` or `{| ... |}`). */
+	bracketed(open, close, quads, level) {
+		const single = this.predicateObjectList(quads, level + 1);
+		if (!single.includes("\n") && single.length <= 60) return `${open} ${single} ${close}`;
+		return `${open}\n${this.pad(level + 1)}${single}\n${this.pad(level)}${close}`;
+	}
+	object(o, level) {
+		if (isBlankNode(o)) {
+			const items = MutableHashMap.get(this.plan.lists, o.value);
+			if (Option.isSome(items) && !MutableHashSet.has(this.rendered, o.value)) {
+				MutableHashSet.add(this.rendered, o.value);
+				const rendered = items.value.map((item) => this.object(item, level));
+				const oneLine = `( ${rendered.join(" ")} )`;
+				return oneLine.length <= 80 && !oneLine.includes("\n") ? oneLine : `(\n${rendered.map((r) => this.pad(level + 1) + r).join("\n")}\n${this.pad(level)})`;
+			}
+			if (MutableHashSet.has(this.plan.inline, o.value) && !MutableHashSet.has(this.rendered, o.value)) {
+				MutableHashSet.add(this.rendered, o.value);
+				const own = listAt(this.plan.bySubject, o.key).filter((x) => !this.plan.consumed.has(x));
+				if (Arr.isReadonlyArrayEmpty(own)) return "[]";
+				const only = own.length === 1 ? Arr.head(own) : Option.none();
+				if (Option.isSome(only) && only.value.predicate.value === RDF_REIFIES && isTriple(only.value.object) && !isTriple(only.value.object.subject)) return this.reifiedTriple(only.value.object);
+				return this.bracketed("[", "]", own, level);
+			}
+		}
+		if (isNamedNode(o) && o.value === RDF_NIL) return "()";
+		return this.term(o);
+	}
+	reifiedTriple(t) {
+		return `<< ${this.term(t.subject)} ${this.predicate(t.predicate)} ${this.term(t.object)} >>`;
+	}
+	predicate(p) {
+		return p.value === RDF_TYPE ? "a" : this.iri(p.value);
+	}
+	/** Renders a term without any abbreviation that depends on context. */
+	term(t) {
+		if (isNamedNode(t)) return this.iri(t.value);
+		if (isBlankNode(t)) return `_:${this.label(t.value)}`;
+		if (isLiteral(t)) return this.literal(t);
+		if (isTriple(t)) return `<<( ${this.term(t.subject)} ${this.predicate(t.predicate)} ${this.term(t.object)} )>>`;
+		throw new SerializeFailure(`Cannot serialise ${t._tag}`);
+	}
+	/** Output labels are assigned in order of first appearance. */
+	label(value) {
+		if (!this.relabel) return blankNodeLabel$1(value);
+		const found = MutableHashMap.get(this.labels, value);
+		if (Option.isSome(found)) return found.value;
+		const label = `b${MutableHashMap.size(this.labels)}`;
+		MutableHashMap.set(this.labels, value, label);
+		return label;
+	}
+	literal(l) {
+		const dt = l.datatype.value;
+		if (l.language === "") {
+			if (dt === XSD_INTEGER && INTEGER.test(l.value) || dt === XSD_DECIMAL && DECIMAL.test(l.value) || dt === XSD_DOUBLE && DOUBLE.test(l.value) || dt === XSD_BOOLEAN && (l.value === "true" || l.value === "false")) return l.value;
+		}
+		const lexical = quoteString(l.value);
+		if (l.language !== "") {
+			const language = l.language.toLowerCase();
+			return l.direction === void 0 ? `${lexical}@${language}` : `${lexical}@${language}--${l.direction}`;
+		}
+		if (dt === "http://www.w3.org/2001/XMLSchema#string") return lexical;
+		return `${lexical}^^${this.iri(dt)}`;
+	}
+	iri(iri) {
+		if (!isWritableIri(iri)) throw new SerializeFailure(`Invalid or relative IRI <${iri}>`);
+		const best = this.byLength.find((c) => iri.startsWith(c.ns) && Option.isSome(encodeLocalName(iri.slice(c.ns.length))));
+		if (best !== void 0) {
+			this.usedPrefixes[best.index] = true;
+			return `${best.prefix}:${Option.getOrElse(encodeLocalName(iri.slice(best.ns.length)), () => "")}`;
+		}
+		if (Option.isSome(this.options.baseIri)) {
+			const relative = relativize(iri, this.options.baseIri.value);
+			if (Option.isSome(relative)) return `<${escapeIri(relative.value)}>`;
+		}
+		return `<${escapeIri(iri)}>`;
+	}
+};
+/** Term kinds in writing order; anything else (a variable) sorts last. */
+const tagRank = {
+	DefaultGraph: 0,
+	NamedNode: 1,
+	BlankNode: 2,
+	Literal: 3,
+	Triple: 4
+};
+/** The value of a numeric literal, or `NaN`. */
+const numericValue = (l) => {
+	const dt = l.datatype.value;
+	return dt === XSD_INTEGER || dt === XSD_DECIMAL || dt === XSD_DOUBLE ? Number(l.value) : NaN;
+};
+const compareTerms = (a, b) => {
+	const ra = tagRank[a._tag] ?? 5;
+	const rb = tagRank[b._tag] ?? 5;
+	if (ra !== rb) return ra < rb ? -1 : 1;
+	if (isLiteral(a) && isLiteral(b)) {
+		const na = numericValue(a);
+		const nb = numericValue(b);
+		if (!Number.isNaN(na) && !Number.isNaN(nb) && na !== nb) return na < nb ? -1 : 1;
+	}
+	return a.key < b.key ? -1 : a.key > b.key ? 1 : 0;
+};
+/** Prefix declarations by prefix name. */
+const byPrefixName = Order.mapInput(Order.String, ([prefix]) => prefix);
+/** Counts the namespaces of the IRIs in `t` (and in its datatype and triple terms). */
+const countNamespaces = (t, counts) => {
+	if (isNamedNode(t)) {
+		const i = Math.max(t.value.lastIndexOf("#"), t.value.lastIndexOf("/"));
+		if (i <= 0) return;
+		const ns = t.value.slice(0, i + 1);
+		if (!isAbsoluteIri(ns) || Option.isNone(encodeLocalName(t.value.slice(i + 1)))) return;
+		const found = MutableHashMap.get(counts, ns);
+		if (Option.isSome(found)) found.value.count += 1;
+		else MutableHashMap.set(counts, ns, { count: 1 });
+	} else if (isLiteral(t)) {
+		if (t.language === "" && t.datatype.value !== "http://www.w3.org/2001/XMLSchema#string") countNamespaces(t.datatype, counts);
+	} else if (isTriple(t)) {
+		countNamespaces(t.subject, counts);
+		countNamespaces(t.predicate, counts);
+		countNamespaces(t.object, counts);
+	}
+};
+/** Well-known namespaces by IRI, with their usual prefixes. */
+const knownPrefixes = MutableHashMap.fromIterable(Record.toEntries(commonPrefixes).map(([p, ns]) => [ns, p]));
+/**
+* Finds namespaces worth declaring: well-known vocabularies that are used,
+* plus any namespace used by at least two IRIs.
+*/
+const detectPrefixes = (quads, baseIri) => {
+	const baseDir = Option.map(baseIri, (iri) => iri.slice(0, iri.lastIndexOf("/") + 1));
+	const counts = MutableHashMap.empty();
+	quads.forEach((q) => {
+		countNamespaces(q.subject, counts);
+		countNamespaces(q.predicate, counts);
+		countNamespaces(q.object, counts);
+		countNamespaces(q.graph, counts);
+	});
+	let n = 0;
+	return Arr.flatMap(Arr.sort(counts, Order.mapInput(Order.String, ([ns]) => ns)), ([ns, { count }]) => {
+		const name = MutableHashMap.get(knownPrefixes, ns);
+		if (Option.isSome(name)) return [[name.value, ns]];
+		if (Option.isSome(baseDir) && baseDir.value.includes("//") && ns.startsWith(baseDir.value)) return [];
+		return count >= 2 ? [[`ns${n++}`, ns]] : [];
+	});
+};
+/**
+* Normalises quads for writing: relabels blank nodes deterministically.
+*
+* @internal
+*/
+const prepare = (quads) => Array.from(relabel(fromIterable(quads), "b"));
+// src/turtle/internal/streamWriter.ts
+/**
+* An incremental Turtle / TriG writer.
+*
+* @internal
+*/
+/**
+* Groups consecutive statements by graph, subject and predicate but performs
+* no look-ahead (no inline blank nodes, lists or annotations), so it runs in
+* constant memory.
+*
+* @internal
+*/
+var StreamWriter = class {
+	writerInstance = Option.none();
+	/** The keys of the open graph block, statement and predicate. */
+	graph = Option.none();
+	subject = Option.none();
+	predicate = Option.none();
+	started = false;
+	options;
+	constructor(options) {
+		this.options = options;
+	}
+	/** Created lazily so that option validation errors surface as failures. */
+	get writer() {
+		if (Option.isSome(this.writerInstance)) return this.writerInstance.value;
+		const writer = new Writer({
+			...this.options,
+			autoPrefixes: false
+		}, [], false);
+		this.writerInstance = Option.some(writer);
+		return writer;
+	}
+	/** The document header: base and all declared prefixes. */
+	header() {
+		this.writer;
+		const sparql = this.options.sparqlDirectives;
+		const out = Option.match(this.options.baseIri, {
+			onNone: () => "",
+			onSome: (iri) => {
+				const escaped = escapeIri(iri);
+				return sparql ? `BASE <${escaped}>\n` : `@base <${escaped}> .\n`;
+			}
+		}) + Option.match(this.options.prefixes, {
+			onNone: () => "",
+			onSome: (map) => Arr.sort(Arr.filter(Arr.fromIterable(map.prefixes), ([p, ns]) => isPrefixName(p) && isWritableIri(ns)), byPrefixName).map(([p, ns]) => {
+				const iri = escapeIri(ns);
+				return sparql ? `PREFIX ${p}: <${iri}>\n` : `@prefix ${p}: <${iri}> .\n`;
+			}).join("")
+		});
+		return out === "" ? "" : `${out}\n`;
+	}
+	write(quads) {
+		let out = "";
+		if (!this.started) {
+			this.started = true;
+			out += this.header();
+		}
+		const indent = this.options.indent;
+		const writer = this.writer;
+		Iterable.forEach(quads, (q) => {
+			checkQuad(q, this.options.trig);
+			const graph = q.graph.key;
+			if (Option.isNone(this.graph) || this.graph.value !== graph) {
+				out += this.closeGraph();
+				this.graph = Option.some(graph);
+				if (!isDefaultGraph(q.graph)) out += `${writer.term(q.graph)} {\n`;
+			}
+			const pad = isDefaultGraph(q.graph) ? "" : indent;
+			const object = writer.term(q.object);
+			if (Option.isSome(this.subject) && this.subject.value === q.subject.key) {
+				if (Option.isSome(this.predicate) && this.predicate.value === q.predicate.key) out += `, ${object}`;
+				else {
+					this.predicate = Option.some(q.predicate.key);
+					out += ` ;\n${pad}${indent}${this.verb(q.predicate)} ${object}`;
+				}
+			} else {
+				if (Option.isSome(this.subject)) out += " .\n";
+				this.subject = Option.some(q.subject.key);
+				this.predicate = Option.some(q.predicate.key);
+				out += `${pad}${writer.term(q.subject)} ${this.verb(q.predicate)} ${object}`;
+			}
+		});
+		return out;
+	}
+	/** Closes any open statement and graph block. */
+	end() {
+		const head = this.started ? "" : this.header();
+		this.started = true;
+		return head + this.closeGraph();
+	}
+	verb(p) {
+		return p.value === rdf.type.value ? "a" : this.writer.iri(p.value);
+	}
+	closeGraph() {
+		let out = "";
+		if (Option.isSome(this.subject)) out += " .\n";
+		this.subject = Option.none();
+		this.predicate = Option.none();
+		if (Option.isSome(this.graph) && this.graph.value !== "") out += "}\n";
+		this.graph = Option.none();
+		return out;
+	}
+};
+// src/turtle/internal/serialize.ts
+const writerOptions = (syntax, options) => ({
+	trig: syntax.trig,
+	prefixes: Option.fromUndefinedOr(options?.prefixes),
+	baseIri: Option.fromUndefinedOr(options?.baseIri),
+	autoPrefixes: options?.autoPrefixes ?? false,
+	sparqlDirectives: options?.sparqlDirectives ?? false,
+	indent: options?.indent ?? "    "
+});
+/** Maps what a serialisation threw (an `Error` or its string form) to an `RdfSerializeError`. */
+const toSerializeError = (syntax, error) => new RdfSerializeError({
+	format: syntax.name,
+	message: Predicate.isString(error) ? error : error.message
+});
+/** @internal */
+const serialize = (syntax, quads, options) => Effect.try({
+	try: () => new Writer(writerOptions(syntax, options), prepare(quads)).write(),
+	catch: (error) => toSerializeError(syntax, Predicate.isError(error) ? error : String(error))
+}).pipe(withSerializeSpan(Option.getOrUndefined(syntax.trace)));
+/** @internal */
+const serializeStream = (syntax) => (quads, options) => Stream.suspend(() => {
+	const writer = new StreamWriter(writerOptions(syntax, options));
+	const write = (f) => Effect.try({
+		try: f,
+		catch: (error) => toSerializeError(syntax, Predicate.isError(error) ? error : String(error))
+	});
+	return quads.pipe(Stream.chunks, Stream.mapEffect((chunk) => write(() => writer.write(chunk))), Stream.concat(Stream.fromEffect(write(() => writer.end()))), Stream.filter((s) => s !== ""));
+}).pipe(withStreamSpan(Option.getOrUndefined(syntax.trace), "serializeStream"));
+export { parseStream as a, parseQuads as i, serializeStream as n, parse as r, serialize as t };
+
+//# sourceMappingURL=serialize-96KBvKaf.mjs.map