@thomasfosterau/effect-rdf 0.0.0 → 0.1.0

package/dist/RdfJson-BNocgW4f.mjs

@@ -0,0 +1,548 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { B as isNamedNode, K as isTriple, O as defaultGraph, P as isDefaultGraph, Y as literal, c as NamedNode, d as Quad, t as BlankNode, u as Order$1, y as Triple } from "./Term-CFLG1qu4.mjs";
+import { D as mutate, c as empty, t as DatasetSchema } from "./Dataset-BlmlcI7J.mjs";
+import { i as empty$1 } from "./PrefixMap-BHFPDLO-.mjs";
+import { C as withParseSpan, c as makeCodec, d as makeSerializer, l as makeFormat, n as RdfParseError, o as freshBlankNodePrefix, r as RdfSerializeError, u as makeParser, w as withSerializeSpan } from "./Serialization-DP9H5bYQ.mjs";
+import * as Arr from "effect/Array";
+import { constVoid } from "effect/Function";
+import * as Iterable from "effect/Iterable";
+import * as MutableHashSet from "effect/MutableHashSet";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import * as SchemaTransformation from "effect/SchemaTransformation";
+import * as Effect from "effect/Effect";
+import * as Match from "effect/Match";
+import * as Order from "effect/Order";
+import * as SchemaIssue from "effect/SchemaIssue";
+import * as Record from "effect/Record";
+import * as Result from "effect/Result";
+// src/rdfjson/internal/json.ts
+/**
+* The one `JSON.parse` call of this package. It stays native because the
+* engine's `SyntaxError` text is part of the parse error messages, and
+* `Schema.fromJsonString` replaces it with a generic issue.
+*
+* @internal
+*/
+/**
+* Parses JSON text, failing with the engine's `SyntaxError`.
+*
+* @internal
+*/
+const parseJson = (text) => Result.try({
+	try: () => JSON.parse(text),
+	catch: (e) => e instanceof SyntaxError ? e : new SyntaxError(String(e))
+});
+// src/rdfjson/RdfJson.ts
+/**
+* RDF/JSON (https://www.w3.org/TR/rdf-json/), media type
+* `application/rdf+json`.
+*
+* The document structure is described with Effect `Schema`s, so decoding
+* validates the JSON shape and reports precise errors. `RdfJsonFromString`
+* decodes JSON text into a typed `Document`, and `DatasetFromRdfJson` /
+* `DatasetFromString` transform documents into core `Dataset`s and back.
+*
+* ## RDF 1.2 extensions
+*
+* RDF/JSON predates RDF 1.2. This module defines two backwards-compatible
+* extensions, accepted when parsing by default and written only when
+* `extensions: true` is passed to the serializer:
+*
+* - **Base direction**: a literal object with a `"lang"` may carry
+*   `"direction": "ltr" | "rtl"`, denoting a directional language-tagged
+*   string (`rdf:dirLangString`).
+* - **Triple terms**: an object value `{ "type": "triple", "value": { … } }`
+*   whose `value` has `"subject"` (a `uri` or `bnode` value), `"predicate"`
+*   (a `uri` value) and `"object"` (any object value, including another
+*   triple term) members.
+*
+* ```json
+* {
+*   "http://example.org/s": {
+*     "http://example.org/says": [
+*       { "type": "literal", "value": "שלום", "lang": "he", "direction": "rtl" },
+*       { "type": "triple", "value": {
+*           "subject": { "type": "uri", "value": "http://example.org/a" },
+*           "predicate": { "type": "uri", "value": "http://example.org/b" },
+*           "object": { "type": "literal", "value": "c" } } }
+*     ]
+*   }
+* }
+* ```
+*
+* RDF/JSON describes a single graph: serialising quads in named graphs fails
+* unless `mergeGraphs: true` is given.
+*
+* @since 0.1.0
+*/
+var RdfJson_exports = /* @__PURE__ */ __exportAll({
+	BlankNodeValue: () => BlankNodeValue,
+	DatasetFromRdfJson: () => DatasetFromRdfJson,
+	DatasetFromString: () => DatasetFromString,
+	Document: () => Document,
+	LiteralValue: () => LiteralValue,
+	ObjectValue: () => ObjectValue,
+	RdfJsonFromString: () => RdfJsonFromString,
+	StrictDocument: () => StrictDocument,
+	StrictObjectValue: () => StrictObjectValue,
+	TripleTermValue: () => TripleTermValue,
+	UriValue: () => UriValue,
+	codec: () => codec,
+	format: () => format,
+	fromQuads: () => fromQuads,
+	makeDatasetSchema: () => makeDatasetSchema,
+	parse: () => parse,
+	parser: () => parser,
+	serialize: () => serialize,
+	serializer: () => serializer,
+	toDataset: () => toDataset
+});
+const FORMAT_NAME = "RDF/JSON";
+const XSD_STRING = "http://www.w3.org/2001/XMLSchema#string";
+const RDF_LANG_STRING = "http://www.w3.org/1999/02/22-rdf-syntax-ns#langString";
+const RDF_DIR_LANG_STRING = "http://www.w3.org/1999/02/22-rdf-syntax-ns#dirLangString";
+/**
+* The RDF/JSON format description.
+*
+* @since 0.1.0
+* @category formats
+*/
+const format = makeFormat({
+	name: FORMAT_NAME,
+	mediaType: "application/rdf+json",
+	extensions: ["rj"],
+	datasets: false
+});
+const trace = {
+	module: "RdfJson",
+	format
+};
+/**
+* @since 0.1.0
+* @category schemas
+*/
+const UriValue = Schema.Struct({
+	type: Schema.Literal("uri"),
+	value: Schema.String
+}).annotate({
+	identifier: "UriValue",
+	description: "An RDF/JSON IRI value"
+});
+/**
+* @since 0.1.0
+* @category schemas
+*/
+const BlankNodeValue = Schema.Struct({
+	type: Schema.Literal("bnode"),
+	value: Schema.String.check(Schema.isPattern(/^_:.+$/s, { message: "Blank node values must have the form \"_:label\"" }))
+}).annotate({
+	identifier: "BlankNodeValue",
+	description: "An RDF/JSON blank node value"
+});
+const Direction = Schema.Literals(["ltr", "rtl"]);
+/**
+* @since 0.1.0
+* @category schemas
+*/
+const LiteralValue = Schema.Struct({
+	type: Schema.Literal("literal"),
+	value: Schema.String,
+	lang: Schema.optionalKey(Schema.String.check(Schema.isPattern(/^[a-zA-Z]+(-[a-zA-Z0-9]+)*$/, { message: "Invalid language tag" }))),
+	datatype: Schema.optionalKey(Schema.String),
+	direction: Schema.optionalKey(Direction)
+}).check(Schema.makeFilter((l) => l.lang !== void 0 && l.datatype !== void 0 && l.datatype !== RDF_LANG_STRING && l.datatype !== RDF_DIR_LANG_STRING ? {
+	path: ["datatype"],
+	issue: "\"datatype\" cannot be combined with \"lang\""
+} : void 0, {
+	identifier: "LiteralLangDatatype",
+	title: "Language or datatype",
+	description: "A literal with a \"lang\" has no \"datatype\" other than rdf:langString"
+}), Schema.makeFilter((l) => l.direction !== void 0 && l.lang === void 0 ? {
+	path: ["direction"],
+	issue: "\"direction\" requires \"lang\""
+} : void 0, {
+	identifier: "LiteralDirectionLang",
+	title: "Direction requires language",
+	description: "A literal with a \"direction\" also has a \"lang\""
+})).annotate({
+	identifier: "LiteralValue",
+	description: "An RDF/JSON literal value"
+});
+const SubjectValue = Schema.Union([UriValue, BlankNodeValue]);
+/**
+* An RDF 1.2 triple term (extension).
+*
+* @since 0.1.0
+* @category schemas
+*/
+const TripleTermValue = Schema.Struct({
+	type: Schema.Literal("triple"),
+	value: Schema.Struct({
+		subject: SubjectValue,
+		predicate: UriValue,
+		object: Schema.suspend(() => ObjectValue)
+	})
+}).annotate({
+	identifier: "TripleTermValue",
+	description: "An RDF 1.2 triple term (extension)"
+});
+/**
+* Any object value, including the RDF 1.2 extensions.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const ObjectValue = Schema.Union([
+	UriValue,
+	BlankNodeValue,
+	LiteralValue,
+	TripleTermValue
+]).annotate({ expected: "an RDF/JSON value (\"type\" must be \"uri\", \"bnode\", \"literal\" or \"triple\")" });
+/**
+* An object value in strict RDF/JSON: no triple terms and no base
+* direction.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const StrictObjectValue = Schema.Union([
+	UriValue,
+	BlankNodeValue,
+	LiteralValue.check(Schema.makeFilter((l) => l.direction !== void 0 ? {
+		path: ["direction"],
+		issue: "\"direction\" is an RDF 1.2 extension (disabled in strict mode)"
+	} : void 0, {
+		identifier: "StrictLiteralDirection",
+		title: "No base direction",
+		description: "A strict RDF/JSON literal has no \"direction\""
+	}))
+]).annotate({ expected: "an RDF/JSON value (\"type\" must be \"uri\", \"bnode\" or \"literal\")" });
+const makeDocument = (value) => Schema.Record(Schema.String, Schema.Record(Schema.String, Schema.Array(value)));
+/**
+* An RDF/JSON document, accepting the RDF 1.2 extensions.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const Document = makeDocument(ObjectValue).annotate({ description: "An RDF/JSON document (with the RDF 1.2 extensions)" });
+/**
+* A strict RDF/JSON document, rejecting the RDF 1.2 extensions.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const StrictDocument = makeDocument(StrictObjectValue).annotate({ description: "A strict RDF/JSON document" });
+/**
+* Decodes RDF/JSON text into a validated `Document` (and encodes documents
+* as JSON text).
+*
+* @since 0.1.0
+* @category schemas
+*/
+const RdfJsonFromString = Schema.fromJsonString(Document);
+/**
+* Converts a (validated) RDF/JSON document to a dataset.
+*
+* @since 0.1.0
+* @category conversions
+*/
+const toDataset = (document, options) => {
+	const prefix = options?.blankNodePrefix ?? freshBlankNodePrefix();
+	const graph = options?.graph ?? defaultGraph;
+	const blank = (label) => new BlankNode(prefix + label.slice(2));
+	const subjectTerm = (key) => key.startsWith("_:") ? blank(key) : new NamedNode(key);
+	const objectTerm = Match.type().pipe(Match.withReturnType(), Match.when({ type: "uri" }, (v) => new NamedNode(v.value)), Match.when({ type: "bnode" }, (v) => blank(v.value)), Match.when({ type: "literal" }, (v) => {
+		if (v.lang !== void 0) return literal(v.value, v.direction !== void 0 ? {
+			language: v.lang,
+			direction: v.direction
+		} : v.lang);
+		return literal(v.value, new NamedNode(v.datatype ?? XSD_STRING));
+	}), Match.when({ type: "triple" }, (v) => new Triple(v.value.subject.type === "uri" ? new NamedNode(v.value.subject.value) : blank(v.value.subject.value), new NamedNode(v.value.predicate.value), objectTerm(v.value.object))), Match.exhaustive);
+	return mutate(empty, (b) => Arr.forEach(Record.toEntries(document), ([s, predicates]) => {
+		const subject = subjectTerm(s);
+		Arr.forEach(Record.toEntries(predicates), ([p, objects]) => {
+			const predicate = new NamedNode(p);
+			Arr.forEach(objects, (o) => b.add(new Quad(subject, predicate, objectTerm(o), graph)));
+		});
+	}));
+};
+var SerializeFailure = class {
+	message;
+	constructor(message) {
+		this.message = message;
+	}
+};
+const quadOrder = Order.combineAll([
+	Order.mapInput(Order$1, (q) => q.subject),
+	Order.mapInput(Order$1, (q) => q.predicate),
+	Order.mapInput(Order$1, (q) => q.object)
+]);
+const failSerialize = (message) => {
+	throw new SerializeFailure(message);
+};
+const resourceValue = (t) => isNamedNode(t) ? {
+	type: "uri",
+	value: t.value
+} : {
+	type: "bnode",
+	value: `_:${t.value}`
+};
+const fromQuadsUnsafe = (quads, options) => {
+	const extensions = options.extensions ?? false;
+	const objectValue = Match.type().pipe(Match.withReturnType(), Match.tag("NamedNode", "BlankNode", (t) => resourceValue(t)), Match.tag("Literal", (t) => {
+		if (t.language !== "") {
+			if (t.direction === void 0) return {
+				type: "literal",
+				value: t.value,
+				lang: t.language
+			};
+			if (!extensions) failSerialize(`The literal ${t.key} has a base direction, which requires the RDF/JSON extensions`);
+			return {
+				type: "literal",
+				value: t.value,
+				lang: t.language,
+				direction: t.direction
+			};
+		}
+		return t.datatype.value === XSD_STRING ? {
+			type: "literal",
+			value: t.value
+		} : {
+			type: "literal",
+			value: t.value,
+			datatype: t.datatype.value
+		};
+	}), Match.tag("Triple", (t) => {
+		if (!extensions) failSerialize(`The triple term ${t.key} requires the RDF/JSON extensions`);
+		const subject = t.subject;
+		if (isTriple(subject)) throw new SerializeFailure(`Triple terms cannot have triple terms as subjects: ${t.key}`);
+		return {
+			type: "triple",
+			value: {
+				subject: resourceValue(subject),
+				predicate: {
+					type: "uri",
+					value: t.predicate.value
+				},
+				object: objectValue(t.object)
+			}
+		};
+	}), Match.exhaustive);
+	const merge = options.mergeGraphs ?? false;
+	const seen = MutableHashSet.empty();
+	const sorted = Arr.sort(quads, quadOrder);
+	const document = {};
+	Arr.forEach(sorted, (q) => {
+		if (!isDefaultGraph(q.graph) && !merge) failSerialize(`RDF/JSON cannot represent named graphs (found graph ${q.graph.key})`);
+		const tripleKey = `${q.subject.key} ${q.predicate.key} ${q.object.key}`;
+		if (MutableHashSet.has(seen, tripleKey)) return;
+		MutableHashSet.add(seen, tripleKey);
+		const subject = q.subject;
+		if (isTriple(subject)) throw new SerializeFailure("RDF/JSON cannot represent triple terms as subjects");
+		const s = isNamedNode(subject) ? subject.value : `_:${subject.value}`;
+		const predicates = document[s] ??= {};
+		(predicates[q.predicate.value] ??= []).push(objectValue(q.object));
+	});
+	return document;
+};
+/**
+* Converts quads to an RDF/JSON document.
+*
+* @since 0.1.0
+* @category conversions
+*/
+const fromQuads = (quads, options) => Effect.try({
+	try: () => fromQuadsUnsafe(quads, options ?? {}),
+	catch: (e) => {
+		if (e instanceof SerializeFailure) return new RdfSerializeError({
+			format: FORMAT_NAME,
+			message: e.message
+		});
+		throw e;
+	}
+});
+/**
+* Builds a schema transforming RDF/JSON documents into datasets and back,
+* with the given conversion options.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const makeDatasetSchema = (options) => (options?.strict === true ? StrictDocument : Document).pipe(Schema.decodeTo(DatasetSchema, SchemaTransformation.transformEffect({
+	decode: (document) => Effect.sync(() => toDataset(document, options)),
+	encode: (dataset) => fromQuads(dataset, options).pipe(Effect.mapError((e) => new SchemaIssue.InvalidValue({ message: e.message }, dataset)))
+})));
+/**
+* A schema transforming RDF/JSON documents into datasets and back. Decoding
+* accepts the RDF 1.2 extensions; encoding writes strict RDF/JSON and fails
+* for data that needs the extensions or uses named graphs.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const DatasetFromRdfJson = makeDatasetSchema();
+/**
+* A schema transforming RDF/JSON text into datasets and back.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const DatasetFromString = Schema.fromJsonString(DatasetFromRdfJson, { space: 2 });
+/**
+* Finds the offset of the first JSON syntax error (JavaScript engines do not
+* always report one). Only used once `JSON.parse` has failed.
+*/
+const jsonErrorOffset = (input) => {
+	let i = 0;
+	const ws = () => {
+		WHITESPACE.lastIndex = i;
+		i += WHITESPACE.exec(input)?.[0].length ?? 0;
+	};
+	const fail = () => {
+		throw i;
+	};
+	const string = () => {
+		STRING_PREFIX.lastIndex = i;
+		i += STRING_PREFIX.exec(input)?.[0].length ?? 0;
+		if (input[i] !== "\"") fail();
+		i++;
+	};
+	const NUMBER = /-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?/y;
+	/** The members of an object or the items of an array, up to the closing `end`. */
+	const elements = (end, element) => {
+		i++;
+		ws();
+		if (input[i] === end) {
+			i++;
+			return;
+		}
+		repeat(() => {
+			element();
+			ws();
+			if (input[i] === ",") {
+				i++;
+				return true;
+			}
+			if (input[i] !== end) fail();
+			i++;
+			return false;
+		});
+	};
+	const member = () => {
+		ws();
+		if (input[i] !== "\"") fail();
+		string();
+		ws();
+		if (input[i] !== ":") fail();
+		i++;
+		value();
+	};
+	const value = () => {
+		ws();
+		const c = input[i];
+		if (c === "{") elements("}", member);
+		else if (c === "[") elements("]", value);
+		else if (c === "\"") string();
+		else if (input.startsWith("true", i)) i += 4;
+		else if (input.startsWith("false", i)) i += 5;
+		else if (input.startsWith("null", i)) i += 4;
+		else {
+			NUMBER.lastIndex = i;
+			const m = NUMBER.exec(input);
+			if (m === null) return fail();
+			i += m[0].length;
+		}
+	};
+	const scan = () => {
+		value();
+		ws();
+		return i;
+	};
+	return Result.getOrElse(Result.try(scan), () => i);
+};
+const WHITESPACE = /[ \t\n\r]*/y;
+/**
+* The longest well-formed prefix of a JSON string, from its opening quote:
+* any character but `"`, `\` and U+0000–U+001F (the C0 controls; DEL and the
+* C1 controls are allowed), or an escape.
+*/
+const STRING_PREFIX = /"(?:[^"\\\p{Cc}]|[\x7f-\x9f]|\\(?:["\\/bfnrt]|u[0-9a-fA-F]{4}))*/uy;
+/** Runs `step` until it returns `false`. */
+const repeat = (step) => Iterable.forEach(Iterable.unfold(true, (again) => again ? Option.some([void 0, step()]) : Option.none()), constVoid);
+const jsonErrorPosition = (input) => {
+	const offset = jsonErrorOffset(input);
+	const before = input.slice(0, offset);
+	return {
+		line: before.split("\n").length,
+		column: offset - before.lastIndexOf("\n")
+	};
+};
+/**
+* Parses RDF/JSON text into a dataset. The document shape is validated with
+* the `Document` schema (or `StrictDocument` when `strict` is set), and
+* validation failures are reported as `RdfParseError`s.
+*
+* @since 0.1.0
+* @category parsing
+*/
+const parse = (input, options) => Effect.gen(function* () {
+	const json = yield* Effect.fromResult(parseJson(input)).pipe(Effect.mapError((e) => new RdfParseError({
+		format: FORMAT_NAME,
+		message: `Invalid JSON: ${e.message}`,
+		...jsonErrorPosition(input)
+	})));
+	const document = yield* Schema.decodeUnknownEffect(options?.strict === true ? StrictDocument : Document)(json).pipe(Effect.mapError((e) => new RdfParseError({
+		format: FORMAT_NAME,
+		message: e.message
+	})));
+	return {
+		dataset: toDataset(document, options),
+		prefixes: empty$1,
+		baseIri: options?.baseIri
+	};
+}).pipe(withParseSpan(trace, input));
+/**
+* Serialises quads as RDF/JSON text.
+*
+* @since 0.1.0
+* @category serializing
+*/
+const serialize = (quads, options) => fromQuads(quads, options).pipe(Effect.flatMap((document) => Schema.encodeEffect(Schema.fromJsonString(Schema.Unknown, { space: options?.space ?? 2 }))(document).pipe(Effect.mapError((e) => new RdfSerializeError({
+	format: FORMAT_NAME,
+	message: e.message
+})))), Effect.map((text) => `${text}\n`), withSerializeSpan(trace));
+/**
+* The RDF/JSON parser.
+*
+* @since 0.1.0
+* @category parsing
+*/
+const parser = makeParser({
+	format,
+	parse
+});
+/**
+* The RDF/JSON serializer.
+*
+* @since 0.1.0
+* @category serializing
+*/
+const serializer = makeSerializer({
+	format,
+	serialize
+});
+/**
+* The RDF/JSON codec. Its `schema` is `DatasetFromString`, so decoding
+* errors carry the precise schema issue.
+*
+* @since 0.1.0
+* @category codecs
+*/
+const codec = {
+	...makeCodec(parser, serializer),
+	schema: DatasetFromString
+};
+export { parse as _, LiteralValue as a, serializer as b, RdfJson_exports as c, TripleTermValue as d, UriValue as f, makeDatasetSchema as g, fromQuads as h, Document as i, StrictDocument as l, format as m, DatasetFromRdfJson as n, ObjectValue as o, codec as p, DatasetFromString as r, RdfJsonFromString as s, BlankNodeValue as t, StrictObjectValue as u, parser as v, toDataset as x, serialize as y };
+
+//# sourceMappingURL=RdfJson-BNocgW4f.mjs.map

package/dist/RdfJson-BNocgW4f.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"RdfJson-BNocgW4f.mjs","names":["Serialization.makeFormat","Serialization.freshBlankNodePrefix","Term.defaultGraph","Term.BlankNode","Term.NamedNode","Term.literal","Term.Triple","Dataset.mutate","Dataset.empty","Term.Quad","Term.Order","Term.isNamedNode","Term.isTriple","Term.isDefaultGraph","Serialization.RdfSerializeError","Dataset.DatasetSchema","Serialization.RdfParseError","PrefixMap.empty","Serialization.withParseSpan","Serialization.withSerializeSpan","Serialization.makeParser","Serialization.makeSerializer","Serialization.makeCodec"],"sources":["../src/rdfjson/internal/json.ts","../src/rdfjson/RdfJson.ts"],"sourcesContent":["/**\n * The one `JSON.parse` call of this package. It stays native because the\n * engine's `SyntaxError` text is part of the parse error messages, and\n * `Schema.fromJsonString` replaces it with a generic issue.\n *\n * @internal\n */\nimport * as Result from 'effect/Result';\n\n/**\n * Parses JSON text, failing with the engine's `SyntaxError`.\n *\n * @internal\n */\nexport const parseJson = (text: string): Result.Result<unknown, SyntaxError> =>\n  Result.try({\n    try: () => JSON.parse(text),\n    catch: (e) => (e instanceof SyntaxError ? e : new SyntaxError(String(e))),\n  });\n","/**\n * RDF/JSON (https://www.w3.org/TR/rdf-json/), media type\n * `application/rdf+json`.\n *\n * The document structure is described with Effect `Schema`s, so decoding\n * validates the JSON shape and reports precise errors. `RdfJsonFromString`\n * decodes JSON text into a typed `Document`, and `DatasetFromRdfJson` /\n * `DatasetFromString` transform documents into core `Dataset`s and back.\n *\n * ## RDF 1.2 extensions\n *\n * RDF/JSON predates RDF 1.2. This module defines two backwards-compatible\n * extensions, accepted when parsing by default and written only when\n * `extensions: true` is passed to the serializer:\n *\n * - **Base direction**: a literal object with a `\"lang\"` may carry\n *   `\"direction\": \"ltr\" | \"rtl\"`, denoting a directional language-tagged\n *   string (`rdf:dirLangString`).\n * - **Triple terms**: an object value `{ \"type\": \"triple\", \"value\": { … } }`\n *   whose `value` has `\"subject\"` (a `uri` or `bnode` value), `\"predicate\"`\n *   (a `uri` value) and `\"object\"` (any object value, including another\n *   triple term) members.\n *\n * ```json\n * {\n *   \"http://example.org/s\": {\n *     \"http://example.org/says\": [\n *       { \"type\": \"literal\", \"value\": \"שלום\", \"lang\": \"he\", \"direction\": \"rtl\" },\n *       { \"type\": \"triple\", \"value\": {\n *           \"subject\": { \"type\": \"uri\", \"value\": \"http://example.org/a\" },\n *           \"predicate\": { \"type\": \"uri\", \"value\": \"http://example.org/b\" },\n *           \"object\": { \"type\": \"literal\", \"value\": \"c\" } } }\n *     ]\n *   }\n * }\n * ```\n *\n * RDF/JSON describes a single graph: serialising quads in named graphs fails\n * unless `mergeGraphs: true` is given.\n *\n * @since 0.1.0\n */\nimport * as Arr from 'effect/Array';\nimport * as Effect from 'effect/Effect';\nimport { constVoid } from 'effect/Function';\nimport * as Iterable from 'effect/Iterable';\nimport * as Match from 'effect/Match';\nimport * as MutableHashSet from 'effect/MutableHashSet';\nimport * as Option from 'effect/Option';\nimport * as Order from 'effect/Order';\nimport * as Record from 'effect/Record';\nimport * as Result from 'effect/Result';\nimport * as Schema from 'effect/Schema';\nimport * as SchemaIssue from 'effect/SchemaIssue';\nimport * as SchemaTransformation from 'effect/SchemaTransformation';\nimport * as Dataset from '../Dataset.ts';\nimport * as PrefixMap from '../PrefixMap.ts';\nimport * as Serialization from '../Serialization.ts';\nimport * as Term from '../Term.ts';\nimport { parseJson } from './internal/json.ts';\n\nconst FORMAT_NAME = 'RDF/JSON';\nconst XSD_STRING = 'http://www.w3.org/2001/XMLSchema#string';\nconst RDF_LANG_STRING = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#langString';\nconst RDF_DIR_LANG_STRING = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#dirLangString';\n\n/**\n * The RDF/JSON format description.\n *\n * @since 0.1.0\n * @category formats\n */\nexport const format: Serialization.Format = Serialization.makeFormat({\n  name: FORMAT_NAME,\n  mediaType: 'application/rdf+json',\n  extensions: ['rj'],\n  datasets: false,\n});\n\n// Spans are named `RdfJson.parse`, `RdfJson.serialize`.\nconst trace: Serialization.SpanTarget = { module: 'RdfJson', format };\n\n// -----------------------------------------------------------------------------\n// Document model\n// -----------------------------------------------------------------------------\n\n/**\n * An IRI value: `{ \"type\": \"uri\", \"value\": \"http://…\" }`.\n *\n * @since 0.1.0\n * @category models\n */\nexport type UriValue = {\n  readonly type: 'uri';\n  readonly value: string;\n};\n\n/**\n * A blank node value: `{ \"type\": \"bnode\", \"value\": \"_:label\" }`.\n *\n * @since 0.1.0\n * @category models\n */\nexport type BlankNodeValue = {\n  readonly type: 'bnode';\n  readonly value: string;\n};\n\n/**\n * A literal value. `lang` and `datatype` are mutually exclusive;\n * `direction` is an RDF 1.2 extension that requires `lang`.\n *\n * @since 0.1.0\n * @category models\n */\nexport type LiteralValue = {\n  readonly type: 'literal';\n  readonly value: string;\n  readonly lang?: string;\n  readonly datatype?: string;\n  readonly direction?: Term.Direction;\n};\n\n/**\n * An RDF 1.2 triple term value (extension).\n *\n * @since 0.1.0\n * @category models\n */\nexport type TripleTermValue = {\n  readonly type: 'triple';\n  readonly value: {\n    readonly subject: UriValue | BlankNodeValue;\n    readonly predicate: UriValue;\n    readonly object: ObjectValue;\n  };\n};\n\n/**\n * Any value in the object position.\n *\n * @since 0.1.0\n * @category models\n */\nexport type ObjectValue = UriValue | BlankNodeValue | LiteralValue | TripleTermValue;\n\n/**\n * An RDF/JSON document: subject → predicate → array of object values.\n * Subjects are IRIs or blank node labels (`\"_:label\"`).\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Document {\n  readonly [subject: string]: { readonly [predicate: string]: ReadonlyArray<ObjectValue> };\n}\n\n// -----------------------------------------------------------------------------\n// Schemas\n// -----------------------------------------------------------------------------\n\n/**\n * @since 0.1.0\n * @category schemas\n */\nexport const UriValue: Schema.Codec<UriValue> = Schema.Struct({\n  type: Schema.Literal('uri'),\n  value: Schema.String,\n}).annotate({ identifier: 'UriValue', description: 'An RDF/JSON IRI value' });\n\n/**\n * @since 0.1.0\n * @category schemas\n */\nexport const BlankNodeValue: Schema.Codec<BlankNodeValue> = Schema.Struct({\n  type: Schema.Literal('bnode'),\n  value: Schema.String.check(\n    Schema.isPattern(/^_:.+$/s, { message: 'Blank node values must have the form \"_:label\"' }),\n  ),\n}).annotate({ identifier: 'BlankNodeValue', description: 'An RDF/JSON blank node value' });\n\nconst Direction = Schema.Literals(['ltr', 'rtl']);\n\n/**\n * @since 0.1.0\n * @category schemas\n */\nexport const LiteralValue: Schema.Codec<LiteralValue> = Schema.Struct({\n  type: Schema.Literal('literal'),\n  value: Schema.String,\n  lang: Schema.optionalKey(\n    Schema.String.check(\n      Schema.isPattern(/^[a-zA-Z]+(-[a-zA-Z0-9]+)*$/, { message: 'Invalid language tag' }),\n    ),\n  ),\n  datatype: Schema.optionalKey(Schema.String),\n  direction: Schema.optionalKey(Direction),\n})\n  .check(\n    Schema.makeFilter(\n      (l) =>\n        l.lang !== undefined &&\n        l.datatype !== undefined &&\n        l.datatype !== RDF_LANG_STRING &&\n        l.datatype !== RDF_DIR_LANG_STRING\n          ? { path: ['datatype'], issue: '\"datatype\" cannot be combined with \"lang\"' }\n          : undefined,\n      {\n        identifier: 'LiteralLangDatatype',\n        title: 'Language or datatype',\n        description: 'A literal with a \"lang\" has no \"datatype\" other than rdf:langString',\n      },\n    ),\n    Schema.makeFilter(\n      (l) =>\n        l.direction !== undefined && l.lang === undefined\n          ? { path: ['direction'], issue: '\"direction\" requires \"lang\"' }\n          : undefined,\n      {\n        identifier: 'LiteralDirectionLang',\n        title: 'Direction requires language',\n        description: 'A literal with a \"direction\" also has a \"lang\"',\n      },\n    ),\n  )\n  .annotate({ identifier: 'LiteralValue', description: 'An RDF/JSON literal value' });\n\nconst SubjectValue = Schema.Union([UriValue, BlankNodeValue]);\n\n/**\n * An RDF 1.2 triple term (extension).\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const TripleTermValue: Schema.Codec<TripleTermValue> = Schema.Struct({\n  type: Schema.Literal('triple'),\n  value: Schema.Struct({\n    subject: SubjectValue,\n    predicate: UriValue,\n    object: Schema.suspend((): Schema.Codec<ObjectValue> => ObjectValue),\n  }),\n}).annotate({ identifier: 'TripleTermValue', description: 'An RDF 1.2 triple term (extension)' });\n\n/**\n * Any object value, including the RDF 1.2 extensions.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const ObjectValue: Schema.Codec<ObjectValue> = Schema.Union([\n  UriValue,\n  BlankNodeValue,\n  LiteralValue,\n  TripleTermValue,\n]).annotate({\n  expected: 'an RDF/JSON value (\"type\" must be \"uri\", \"bnode\", \"literal\" or \"triple\")',\n});\n\n/**\n * The type of an object value in strict RDF/JSON (the `StrictObjectValue`\n * schema's decoded type).\n *\n * @since 0.1.0\n * @category models\n */\nexport type StrictObjectValue = typeof StrictObjectValue.Type;\n\n/**\n * An object value in strict RDF/JSON: no triple terms and no base\n * direction.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const StrictObjectValue: Schema.Codec<UriValue | BlankNodeValue | LiteralValue> =\n  Schema.Union([\n    UriValue,\n    BlankNodeValue,\n    LiteralValue.check(\n      Schema.makeFilter(\n        (l) =>\n          l.direction !== undefined\n            ? {\n                path: ['direction'],\n                issue: '\"direction\" is an RDF 1.2 extension (disabled in strict mode)',\n              }\n            : undefined,\n        {\n          identifier: 'StrictLiteralDirection',\n          title: 'No base direction',\n          description: 'A strict RDF/JSON literal has no \"direction\"',\n        },\n      ),\n    ),\n  ]).annotate({\n    expected: 'an RDF/JSON value (\"type\" must be \"uri\", \"bnode\" or \"literal\")',\n  });\n\nconst makeDocument = (value: Schema.Codec<ObjectValue>): Schema.Codec<Document> =>\n  Schema.Record(Schema.String, Schema.Record(Schema.String, Schema.Array(value)));\n\n/**\n * An RDF/JSON document, accepting the RDF 1.2 extensions.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const Document: Schema.Codec<Document> = makeDocument(ObjectValue).annotate({\n  description: 'An RDF/JSON document (with the RDF 1.2 extensions)',\n});\n\n/**\n * A strict RDF/JSON document, rejecting the RDF 1.2 extensions.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const StrictDocument: Schema.Codec<Document> = makeDocument(StrictObjectValue).annotate({\n  description: 'A strict RDF/JSON document',\n});\n\n/**\n * The decoded type of `RdfJsonFromString`: a validated `Document`.\n *\n * @since 0.1.0\n * @category models\n */\nexport type RdfJsonFromString = typeof RdfJsonFromString.Type;\n\n/**\n * Decodes RDF/JSON text into a validated `Document` (and encodes documents\n * as JSON text).\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const RdfJsonFromString: Schema.Codec<Document, string> = Schema.fromJsonString(Document);\n\n// -----------------------------------------------------------------------------\n// Conversions\n// -----------------------------------------------------------------------------\n\n/**\n * Options for converting RDF/JSON documents to datasets.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface ToDatasetOptions {\n  /** The graph to place triples in. Defaults to the default graph. */\n  readonly graph?: Term.Graph | undefined;\n  /**\n   * Prefix for blank node labels. Defaults to a fresh prefix per document,\n   * so that blank nodes from different documents never clash.\n   */\n  readonly blankNodePrefix?: string | undefined;\n}\n\n/**\n * Converts a (validated) RDF/JSON document to a dataset.\n *\n * @since 0.1.0\n * @category conversions\n */\nexport const toDataset = (document: Document, options?: ToDatasetOptions): Dataset.Dataset => {\n  const prefix = options?.blankNodePrefix ?? Serialization.freshBlankNodePrefix();\n  const graph = options?.graph ?? Term.defaultGraph;\n  const blank = (label: string) => new Term.BlankNode(prefix + label.slice(2));\n  const subjectTerm = (key: string): Term.NamedNode | Term.BlankNode =>\n    key.startsWith('_:') ? blank(key) : new Term.NamedNode(key);\n  // Built once per document: `objectTerm` runs for every object value.\n  const objectTerm: (v: ObjectValue) => Term.Object = Match.type<ObjectValue>().pipe(\n    Match.withReturnType<Term.Object>(),\n    Match.when({ type: 'uri' }, (v) => new Term.NamedNode(v.value)),\n    Match.when({ type: 'bnode' }, (v) => blank(v.value)),\n    Match.when({ type: 'literal' }, (v) => {\n      if (v.lang !== undefined) {\n        return Term.literal(\n          v.value,\n          v.direction !== undefined ? { language: v.lang, direction: v.direction } : v.lang,\n        );\n      }\n      return Term.literal(v.value, new Term.NamedNode(v.datatype ?? XSD_STRING));\n    }),\n    Match.when(\n      { type: 'triple' },\n      (v) =>\n        new Term.Triple(\n          v.value.subject.type === 'uri'\n            ? new Term.NamedNode(v.value.subject.value)\n            : blank(v.value.subject.value),\n          new Term.NamedNode(v.value.predicate.value),\n          objectTerm(v.value.object),\n        ),\n    ),\n    Match.exhaustive,\n  );\n  return Dataset.mutate(Dataset.empty, (b) =>\n    Arr.forEach(Record.toEntries(document), ([s, predicates]) => {\n      const subject = subjectTerm(s);\n      Arr.forEach(Record.toEntries(predicates), ([p, objects]) => {\n        const predicate = new Term.NamedNode(p);\n        Arr.forEach(objects, (o) => b.add(new Term.Quad(subject, predicate, objectTerm(o), graph)));\n      });\n    }),\n  );\n};\n\n/**\n * Options for converting quads to RDF/JSON.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface FromQuadsOptions {\n  /**\n   * Whether to use the RDF 1.2 extensions (base direction and triple terms).\n   * When `false` (the default), data that needs them is rejected with an\n   * `RdfSerializeError`.\n   */\n  readonly extensions?: boolean | undefined;\n  /**\n   * Whether to merge quads from named graphs into the single RDF/JSON graph.\n   * When `false` (the default), quads in named graphs are rejected.\n   */\n  readonly mergeGraphs?: boolean | undefined;\n}\n\nclass SerializeFailure {\n  readonly message: string;\n  constructor(message: string) {\n    this.message = message;\n  }\n}\n\n// Subject, predicate, object only — not `Term.QuadOrder`, which sorts by graph first: RDF/JSON\n// has no graphs, so quads from every graph interleave by their triple.\nconst quadOrder: Order.Order<Term.Quad> = Order.combineAll([\n  Order.mapInput(Term.Order, (q: Term.Quad) => q.subject),\n  Order.mapInput(Term.Order, (q: Term.Quad) => q.predicate),\n  Order.mapInput(Term.Order, (q: Term.Quad) => q.object),\n]);\n\nconst failSerialize = (message: string): never => {\n  throw new SerializeFailure(message);\n};\n\nconst resourceValue = (t: Term.NamedNode | Term.BlankNode): UriValue | BlankNodeValue =>\n  Term.isNamedNode(t) ? { type: 'uri', value: t.value } : { type: 'bnode', value: `_:${t.value}` };\n\nconst fromQuadsUnsafe = (quads: Iterable<Term.Quad>, options: FromQuadsOptions): Document => {\n  const extensions = options.extensions ?? false;\n  // Built once per serialisation: `objectValue` runs for every object term.\n  const objectValue: (t: Term.Object) => ObjectValue = Match.type<Term.Object>().pipe(\n    Match.withReturnType<ObjectValue>(),\n    Match.tag('NamedNode', 'BlankNode', (t) => resourceValue(t)),\n    Match.tag('Literal', (t) => {\n      if (t.language !== '') {\n        if (t.direction === undefined) return { type: 'literal', value: t.value, lang: t.language };\n        if (!extensions) {\n          failSerialize(\n            `The literal ${t.key} has a base direction, which requires the RDF/JSON extensions`,\n          );\n        }\n        return { type: 'literal', value: t.value, lang: t.language, direction: t.direction };\n      }\n      return t.datatype.value === XSD_STRING\n        ? { type: 'literal', value: t.value }\n        : { type: 'literal', value: t.value, datatype: t.datatype.value };\n    }),\n    Match.tag('Triple', (t) => {\n      if (!extensions) {\n        failSerialize(`The triple term ${t.key} requires the RDF/JSON extensions`);\n      }\n      const subject = t.subject;\n      if (Term.isTriple(subject)) {\n        throw new SerializeFailure(`Triple terms cannot have triple terms as subjects: ${t.key}`);\n      }\n      return {\n        type: 'triple',\n        value: {\n          subject: resourceValue(subject),\n          predicate: { type: 'uri', value: t.predicate.value },\n          object: objectValue(t.object),\n        },\n      };\n    }),\n    Match.exhaustive,\n  );\n  const merge = options.mergeGraphs ?? false;\n  const seen = MutableHashSet.empty<string>();\n  const sorted = Arr.sort(quads, quadOrder);\n  const document: { [subject: string]: { [predicate: string]: Array<ObjectValue> } } = {};\n  Arr.forEach(sorted, (q) => {\n    if (!Term.isDefaultGraph(q.graph) && !merge) {\n      failSerialize(`RDF/JSON cannot represent named graphs (found graph ${q.graph.key})`);\n    }\n    const tripleKey = `${q.subject.key} ${q.predicate.key} ${q.object.key}`;\n    if (MutableHashSet.has(seen, tripleKey)) return;\n    MutableHashSet.add(seen, tripleKey);\n    const subject = q.subject;\n    if (Term.isTriple(subject)) {\n      throw new SerializeFailure('RDF/JSON cannot represent triple terms as subjects');\n    }\n    const s = Term.isNamedNode(subject) ? subject.value : `_:${subject.value}`;\n    const predicates = (document[s] ??= {});\n    (predicates[q.predicate.value] ??= []).push(objectValue(q.object));\n  });\n  return document;\n};\n\n/**\n * Converts quads to an RDF/JSON document.\n *\n * @since 0.1.0\n * @category conversions\n */\nexport const fromQuads = (\n  quads: Iterable<Term.Quad>,\n  options?: FromQuadsOptions,\n): Effect.Effect<Document, Serialization.RdfSerializeError> =>\n  Effect.try({\n    try: () => fromQuadsUnsafe(quads, options ?? {}),\n    // Anything but a `SerializeFailure` is a bug: rethrown, it becomes a defect.\n    catch: (e) => {\n      if (e instanceof SerializeFailure) {\n        return new Serialization.RdfSerializeError({ format: FORMAT_NAME, message: e.message });\n      }\n      throw e;\n    },\n  });\n\n/**\n * Builds a schema transforming RDF/JSON documents into datasets and back,\n * with the given conversion options.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const makeDatasetSchema = (\n  options?: ToDatasetOptions & FromQuadsOptions & { readonly strict?: boolean | undefined },\n): Schema.Codec<Dataset.Dataset, Document> =>\n  (options?.strict === true ? StrictDocument : Document).pipe(\n    Schema.decodeTo(\n      Dataset.DatasetSchema,\n      SchemaTransformation.transformEffect({\n        decode: (document: Document) => Effect.sync(() => toDataset(document, options)),\n        encode: (dataset: Dataset.Dataset) =>\n          fromQuads(dataset, options).pipe(\n            Effect.mapError((e) => new SchemaIssue.InvalidValue({ message: e.message }, dataset)),\n          ),\n      }),\n    ),\n  );\n\n/**\n * A schema transforming RDF/JSON documents into datasets and back. Decoding\n * accepts the RDF 1.2 extensions; encoding writes strict RDF/JSON and fails\n * for data that needs the extensions or uses named graphs.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const DatasetFromRdfJson: Schema.Codec<Dataset.Dataset, Document> = makeDatasetSchema();\n\n/**\n * The decoded type of `DatasetFromString`: a `Dataset`.\n *\n * @since 0.1.0\n * @category models\n */\nexport type DatasetFromString = typeof DatasetFromString.Type;\n\n/**\n * A schema transforming RDF/JSON text into datasets and back.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const DatasetFromString: Schema.Codec<Dataset.Dataset, string> = Schema.fromJsonString(\n  DatasetFromRdfJson,\n  { space: 2 },\n);\n\n// -----------------------------------------------------------------------------\n// Parser / serializer\n// -----------------------------------------------------------------------------\n\n/**\n * Options for parsing RDF/JSON.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface ParseOptions extends Serialization.ParseOptions {\n  /** Reject the RDF 1.2 extensions. Defaults to `false`. */\n  readonly strict?: boolean | undefined;\n}\n\n/**\n * Finds the offset of the first JSON syntax error (JavaScript engines do not\n * always report one). Only used once `JSON.parse` has failed.\n */\nconst jsonErrorOffset = (input: string): number => {\n  let i = 0;\n  const ws = () => {\n    WHITESPACE.lastIndex = i;\n    i += WHITESPACE.exec(input)?.[0].length ?? 0;\n  };\n  const fail = (): never => {\n    throw i;\n  };\n  const string = () => {\n    // The longest well-formed prefix of the string; it fails where it stops\n    // unless a closing quote follows.\n    STRING_PREFIX.lastIndex = i;\n    i += STRING_PREFIX.exec(input)?.[0].length ?? 0;\n    if (input[i] !== '\"') fail();\n    i++;\n  };\n  const NUMBER = /-?(?:0|[1-9][0-9]*)(?:\\.[0-9]+)?(?:[eE][+-]?[0-9]+)?/y;\n  /** The members of an object or the items of an array, up to the closing `end`. */\n  const elements = (end: string, element: () => void) => {\n    i++;\n    ws();\n    if (input[i] === end) {\n      i++;\n      return;\n    }\n    repeat(() => {\n      element();\n      ws();\n      if (input[i] === ',') {\n        i++;\n        return true;\n      }\n      if (input[i] !== end) fail();\n      i++;\n      return false;\n    });\n  };\n  const member = () => {\n    ws();\n    if (input[i] !== '\"') fail();\n    string();\n    ws();\n    if (input[i] !== ':') fail();\n    i++;\n    value();\n  };\n  const value = (): void => {\n    ws();\n    const c = input[i];\n    if (c === '{') elements('}', member);\n    else if (c === '[') elements(']', value);\n    else if (c === '\"') string();\n    else if (input.startsWith('true', i)) i += 4;\n    else if (input.startsWith('false', i)) i += 5;\n    else if (input.startsWith('null', i)) i += 4;\n    else {\n      NUMBER.lastIndex = i;\n      const m = NUMBER.exec(input);\n      if (m === null) return fail();\n      i += m[0].length;\n    }\n  };\n  const scan = () => {\n    value();\n    ws();\n    return i;\n  };\n  // `fail` throws at the offending offset, which is `i`.\n  return Result.getOrElse(Result.try(scan), () => i);\n};\n\nconst WHITESPACE = /[ \\t\\n\\r]*/y;\n\n/**\n * The longest well-formed prefix of a JSON string, from its opening quote:\n * any character but `\"`, `\\` and U+0000–U+001F (the C0 controls; DEL and the\n * C1 controls are allowed), or an escape.\n */\nconst STRING_PREFIX = /\"(?:[^\"\\\\\\p{Cc}]|[\\x7f-\\x9f]|\\\\(?:[\"\\\\/bfnrt]|u[0-9a-fA-F]{4}))*/uy;\n\n/** Runs `step` until it returns `false`. */\nconst repeat = (step: () => boolean): void =>\n  Iterable.forEach(\n    Iterable.unfold(true, (again) =>\n      again ? Option.some([undefined, step()] as const) : Option.none(),\n    ),\n    constVoid,\n  );\n\nconst jsonErrorPosition = (input: string) => {\n  const offset = jsonErrorOffset(input);\n  const before = input.slice(0, offset);\n  const line = before.split('\\n').length;\n  return { line, column: offset - before.lastIndexOf('\\n') };\n};\n\n/**\n * Parses RDF/JSON text into a dataset. The document shape is validated with\n * the `Document` schema (or `StrictDocument` when `strict` is set), and\n * validation failures are reported as `RdfParseError`s.\n *\n * @since 0.1.0\n * @category parsing\n */\nexport const parse = (\n  input: string,\n  options?: ParseOptions,\n): Effect.Effect<Serialization.ParseResult, Serialization.RdfParseError> =>\n  Effect.gen(function* () {\n    const json = yield* Effect.fromResult(parseJson(input)).pipe(\n      Effect.mapError(\n        (e) =>\n          new Serialization.RdfParseError({\n            format: FORMAT_NAME,\n            message: `Invalid JSON: ${e.message}`,\n            ...jsonErrorPosition(input),\n          }),\n      ),\n    );\n    const document = yield* Schema.decodeUnknownEffect(\n      options?.strict === true ? StrictDocument : Document,\n    )(json).pipe(\n      Effect.mapError(\n        (e) => new Serialization.RdfParseError({ format: FORMAT_NAME, message: e.message }),\n      ),\n    );\n    return {\n      dataset: toDataset(document, options),\n      prefixes: PrefixMap.empty,\n      baseIri: options?.baseIri,\n    };\n  }).pipe(Serialization.withParseSpan(trace, input));\n\n/**\n * Options for serialising RDF/JSON.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface SerializeOptions extends Serialization.SerializeOptions, FromQuadsOptions {\n  /** Indentation passed to `JSON.stringify`. Defaults to 2 spaces. */\n  readonly space?: number | string | undefined;\n}\n\n/**\n * Serialises quads as RDF/JSON text.\n *\n * @since 0.1.0\n * @category serializing\n */\nexport const serialize = (\n  quads: Iterable<Term.Quad>,\n  options?: SerializeOptions,\n): Effect.Effect<string, Serialization.RdfSerializeError> =>\n  fromQuads(quads, options).pipe(\n    Effect.flatMap((document) =>\n      Schema.encodeEffect(Schema.fromJsonString(Schema.Unknown, { space: options?.space ?? 2 }))(\n        document,\n      ).pipe(\n        Effect.mapError(\n          (e) => new Serialization.RdfSerializeError({ format: FORMAT_NAME, message: e.message }),\n        ),\n      ),\n    ),\n    Effect.map((text) => `${text}\\n`),\n    Serialization.withSerializeSpan(trace),\n  );\n\n/**\n * The RDF/JSON parser.\n *\n * @since 0.1.0\n * @category parsing\n */\nexport const parser: Serialization.Parser<ParseOptions> = Serialization.makeParser({\n  format,\n  parse,\n});\n\n/**\n * The RDF/JSON serializer.\n *\n * @since 0.1.0\n * @category serializing\n */\nexport const serializer: Serialization.Serializer<SerializeOptions> = Serialization.makeSerializer({\n  format,\n  serialize,\n});\n\n/**\n * The RDF/JSON codec. Its `schema` is `DatasetFromString`, so decoding\n * errors carry the precise schema issue.\n *\n * @since 0.1.0\n * @category codecs\n */\nexport const codec: Serialization.Codec<ParseOptions, SerializeOptions> = {\n  ...Serialization.makeCodec(parser, serializer),\n  schema: DatasetFromString,\n};\n"],"mappings":"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"}