@thomasfosterau/effect-rdf 0.0.0 → 0.1.0

package/dist/N3-BzyV-KIH.mjs

@@ -0,0 +1,974 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { A as escapeString, S as Variable, Y as literal, c as NamedNode, k as escapeIri, t as BlankNode } from "./Term-CFLG1qu4.mjs";
+import { i as rdf, o as xsd } from "./Vocab-DceKywpq.mjs";
+import { l as resolve, s as relativize } from "./Iri-Cr92gsQV.mjs";
+import { i as empty, r as compact, 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 { D as isBlankNode, E as loop, O as isLiteral, j as isVariable, k as isNamedNode, r as Formula, s as Statement, t as Collection, v as isFormula } from "./Model-DlPzRYhF.mjs";
+import { o as toDataset, r as fromDataset } from "./Mapping-Dc1ZGirk.mjs";
+import { d as iriRef$1, g as pnCharsU, i as blankNodeLabel, m as pnChars, n as alpha, p as langTag } from "./Grammar-mQ8CgE1M.mjs";
+import { c as numericLiteral, d as pnPrefix, f as prefixedName, m as stringLiteral, u as pnLocal } from "./Grammar-CPlSxGH6.mjs";
+import { a as log, c as sameAs, r as i18n } from "./Vocab-TfpWG1Ne.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 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/n3/internal/parser.ts
+/**
+* The Notation3 parser: a compiled `@thomasfosterau/effect-parse` grammar
+* over the input string (no separate lexer), built on the Turtle terminals of
+* `/turtle` (`Grammar`), as the N3 grammar is: N3 extends Turtle with
+* formulas, paths, quick variables, `=`, `=>`, `<=`, `has`, `is … of` and the
+* legacy `@forAll` / `@forSome`.
+*
+* The grammar's callbacks build the model as it reads, with no syntax tree:
+* a `Builder` holds what depends on what came before (`@prefix` / `@base`,
+* quantifier scopes, blank node allocation, the open formulas and the
+* subjects being described), and statements are made in document order.
+* Side effects run in `tap`s and zero-width `Parser.make`s, never in a `map`
+* whose value is unused (the compiler skips those). An error the builder
+* finds is kept and reported once the whole document has been read, so a
+* syntax error anywhere takes precedence, as when the model was built from a
+* tree after parsing.
+*
+* @internal
+*/
+/** @internal */
+var SyntaxFailure = class {
+	message;
+	line;
+	column;
+	constructor(message, line, column) {
+		this.message = message;
+		this.line = line;
+		this.column = column;
+	}
+};
+/** @internal */
+const isPnCharsBase = (c) => c >= 65 && c <= 90 || c >= 97 && c <= 122 || c >= 192 && c <= 214 || c >= 216 && c <= 246 || c >= 248 && c <= 767 || c >= 880 && c <= 893 || c >= 895 && c <= 8191 || c >= 8204 && c <= 8205 || c >= 8304 && c <= 8591 || c >= 11264 && c <= 12271 || c >= 12289 && c <= 55295 || c >= 63744 && c <= 64975 || c >= 65008 && c <= 65533 || c >= 65536 && c <= 983039;
+/** @internal */
+const isPnCharsU = (c) => c === 95 || isPnCharsBase(c);
+/** @internal */
+const isPnChars = (c) => isPnCharsU(c) || c === 45 || c >= 48 && c <= 57 || c === 183 || c >= 768 && c <= 879 || c >= 8255 && c <= 8256;
+const fail = (message, at) => Result.fail({
+	message,
+	at
+});
+const WHITESPACE = "whitespace";
+/** Whitespace and `#` comments (which also end at a form feed). */
+const ws = Parser.asVoid(Parser.repeat(Parser.alt(Token.takeWhile(" 	\r\n", { min: 1 }), Parser.preceded(Token.literal("#"), Token.takeTill("\n\r\f"))).pipe(Parser.expected(WHITESPACE))));
+const lit = (s) => Token.literal(s);
+const closeBracket = Parser.cut(Parser.preceded(ws, Token.literal("]"))).pipe(Parser.expected("']'"));
+/** `s` after whitespace. */
+const sym = (s) => Parser.preceded(ws, Token.literal(s));
+/** A character that ends a statement, a list of objects or a formula. */
+const endOf = (chars) => Parser.preceded(ws, Parser.alt(Parser.eof, Parser.peek(Token.oneOf(chars))));
+/** An `@` keyword: `@` followed by letters. */
+const atWord = Parser.taken(Parser.preceded(lit("@"), Token.takeWhile(alpha, { min: 1 })));
+const atKeyword = (word) => atWord.pipe(Parser.filter((w) => w === word));
+/** A `PN_PREFIX` not followed by `:` (a bare word such as `a`, `is`, `true`). */
+const bareWord = Parser.terminated(pnPrefix, Parser.not(lit(":")));
+/**
+* The bare word `w`, checked by its first character before the word is
+* read, so that the names tried as keywords on the way to a path are not
+* each scanned as a word first.
+*/
+const word = (w) => Parser.preceded(Parser.peek(lit(w.slice(0, 1))), bareWord.pipe(Parser.filter((x) => x === w)));
+const forbiddenInIri = /[\u0000- <>"{}|^`\\]/u;
+/** IRIREF (escapes of characters not allowed in IRIs are rejected by the builder). */
+const iriRef = Parser.seq(Parser.location, iriRef$1, Parser.location).pipe(Parser.map(([at, value, end]) => ({
+	_tag: "IriRef",
+	value,
+	at,
+	escaped: end - at - 2 !== value.length
+})));
+const pname = Parser.seq(Parser.location, prefixedName).pipe(Parser.map(([at, { prefix, local }]) => ({
+	_tag: "PName",
+	prefix,
+	local,
+	at
+})));
+/** Records the offset at which a term starts (`b.at`), for its errors. */
+const mark = Parser.make((state) => {
+	b.at = state.pos;
+});
+/** Records the offset at which an IRI reference ends (`b.end`). */
+const markEnd = Parser.make((state) => {
+	b.end = state.pos;
+});
+/** An IRI reference as a term, made without an intermediate `IriNode`. */
+const iriRefTerm = Parser.delimited(mark, iriRef$1, markEnd).pipe(Parser.map((value) => b.namedRef(value)));
+/**
+* A prefixed name as a term: the `PNAME_LN` / `PNAME_NS` that
+* `TurtleGrammar.prefixedName` reads, taken as one slice and split at its
+* first `:` (which `PN_PREFIX` cannot contain).
+*/
+const pnameTerm = Parser.preceded(mark, Parser.taken(Parser.seq(Parser.opt(pnPrefix), lit(":"), Parser.opt(pnLocal)))).pipe(Parser.map((name) => b.namedPName(name)));
+/** `iri`: an IRI reference or a prefixed name. */
+const iri = Parser.alt(iriRef, pname).pipe(Parser.expected("an IRI"));
+const path = Parser.suspend(() => pathDef);
+const pol = Parser.suspend(() => polDef);
+const statementList = (inFormula) => Parser.suspend(() => inFormula ? formulaStatements : documentStatements);
+/** A parser that consumes nothing and runs `f` (on the builder's state). */
+const act = (f) => Parser.make(() => {
+	f();
+});
+const TRUE = literal("true", xsd.boolean);
+const FALSE = literal("false", xsd.boolean);
+/**
+* Where a numeric literal can start: a digit, or `.`, `+` or `-` followed by
+* one. Checking up front (without consuming input) reports errors at a `.`
+* that ends a statement, rather than after it.
+*/
+const numberStart = Parser.make((state) => {
+	const input = state.input;
+	const isDigit = (k) => {
+		const c = input.charCodeAt(k);
+		return c >= 48 && c <= 57;
+	};
+	const c = input.charCodeAt(state.pos);
+	return isDigit(state.pos) || c === 46 && isDigit(state.pos + 1) || (c === 43 || c === 45) && (isDigit(state.pos + 1) || input.charCodeAt(state.pos + 1) === 46 && isDigit(state.pos + 2)) ? void 0 : state.backtrack("Token", expectedNumber);
+});
+const expectedNumber = ["a number"];
+const numeric = Parser.preceded(numberStart, numericLiteral).pipe(Parser.map(([lexical, type]) => literal(lexical, type === "double" ? xsd.double : type === "decimal" ? xsd.decimal : xsd.integer)));
+const noDatatype = Option.none();
+const plainSuffix = {
+	language: "",
+	datatype: noDatatype
+};
+const rdfLiteral = Parser.seq(stringLiteral, Parser.alt(Parser.preceded(Parser.peek(lit("@")), Parser.cut(langTag)).pipe(Parser.map((language) => ({
+	language,
+	datatype: noDatatype
+}))), Parser.preceded(sym("^^"), Parser.cut(Parser.preceded(ws, iri))).pipe(Parser.map((datatype) => ({
+	language: "",
+	datatype: Option.some(datatype)
+}))), Parser.succeed(plainSuffix))).pipe(Parser.map(([value, { language, datatype }]) => b.literal(value, language, datatype)));
+const quickVar = Parser.preceded(lit("?"), Parser.cut(Parser.taken(Parser.seq(Token.oneOf(pnCharsU), Token.takeWhile(pnChars)))).pipe(Parser.expected("a variable name"))).pipe(Parser.map((name) => b.variable(name)));
+const blank = Parser.preceded(Parser.peek(lit("_:")), Parser.cut(blankNodeLabel.pipe(Parser.expected("a blank node label")))).pipe(Parser.map((label) => b.labelledBlank(label)));
+/**
+* `[ … ]`: an anonymous node, or `[ id <iri> … ]`. A new node is made when
+* the bracket opens, before the nodes inside it, as the statements inside
+* are about it.
+*/
+const bracket = Parser.preceded(lit("["), Parser.cut(Parser.alt(sym("]").pipe(Parser.map(() => b.freshBlank())), Parser.preceded(Parser.tap(Parser.preceded(Parser.seq(ws, word("id")), Parser.cut(Parser.preceded(ws, iri))), (id) => b.open(b.named(id))), Parser.cut(Parser.terminated(pol, closeBracket))).pipe(Parser.map(() => b.close())), Parser.preceded(act(() => b.open(b.freshBlank())), Parser.terminated(pol, closeBracket)).pipe(Parser.map(() => b.close())))));
+/** `( … )`: a collection. */
+const collection = Parser.delimited(lit("("), Parser.cut(Parser.repeat(Parser.preceded(Parser.not(sym(")")), path))), Parser.cut(sym(")").pipe(Parser.expected("')'")))).pipe(Parser.map((items) => new Collection(items)));
+/** `{ … }`: a formula; an empty one is the literal `true` (N3 test suite: graph/empty_graph). */
+const formula = Parser.preceded(lit("{"), Parser.cut(Parser.delimited(act(() => b.openFormula()), statementList(true), Parser.cut(sym("}").pipe(Parser.expected("'}'")))))).pipe(Parser.map(() => {
+	const f = b.closeFormula();
+	return f.size === 0 ? TRUE : f;
+}));
+/** A prefixed name, or the bare words `true` and `false`. */
+const TRAILING_DOTS = /\.+$/;
+/** ASCII letters (`PN_CHARS_BASE` below 0x80). */
+const isAsciiLetter = (c) => c >= 97 && c <= 122 || c >= 65 && c <= 90;
+/** ASCII name characters (`PN_CHARS` below 0x80): letters, digits, `_` and `-`. */
+const isAsciiNameChar = (c) => isAsciiLetter(c) || c >= 48 && c <= 57 || c === 95 || c === 45;
+/** The scan in progress: its input and position (one pair of step functions serves every scan). */
+let scanInput = "";
+let scanPos = 0;
+const prefixStep = () => {
+	if (!isAsciiNameChar(scanInput.charCodeAt(scanPos))) return false;
+	scanPos++;
+	return true;
+};
+const localStep = () => {
+	const c = scanInput.charCodeAt(scanPos);
+	if (!isAsciiNameChar(c) && c !== 46 && c !== 58) return false;
+	scanPos++;
+	return true;
+};
+/** Where the run of characters that `step` accepts, from `pos`, ends. */
+const scanTo = (step, input, pos) => {
+	scanInput = input;
+	scanPos = pos;
+	loop(step);
+	return scanPos;
+};
+/**
+* A prefixed name that is plain ASCII, scanned by hand: a prefix of letters,
+* digits, `_` and `-` (or none), `:`, and a local name of those and `:` and
+* `.` (without trailing dots). It backtracks, having changed nothing, at
+* anything else (`.` in the prefix, `%`, `\`, a character from 0x80, no
+* `:`), so that `pnameTerm` reads the name, with the same result.
+*/
+const asciiPName = Parser.make((state) => {
+	const input = state.input;
+	const start = state.pos;
+	const colon = isAsciiLetter(input.charCodeAt(start)) ? scanTo(prefixStep, input, start + 1) : start;
+	if (input.charCodeAt(colon) !== 58) return state.backtrack("Token");
+	const first = input.charCodeAt(colon + 1);
+	const i = first === 45 || first === 46 || !(isAsciiNameChar(first) || first === 58) ? colon + 1 : scanTo(localStep, input, colon + 2);
+	const c = input.charCodeAt(i);
+	if (c === 37 || c === 92 || c >= 128) return state.backtrack("Token");
+	const local = input.charCodeAt(i - 1) === 46 && i > colon + 1 ? input.slice(colon + 1, i).replace(TRAILING_DOTS, "") : input.slice(colon + 1, i);
+	b.at = start;
+	state.pos = colon + 1 + local.length;
+	return b.namedPNameParts(input.slice(start, colon), local);
+});
+const nameItem = Parser.alt(Parser.alt(asciiPName, pnameTerm), Parser.seq(Parser.location, bareWord).pipe(Parser.map(([at, w]) => w === "true" ? TRUE : w === "false" ? FALSE : b.error(`Unexpected keyword or undeclared prefix '${w}'`, at))));
+/**
+* A grammar rule compiled to a function of its own. Formulas, collections and
+* `[ … ]` nest, so the compiled functions on that path recurse; keeping the
+* leaf terms out of them keeps their stack frames small, and the nesting
+* depth the parser supports large.
+*/
+const rule = (p) => Parser.suspend(() => p);
+const leafItem = rule(Parser.alt(iriRefTerm, rdfLiteral, quickVar, atKeyword("@true").pipe(Parser.as(TRUE)), atKeyword("@false").pipe(Parser.as(FALSE)), blank, numeric, nameItem));
+const pathItem = Parser.preceded(ws, Parser.alt(bracket, collection, formula, leafItem).pipe(Parser.expected("a term")));
+/** A path: an item, then `!` (forward) and `^` (backward) steps, each applied as it is read. */
+const pathDef = Parser.preceded(Parser.tap(pathItem, (head) => b.paths.push(head)), Parser.repeat(Parser.preceded(Parser.tap(Parser.preceded(ws, Parser.alt(lit("!"), Parser.terminated(lit("^"), Parser.not(lit("^"))))), (dir) => b.dirs.push(dir)), Parser.tap(Parser.cut(pathItem), (step) => b.step(step))))).pipe(Parser.map(() => b.endPath()));
+const fixedVerb = rule(Parser.alt(lit("=>").pipe(Parser.as(log.implies)), lit("=").pipe(Parser.as(sameAs)), Parser.preceded(Parser.seq(Parser.peek(lit("<=")), Parser.not(iriRef)), lit("<=")).pipe(Parser.as(log.isImpliedBy)), Parser.alt(word("a"), atKeyword("@a")).pipe(Parser.as(rdf.type))));
+/** A verb, which becomes the predicate (and direction) of the objects after it. */
+const verb = Parser.preceded(ws, Parser.asVoid(Parser.alt(Parser.tap(fixedVerb, (predicate) => b.verb(predicate, false)), Parser.tap(Parser.preceded(Parser.seq(Parser.peek(lit("<-")), Parser.not(iriRef), lit("<-")), Parser.cut(path)), (predicate) => b.verb(predicate, true)), Parser.tap(Parser.preceded(Parser.alt(word("has"), atKeyword("@has")), Parser.cut(path)), (predicate) => b.verb(predicate, false)), Parser.preceded(Parser.alt(word("is"), atKeyword("@is")), Parser.cut(Parser.terminated(path, Parser.preceded(ws, Parser.alt(word("of"), atKeyword("@of"))).pipe(Parser.expected("'of' after 'is ...'"))))).pipe(Parser.tap((predicate) => b.verb(predicate, true))), Parser.tap(path, (predicate) => b.verb(predicate, false)))));
+const objectList = Parser.separated(Parser.tap(path, (object) => b.object(object)), sym(","), { min: 1 }).pipe(Parser.expected("an object"));
+const semicolons = Parser.repeat(sym(";"), { min: 1 });
+const polDef = Parser.asVoid(Parser.terminated(Parser.seq(Parser.seq(verb, Parser.cut(objectList)), Parser.repeat(Parser.preceded(semicolons, Parser.preceded(Parser.not(endOf(".]}")), Parser.cut(Parser.seq(verb, objectList)))))), Parser.opt(semicolons)));
+const triples = Parser.preceded(Parser.tap(path, (subject) => b.open(subject)), Parser.alt(Parser.preceded(Parser.peek(endOf(".}")), Parser.succeed(void 0)), pol)).pipe(Parser.tap(() => void b.close()));
+/** The body of `@prefix` / `PREFIX`: `PN_PREFIX? ':' IRIREF`. */
+const prefixBody = Parser.asVoid(Parser.seq(Parser.preceded(ws, Parser.terminated(Parser.opt(pnPrefix), lit(":").pipe(Parser.expected("a prefix name ending in \":\"")))), Parser.preceded(ws, iriRef)).pipe(Parser.tap(([prefix, ref]) => b.prefix(Option.getOrElse(prefix, () => ""), ref))));
+const baseBody = Parser.asVoid(Parser.preceded(ws, iriRef).pipe(Parser.tap((ref) => {
+	b.base = Option.some(b.iri(ref));
+})));
+const quantifier = (universal) => Parser.alt(Parser.preceded(Parser.peek(endOf(".}")), Parser.succeed([])), Parser.separated(Parser.preceded(ws, iri), sym(","), { min: 1 })).pipe(Parser.tap((iris) => b.quantify(universal, iris)), Parser.asVoid);
+/** `PREFIX` / `BASE` (case-insensitive, no trailing `.`). */
+const sparqlDirective = rule(Parser.preceded(ws, Parser.alt(Parser.preceded(Parser.terminated(Ascii.caseless("PREFIX"), Parser.not(Token.oneOf([":.", pnChars]))), Parser.cut(prefixBody)), Parser.preceded(Parser.terminated(Ascii.caseless("BASE"), Parser.not(Token.oneOf([":.", pnChars]))), Parser.cut(baseBody)))));
+const atDirective = rule(Parser.alt(Parser.preceded(atKeyword("@prefix"), Parser.cut(prefixBody)), Parser.preceded(atKeyword("@base"), Parser.cut(baseBody)), Parser.preceded(atKeyword("@forAll"), Parser.cut(quantifier(true))), Parser.preceded(atKeyword("@forSome"), Parser.cut(quantifier(false))), Parser.preceded(Parser.peek(atKeyword("@keywords")), Parser.cut(Parser.location.pipe(Parser.tryMap((at) => fail("@keywords is not supported by Notation3", at)))))));
+const statement = Parser.preceded(ws, Parser.alt(atDirective, triples));
+/** Statements, each ended by `.` (optional before the `}` of a formula). */
+const statements = (inFormula) => Parser.asVoid(Parser.repeat(Parser.preceded(Parser.not(inFormula ? endOf("}") : Parser.preceded(ws, Parser.eof)), Parser.alt(sparqlDirective, Parser.cut(Parser.terminated(statement, (inFormula ? Parser.alt(sym("."), Parser.peek(sym("}"))) : sym(".")).pipe(Parser.expected("'.'"))))))));
+const formulaStatements = statements(true);
+const documentStatements = statements(false);
+const document = Compiler.jit(Parser.terminated(documentStatements, Parser.preceded(ws, Parser.eof)));
+const PN_LOCAL_ESC = /\\(.)/gu;
+const I18N_DATATYPE = /^([a-zA-Z]+(?:-[a-zA-Z0-9]+)*)_(ltr|rtl)$/;
+/** The subject whose statements are being read, with the predicate and direction in force. */
+var Frame = class {
+	subject = rdf.nil;
+	predicate = rdf.nil;
+	inverse = false;
+};
+/**
+* What depends on the document so far (prefixes, the base IRI, blank node
+* labels and counters, quantifier scopes, the open formulas and subjects),
+* updated by the grammar's callbacks as it reads, so that statements are
+* made in document order without a syntax tree. An error found here is
+* kept and reported once the grammar has read the whole document, so that a
+* syntax error anywhere comes first.
+*/
+var Builder = class {
+	prefixes = MutableHashMap.empty();
+	base;
+	bnodePrefix;
+	bnodes = MutableHashMap.empty();
+	/** The blank node labels written in the document (as keys). */
+	reserved = MutableHashMap.empty();
+	anonCounter = 0;
+	/** Statement collectors, one per open formula (innermost last). */
+	out = [];
+	/**
+	* Explicit quantifier scopes (legacy `@forAll` / `@forSome`), innermost
+	* last, each with the depth of the formula it belongs to: only formulas
+	* that quantify something have one, so a document without quantifiers
+	* looks nothing up.
+	*/
+	scopes = [];
+	/** How many formulas are open. */
+	depth = 0;
+	/**
+	* The variables made so far, by name: quick variables (one node per name,
+	* so that the copies of a rule compare by identity when a formula removes
+	* duplicate statements) and those made for `@forAll`, whose names avoid
+	* these.
+	*/
+	variables = MutableHashMap.empty();
+	/** The subjects being described, innermost last (`depthOfFrames` of them are in use). */
+	frames = [];
+	openFrames = 0;
+	/** The items of the paths being read, and the directions of their steps, innermost last. */
+	paths = [];
+	dirs = [];
+	/** Where the term being read starts, and (for an IRI reference) ends. */
+	at = 0;
+	end = 0;
+	/** The first error found (none while it is empty). */
+	errors = [];
+	input;
+	constructor(input, options) {
+		this.input = input;
+		this.base = options.baseIri;
+		this.bnodePrefix = options.blankNodePrefix;
+		Iterable.forEach(input.matchAll(/_:([^\s<>"{}()[\],;^!]+)/g), ([, label]) => {
+			MutableHashMap.set(this.reserved, `${this.bnodePrefix}${label ?? ""}`, true);
+		});
+	}
+	/** Keeps the first error, returning a stand-in term so that reading can go on. */
+	error(message, at) {
+		if (Arr.isReadonlyArrayEmpty(this.errors)) this.errors.push({
+			message,
+			at
+		});
+		return rdf.nil;
+	}
+	openFormula() {
+		this.out.push([]);
+		this.depth++;
+	}
+	closeFormula() {
+		if (this.scopes.at(-1)?.[0] === this.depth) this.scopes.pop();
+		this.depth--;
+		return new Formula(this.out.pop() ?? []);
+	}
+	/** Starts describing `subject` (a statement's subject, or the node of a `[ … ]`). */
+	open(subject) {
+		const frame = this.frames[this.openFrames++] ??= new Frame();
+		frame.subject = subject;
+		frame.predicate = rdf.nil;
+		frame.inverse = false;
+	}
+	/** Stops describing the current subject, returning it. */
+	close() {
+		const frame = this.frames[--this.openFrames];
+		return frame === void 0 ? rdf.nil : frame.subject;
+	}
+	verb(predicate, inverse) {
+		const frame = this.frames[this.openFrames - 1];
+		if (frame === void 0) return;
+		frame.predicate = predicate;
+		frame.inverse = inverse;
+	}
+	/** A statement about the current subject, with the current predicate, of `object`. */
+	object(object) {
+		const frame = this.frames[this.openFrames - 1];
+		if (frame === void 0) return;
+		if (frame.inverse) this.emit(object, frame.predicate, frame.subject);
+		else this.emit(frame.subject, frame.predicate, object);
+	}
+	/** A `!` or `^` step from the current path's item to a new blank node, which replaces it. */
+	step(predicate) {
+		const dir = this.dirs.pop();
+		const item = this.paths.pop() ?? rdf.nil;
+		const node = this.freshBlank();
+		if (dir === "!") this.emit(item, predicate, node);
+		else this.emit(node, predicate, item);
+		this.paths.push(node);
+	}
+	endPath() {
+		return this.paths.pop() ?? rdf.nil;
+	}
+	prefix(prefix, ref) {
+		MutableHashMap.set(this.prefixes, prefix, this.iri(ref));
+	}
+	quantify(universal, iris) {
+		const scope = this.scope();
+		iris.forEach((node) => {
+			const quantified = this.iri(node);
+			MutableHashMap.set(scope, quantified, universal ? this.variableFor(quantified) : this.freshBlank());
+		});
+	}
+	variable(name) {
+		const known = this.variables.backing.get(name);
+		if (known !== void 0) return known;
+		const node = new Variable(name);
+		MutableHashMap.set(this.variables, name, node);
+		return node;
+	}
+	/** A literal: with `language` unless it is `''`, else of `datatype` if there is one. */
+	literal(value, language, datatype) {
+		if (language !== "") return literal(value, language);
+		if (Option.isNone(datatype)) return literal(value);
+		const type = this.iri(datatype.value);
+		const dir = type.startsWith(i18n.base) ? I18N_DATATYPE.exec(type.slice(i18n.base.length)) : null;
+		if (dir !== null) return literal(value, {
+			language: dir[1] ?? "",
+			direction: dir[2] === "rtl" ? "rtl" : "ltr"
+		});
+		return literal(value, new NamedNode(type));
+	}
+	iri(node) {
+		if (Predicate.isTagged(node, "IriRef")) {
+			if (node.escaped && forbiddenInIri.test(node.value)) {
+				this.error("Invalid escaped character in IRI", node.at);
+				return node.value;
+			}
+			return this.resolveIri(node.value);
+		}
+		const ns = this.prefixes.backing.get(node.prefix);
+		if (ns !== void 0) return ns + node.local;
+		if (node.prefix === "") return this.resolveIri("#") + node.local;
+		this.error(`Undeclared prefix '${node.prefix}:'`, node.at);
+		return node.local;
+	}
+	resolveIri(value) {
+		return Option.isNone(this.base) ? value : resolve(value, this.base.value);
+	}
+	/** The quantifier scope of the innermost formula, made on first use. */
+	scope() {
+		const top = this.scopes.at(-1);
+		if (top !== void 0 && top[0] === this.depth) return top[1];
+		const scope = MutableHashMap.empty();
+		this.scopes.push([this.depth, scope]);
+		return scope;
+	}
+	/**
+	* The nodes made so far, by IRI and (for prefixed names) by namespace and
+	* local name, so that a name written again is neither concatenated nor
+	* hashed anew, and each IRI's key (which formulas deduplicate by) is
+	* computed once.
+	*/
+	iriNodes = MutableHashMap.empty();
+	localNodes = MutableHashMap.empty();
+	/** The term an IRI reference read at `at`…`end` stands for. */
+	namedRef(value) {
+		if (this.end - this.at - 2 !== value.length && forbiddenInIri.test(value)) return this.error("Invalid escaped character in IRI", this.at);
+		return this.scoped(this.iriNodeOf(this.resolveIri(value)));
+	}
+	/** The term a prefixed name read at `at` stands for. */
+	namedPName(name) {
+		const colon = name.indexOf(":");
+		const raw = name.slice(colon + 1);
+		return this.namedPNameParts(name.slice(0, colon), raw.includes("\\") ? raw.replace(PN_LOCAL_ESC, "$1") : raw);
+	}
+	/** The term of a prefixed name read at `at`, given its prefix and decoded local name. */
+	namedPNameParts(prefix, local) {
+		const ns = this.prefixes.backing.get(prefix);
+		if (ns !== void 0) return this.scoped(this.localNode(ns, local));
+		return this.named({
+			_tag: "PName",
+			prefix,
+			local,
+			at: this.at
+		});
+	}
+	/** The term an IRI as written stands for: its node, or a quantified variable or blank node. */
+	named(node) {
+		return this.scoped(this.iriNode(node));
+	}
+	/** `named`, or the variable or blank node it is quantified as. */
+	scoped(named) {
+		if (Arr.isReadonlyArrayEmpty(this.scopes)) return named;
+		return this.scopes.findLast(([, quantified]) => MutableHashMap.has(quantified, named.value))?.[1].backing.get(named.value) ?? named;
+	}
+	iriNode(node) {
+		if (Predicate.isTagged(node, "PName")) {
+			const ns = this.prefixes.backing.get(node.prefix);
+			if (ns !== void 0) return this.localNode(ns, node.local);
+		}
+		return this.iriNodeOf(this.iri(node));
+	}
+	iriNodeOf(value) {
+		const known = this.iriNodes.backing.get(value);
+		if (known !== void 0) return known;
+		const named = new NamedNode(value);
+		MutableHashMap.set(this.iriNodes, value, named);
+		return named;
+	}
+	/** The node of `ns` + `local`, by local name and then namespace (a local name rarely has two). */
+	localNode(ns, local) {
+		let byNamespace = this.localNodes.backing.get(local);
+		if (byNamespace === void 0) {
+			byNamespace = [];
+			MutableHashMap.set(this.localNodes, local, byNamespace);
+		}
+		const known = byNamespace.find(([namespace]) => namespace === ns);
+		if (known !== void 0) return known[1];
+		const named = new NamedNode(ns + local);
+		byNamespace.push([ns, named]);
+		return named;
+	}
+	emit(subject, predicate, object) {
+		this.out.at(-1)?.push(new Statement(subject, predicate, object));
+	}
+	freshBlank() {
+		const label = this.freshLabel();
+		return new BlankNode(this.reserved.backing.has(label) ? this.freeLabel() : label);
+	}
+	freshLabel() {
+		return `${this.bnodePrefix}b${(this.anonCounter++).toString(36)}`;
+	}
+	/** The next generated label that the document does not use. */
+	freeLabel() {
+		let label = this.freshLabel();
+		loop(() => {
+			if (!this.reserved.backing.has(label)) return false;
+			label = this.freshLabel();
+			return true;
+		});
+		return label;
+	}
+	labelledBlank(label) {
+		const known = this.bnodes.backing.get(label);
+		if (known !== void 0) return known;
+		const node = new BlankNode(`${this.bnodePrefix}${label}`);
+		MutableHashMap.set(this.bnodes, label, node);
+		return node;
+	}
+	variableFor(quantified) {
+		const local = /[^#/:]*$/.exec(quantified)?.[0] ?? "";
+		const base = /^[A-Za-z_][A-Za-z0-9_]*$/.test(local) ? local : "v";
+		let name = base;
+		if (MutableHashMap.has(this.variables, base)) loop((i) => {
+			name = `${base}_${i + 1}`;
+			return MutableHashMap.has(this.variables, name);
+		});
+		const node = new Variable(name);
+		MutableHashMap.set(this.variables, name, node);
+		return node;
+	}
+};
+/** The builder of the document being parsed (the grammar's callbacks update it). */
+let b = new Builder("", {
+	baseIri: Option.none(),
+	blankNodePrefix: ""
+});
+const failAt = (input, message, at) => {
+	const end = Math.min(at, input.length);
+	const lines = input.slice(0, end).split("\n");
+	const column = (lines.at(-1) ?? "").length + 1;
+	throw new SyntaxFailure(message, lines.length, column);
+};
+const describe = (input, at) => at >= input.length ? "end of input" : `'${String.fromCodePoint(input.codePointAt(at) ?? 0)}'`;
+/** @internal */
+const parse$1 = (input, options) => {
+	b = new Builder(input, options);
+	b.openFormula();
+	const result = Parser.parse(document, input);
+	if (Result.isFailure(result)) {
+		const error = result.failure;
+		if (error.cause !== void 0) return failAt(input, error.cause.message, error.cause.at);
+		const found = describe(input, error.offset);
+		const expected = error.expected.filter((e) => e !== WHITESPACE);
+		const message = Arr.isReadonlyArrayEmpty(expected) || expected.length > 3 ? `Unexpected ${found}` : `Expected ${expected.join(" or ")} but found ${found}`;
+		return failAt(input, message, error.offset);
+	}
+	const error = b.errors.at(0);
+	if (error !== void 0) return failAt(input, error.message, error.at);
+	return {
+		formula: b.closeFormula(),
+		prefixes: make(b.prefixes),
+		baseIri: Option.getOrUndefined(b.base)
+	};
+};
+// src/n3/internal/writer.ts
+/**
+* Pretty-printer for the N3 model.
+*
+* @internal
+*/
+/** Whether a string is a valid `PN_PREFIX` (or empty). */
+const isPnPrefix = (s) => {
+	const cps = Array.from(s, codePoint);
+	if (!Arr.isReadonlyArrayNonEmpty(cps)) return true;
+	if (!isPnCharsBase(cps[0])) return false;
+	if (cps.length > 1 && cps[cps.length - 1] === 46) return false;
+	return cps.slice(1).every((c) => c === 46 || isPnChars(c));
+};
+/** The code point of a character (as `Array.from` splits a string). */
+const codePoint = (ch) => ch.codePointAt(0) ?? 0;
+/** Whether a string is a valid quick variable name (without `?`). */
+const isVarName = (s) => {
+	const cps = Array.from(s, codePoint);
+	return Arr.isReadonlyArrayNonEmpty(cps) && isPnCharsU(cps[0]) && cps.slice(1).every(isPnChars);
+};
+const BLANK_LABEL = /^[A-Za-z0-9_](?:[\w.-]*[\w-])?$/;
+const INTEGER = /^[+-]?\d+$/;
+const DECIMAL = /^[+-]?\d*\.\d+$/;
+const DOUBLE = /^[+-]?(?:\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+$/;
+/** @internal */
+const write = (root, options) => new Writer(root, options).run();
+var Writer = class {
+	prefixes;
+	base;
+	unit;
+	usedPrefixes = MutableHashSet.empty();
+	blanks = MutableHashMap.empty();
+	blankLabels = MutableHashMap.empty();
+	usedLabels = MutableHashSet.empty();
+	varNames = MutableHashMap.empty();
+	/** Subject groups of inlinable blank nodes, per formula. */
+	inlineGroups = MutableHashMap.empty();
+	inlinable = MutableHashSet.empty();
+	emitted = MutableHashSet.empty();
+	root;
+	constructor(root, options) {
+		this.root = root;
+		this.prefixes = options.prefixes;
+		this.base = options.baseIri;
+		this.unit = options.indent;
+	}
+	run() {
+		this.analyse(this.root);
+		MutableHashMap.forEach(this.blanks, (info, label) => {
+			if (!info.predicate && info.refs <= 1 && !info.shared) MutableHashSet.add(this.inlinable, label);
+		});
+		const body = this.formulaBody(this.root, 0);
+		const base = Option.match(this.base, {
+			onNone: () => "",
+			onSome: (iri) => `@base <${escapeIri(iri)}> .\n`
+		});
+		const header = Arr.reduce(Arr.fromIterable(this.prefixes.prefixes), base, (acc, [prefix, ns]) => MutableHashSet.has(this.usedPrefixes, prefix) ? `${acc}@prefix ${prefix}: <${escapeIri(ns)}> .\n` : acc);
+		return header === "" ? body : `${header}\n${body}`;
+	}
+	/** The blank node's information, made (in `f`) on first sight. */
+	info(label, f) {
+		const known = this.blanks.backing.get(label);
+		if (known !== void 0) {
+			if (known.formula !== f) known.shared = true;
+			return known;
+		}
+		const info = {
+			refs: 0,
+			predicate: false,
+			formula: f,
+			shared: false
+		};
+		MutableHashMap.set(this.blanks, label, info);
+		return info;
+	}
+	analyse(f) {
+		f.statements.forEach((s) => {
+			this.analyseTerm(s.subject, f, "subject");
+			this.analyseTerm(s.predicate, f, "predicate");
+			this.analyseTerm(s.object, f, "object");
+		});
+	}
+	analyseTerm(t, f, position) {
+		if (isBlankNode(t)) {
+			const info = this.info(t.value, f);
+			if (position === "predicate") info.predicate = true;
+			else if (position !== "subject") info.refs++;
+		} else if (t instanceof Collection) t.items.forEach((item) => this.analyseTerm(item, f, "item"));
+		else if (t instanceof Formula) this.analyse(t);
+	}
+	/** Whether `subject` is an inlinable blank node. */
+	isInlinable(subject) {
+		return isBlankNode(subject) && MutableHashSet.has(this.inlinable, subject.value);
+	}
+	formulaBody(f, depth) {
+		const groups = MutableHashMap.empty();
+		f.statements.forEach((s) => {
+			const k = s.subject.key;
+			let g = groups.backing.get(k);
+			if (g === void 0) {
+				g = {
+					first: s,
+					statements: [s]
+				};
+				MutableHashMap.set(groups, k, g);
+			} else g.statements.push(s);
+			if (this.isInlinable(s.subject)) MutableHashMap.set(this.inlineGroups, s.subject.value, g.statements);
+		});
+		const pad = this.unit.repeat(depth);
+		const lines = [];
+		const render = (g) => {
+			const subject = g.first.subject;
+			if (this.isInlinable(subject)) {
+				MutableHashSet.add(this.emitted, subject.value);
+				lines.push(`${pad}[ ${this.predicateObjects(g.statements, depth + 1, ` ;\n${pad}${this.unit}`)} ] .`);
+				return;
+			}
+			const subj = this.term(subject, depth);
+			lines.push(`${pad}${subj} ${this.predicateObjects(g.statements, depth, ` ;\n${pad}${this.unit}`)} .`);
+		};
+		const deferred = [];
+		MutableHashMap.forEach(groups, (g) => {
+			const subject = g.first.subject;
+			if (this.isInlinable(subject) && this.blanks.backing.get(subject.value)?.refs === 1) {
+				deferred.push(g);
+				return;
+			}
+			render(g);
+		});
+		deferred.forEach((g) => {
+			const subject = g.first.subject;
+			if (!isBlankNode(subject) || MutableHashSet.has(this.emitted, subject.value)) return;
+			MutableHashSet.remove(this.inlinable, subject.value);
+			render(g);
+		});
+		return lines.join("\n") + (Arr.isReadonlyArrayNonEmpty(lines) ? "\n" : "");
+	}
+	predicateObjects(statements, depth, separator) {
+		const byPredicate = MutableHashMap.empty();
+		statements.forEach((s) => {
+			const k = s.predicate.key;
+			const e = byPredicate.backing.get(k);
+			if (e === void 0) MutableHashMap.set(byPredicate, k, {
+				predicate: s.predicate,
+				objects: [s.object]
+			});
+			else e.objects.push(s.object);
+		});
+		return Arr.map(Arr.fromIterable(MutableHashMap.values(byPredicate)), ({ predicate, objects }) => `${this.verb(predicate, depth)} ${objects.map((o) => this.term(o, depth)).join(", ")}`).join(separator);
+	}
+	verb(t, depth) {
+		if (isNamedNode(t)) {
+			if (t.value === rdf.type.value) return "a";
+			if (t.value === log.implies.value) return "=>";
+			if (t.value === log.isImpliedBy.value) return "<=";
+			if (t.value === sameAs.value) return "=";
+		}
+		return this.term(t, depth);
+	}
+	term(t, depth) {
+		if (isNamedNode(t)) return this.iri(t.value);
+		if (isBlankNode(t)) return this.blank(t, depth);
+		if (isLiteral(t)) return this.literal(t);
+		if (isVariable(t)) return this.variable(t);
+		if (t instanceof Collection) return Arr.isReadonlyArrayEmpty(t.items) ? "()" : `( ${t.items.map((i) => this.term(i, depth)).join(" ")} )`;
+		return this.formula(t, depth);
+	}
+	formula(f, depth) {
+		if (Arr.isReadonlyArrayEmpty(f.statements)) return "{}";
+		const inner = this.formulaBody(f, depth + 1);
+		if (f.statements.length === 1) {
+			const line = inner.trim();
+			if (!line.includes("\n") && line.length <= 80) return `{ ${line.replace(/ \.$/, "")} }`;
+		}
+		return `{\n${inner}${this.unit.repeat(depth)}}`;
+	}
+	blank(b, depth) {
+		if (MutableHashSet.has(this.inlinable, b.value) && !MutableHashSet.has(this.emitted, b.value)) {
+			MutableHashSet.add(this.emitted, b.value);
+			const g = this.inlineGroups.backing.get(b.value);
+			if (g === void 0 || Arr.isReadonlyArrayEmpty(g)) return "[]";
+			const pad = this.unit.repeat(depth + 1);
+			return `[ ${this.predicateObjects(g, depth + 1, ` ;\n${pad}`)} ]`;
+		}
+		const known = this.blankLabels.backing.get(b.value);
+		if (known !== void 0) return `_:${known}`;
+		let label = BLANK_LABEL.test(b.value) ? b.value : `b${MutableHashMap.size(this.blankLabels)}`;
+		loop(() => {
+			if (!MutableHashSet.has(this.usedLabels, label)) return false;
+			label = `${label}_`;
+			return true;
+		});
+		MutableHashSet.add(this.usedLabels, label);
+		MutableHashMap.set(this.blankLabels, b.value, label);
+		return `_:${label}`;
+	}
+	variable(v) {
+		const known = this.varNames.backing.get(v.value);
+		if (known !== void 0) return `?${known}`;
+		const name = isVarName(v.value) ? v.value : `v${MutableHashMap.size(this.varNames)}`;
+		MutableHashMap.set(this.varNames, v.value, name);
+		return `?${name}`;
+	}
+	iri(value) {
+		const compact$1 = compact(this.prefixes, value);
+		if (Option.isSome(compact$1) && isPnPrefix(compact$1.value[0])) {
+			const [prefix, local] = compact$1.value;
+			if (!local.endsWith(".")) {
+				MutableHashSet.add(this.usedPrefixes, prefix);
+				return `${prefix}:${local}`;
+			}
+		}
+		if (Option.isSome(this.base)) {
+			const rel = relativize(value, this.base.value);
+			if (Option.isSome(rel)) return `<${escapeIri(rel.value)}>`;
+		}
+		return `<${escapeIri(value)}>`;
+	}
+	literal(l) {
+		const dt = l.datatype.value;
+		if (l.language === "") {
+			if (dt === xsd.integer.value && INTEGER.test(l.value)) return l.value;
+			if (dt === xsd.decimal.value && DECIMAL.test(l.value)) return l.value;
+			if (dt === xsd.double.value && DOUBLE.test(l.value)) return l.value;
+			if (dt === xsd.boolean.value && (l.value === "true" || l.value === "false")) return l.value;
+		}
+		const quoted = this.quote(l.value);
+		if (l.language !== "") return l.direction === void 0 ? `${quoted}@${l.language}` : `${quoted}^^${this.iri(`${i18n.base}${l.language}_${l.direction}`)}`;
+		if (dt === "http://www.w3.org/2001/XMLSchema#string") return quoted;
+		return `${quoted}^^${this.iri(dt)}`;
+	}
+	quote(value) {
+		if (value.includes("\n") && !value.endsWith("\"")) return `"""${value.replace(/[\\"\u0000-\u0009\u000b-\u001f\u007f]/g, (ch) => ch === "\\" || ch === "\"" ? `\\${ch}` : escapeString(ch))}"""`;
+		return `"${escapeString(value)}"`;
+	}
+};
+// src/n3/N3.ts
+/**
+* Notation3 (N3) parsing and serialisation.
+*
+* - `parse` parses an N3 document into the full N3 model (`Model.Document`),
+*   including formulas, variables, collections and literals in any position.
+* - `serializeDocument` pretty-prints the N3 model.
+* - `parser`, `serializer` and `codec` implement the core
+*   `Serialization.Parser` / `Serializer` / `Codec` interfaces over RDF
+*   `Dataset`s, using the mapping documented in the `Mapping` module:
+*   formulas become named graphs identified by blank nodes, and collections
+*   become `rdf:first`/`rdf:rest` lists. Documents outside the RDF-compatible
+*   subset (variables, literal subjects, non-IRI predicates) fail with
+*   `RdfParseError`.
+*
+* Syntax notes (current W3C CG specification and test suite):
+*
+* - Supports `@prefix`/`@base`, SPARQL `PREFIX`/`BASE`, formulas, quick
+*   variables, paths (`!`, `^`), `a`, `has`, `is … of`, `<-`, `=`, `=>`,
+*   `<=`, IRI property lists (`[ id <iri> … ]`), and the `@`-prefixed
+*   keyword forms. The legacy explicit quantifiers `@forAll` (mapped to
+*   variables) and `@forSome` (mapped to fresh blank nodes) are accepted;
+*   `@keywords` is rejected.
+* - `<=` is `log:isImpliedBy`; `=` is `owl:sameAs`.
+* - An empty formula `{}` denotes the literal `true`.
+* - The empty prefix `:` defaults to `<#>` (relative to the base) when not
+*   declared.
+* - Blank node labels are scoped to the whole document.
+* - `"…"^^i18n:{lang}_{dir}` is read as a directional language-tagged
+*   string.
+*
+* @since 0.1.0
+*/
+var N3_exports = /* @__PURE__ */ __exportAll({
+	codec: () => codec,
+	format: () => format,
+	parse: () => parse,
+	parseDataset: () => parseDataset,
+	parser: () => parser,
+	serialize: () => serialize,
+	serializeDocument: () => serializeDocument,
+	serializer: () => serializer
+});
+/**
+* The N3 format descriptor (`text/n3`, `.n3`).
+*
+* N3 can only represent named graphs that are named by blank nodes used as
+* terms (formulas), so `datasets` is `false`.
+*
+* @since 0.1.0
+* @category formats
+*/
+const format = makeFormat({
+	name: "N3",
+	mediaType: "text/n3",
+	mediaTypes: [
+		"text/n3",
+		"text/rdf+n3",
+		"application/n3"
+	],
+	extensions: ["n3"],
+	datasets: false
+});
+const trace = {
+	module: "N3",
+	format
+};
+const runParser = (input, options) => Effect.sync(() => parse$1(input, {
+	baseIri: Option.fromUndefinedOr(options?.baseIri),
+	blankNodePrefix: options?.blankNodePrefix ?? freshBlankNodePrefix()
+})).pipe(Effect.catchDefect((e) => e instanceof SyntaxFailure ? Effect.fail(new RdfParseError({
+	format: format.name,
+	message: e.message,
+	line: e.line,
+	column: e.column
+})) : Effect.die(e)));
+/**
+* Parses an N3 document into the full N3 model.
+*
+* @example
+* ```ts
+* import { Effect } from 'effect'
+* import { N3 } from '@thomasfosterau/effect-rdf/n3'
+*
+* const doc = Effect.runSync(N3.parse('@prefix : <http://example.org/> . { ?x a :Man } => { ?x a :Mortal } .'))
+* doc.formula.statements.length // 1
+* ```
+*
+* @since 0.1.0
+* @category parsing
+*/
+const parse = Effect.fn("N3.parse")(function* (input, options) {
+	yield* Effect.annotateCurrentSpan({
+		"rdf.format": format.name,
+		"rdf.media_type": format.mediaType,
+		"rdf.input.length": input.length
+	});
+	const doc = yield* runParser(input, options);
+	yield* Effect.annotateCurrentSpan("n3.statements", doc.formula.size);
+	return doc;
+});
+/**
+* Parses an N3 document in the RDF-compatible subset into a core dataset
+* (see `Mapping.toDataset`).
+*
+* @since 0.1.0
+* @category parsing
+*/
+const parseDataset = (input, options) => Effect.flatMap(runParser(input, options), (doc) => Effect.suspend(() => {
+	const prefix = options?.blankNodePrefix ?? freshBlankNodePrefix();
+	return toDataset(doc, { blankNodePrefix: prefix }).pipe(Effect.mapError((e) => new RdfParseError({
+		format: format.name,
+		message: e.message
+	})), Effect.map((dataset) => ({
+		dataset,
+		prefixes: doc.prefixes,
+		baseIri: doc.baseIri
+	})));
+})).pipe(withParseSpan(trace, input, "parseDataset"));
+/**
+* The N3 `Serialization.Parser`, producing core datasets.
+*
+* @since 0.1.0
+* @category parsing
+*/
+const parser = makeParser({
+	format,
+	parse: parseDataset
+});
+/**
+* Serialises an N3 formula or document. Prefixes from the options (or, for
+* a document, the document's own prefixes) are used to abbreviate IRIs, and
+* only the prefixes actually used are declared.
+*
+* @since 0.1.0
+* @category serializing
+*/
+const serializeDocument = (self, options) => {
+	const isFormula$1 = isFormula(self);
+	return write(isFormula$1 ? self : self.formula, {
+		prefixes: options?.prefixes ?? (isFormula$1 ? empty : self.prefixes),
+		baseIri: Option.fromUndefinedOr(options?.baseIri ?? (isFormula$1 ? void 0 : self.baseIri)),
+		indent: options?.indent ?? "    "
+	});
+};
+/**
+* Serialises RDF quads as N3. Graphs named by blank nodes that are used as
+* terms are written as nested formulas, and well-formed RDF lists as
+* collections; other named graphs cannot be represented and fail with
+* `RdfSerializeError`.
+*
+* @since 0.1.0
+* @category serializing
+*/
+const serialize = (quads, options) => fromDataset(quads).pipe(Effect.map((f) => serializeDocument(f, options)), Effect.mapError((e) => new RdfSerializeError({
+	format: format.name,
+	message: e.message
+})), withSerializeSpan(trace));
+/**
+* The N3 `Serialization.Serializer` for core datasets.
+*
+* @since 0.1.0
+* @category serializing
+*/
+const serializer = makeSerializer({
+	format,
+	serialize
+});
+/**
+* The N3 `Serialization.Codec` (parser + serializer over core datasets).
+*
+* @since 0.1.0
+* @category codecs
+*/
+const codec = makeCodec(parser, serializer);
+export { parseDataset as a, serializeDocument as c, parse as i, serializer as l, codec as n, parser as o, format as r, serialize as s, N3_exports as t };
+
+//# sourceMappingURL=N3-BzyV-KIH.mjs.map