@thomasfosterau/effect-rdf 0.0.0-stage → 0.1.0

package/dist/Serialization-DP9H5bYQ.mjs

@@ -0,0 +1,514 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { G as statementCount, t as DatasetSchema } from "./Dataset-BlmlcI7J.mjs";
+import * as Arr from "effect/Array";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+import * as Schema from "effect/Schema";
+import * as SchemaTransformation from "effect/SchemaTransformation";
+import * as Effect from "effect/Effect";
+import * as Order from "effect/Order";
+import * as SchemaIssue from "effect/SchemaIssue";
+import * as Context from "effect/Context";
+import * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import * as Path from "effect/Path";
+import * as Stream from "effect/Stream";
+import * as Result from "effect/Result";
+// src/internal/textDecoder.ts
+/**
+* Incremental, strict text decoding for the byte entry points of
+* `Serialization`. Validation is `TextDecoder`'s `fatal` mode; when it
+* rejects UTF-8, a binary search over prefixes finds the exact bad byte, so
+* the failure carries the line and column reached before it. A leading byte
+* order mark is dropped. Other charsets go through a fatal `TextDecoder` too,
+* with failures positioned at the start of the failing chunk.
+*/
+const isUtf8 = (charset) => /^utf-?8$/i.test(charset.trim());
+/** The byte at `i` from the end of `bytes` (1 is the last), if there is one. */
+const fromEnd = (bytes, i) => Option.fromUndefinedOr(bytes[bytes.length - i]);
+const isContinuation = (b) => Option.exists(b, (byte) => byte >= 128 && byte < 192);
+const sequenceLength = (lead) => Option.match(lead, {
+	onNone: () => 1,
+	onSome: (l) => l < 194 ? 1 : l < 224 ? 2 : l < 240 ? 3 : l < 245 ? 4 : 1
+});
+/**
+* How many trailing bytes start a sequence the chunk does not finish (0–3):
+* they are held back for the next chunk. Whether they are well formed is
+* left to the decoder.
+*/
+const incompleteTail = (bytes) => {
+	if (sequenceLength(fromEnd(bytes, 1)) > 1) return 1;
+	if (sequenceLength(fromEnd(bytes, 2)) > 2 && isContinuation(fromEnd(bytes, 1))) return 2;
+	if (sequenceLength(fromEnd(bytes, 3)) > 3 && isContinuation(fromEnd(bytes, 2)) && isContinuation(fromEnd(bytes, 1))) return 3;
+	return 0;
+};
+const fatalUtf8 = (bytes, stream) => Result.try(() => new TextDecoder("utf-8", {
+	fatal: true,
+	ignoreBOM: true
+}).decode(bytes, { stream }));
+/**
+* The length of the longest prefix of `bytes` with no ill-formed byte (an
+* incomplete sequence at its end is allowed), given that `bytes.subarray(0,
+* valid)` has none and `bytes.subarray(0, invalid)` has one.
+*/
+const validPrefix = (bytes, valid, invalid) => {
+	if (invalid - valid <= 1) return valid;
+	const mid = Math.floor((valid + invalid) / 2);
+	return Result.isSuccess(fatalUtf8(bytes.subarray(0, mid), true)) ? validPrefix(bytes, mid, invalid) : validPrefix(bytes, valid, mid);
+};
+var Position = class {
+	line = 1;
+	column = 1;
+	advance(text) {
+		const lines = text.split("\n");
+		const last = lines.at(-1) ?? "";
+		if (lines.length === 1) this.column += last.length;
+		else {
+			this.line += lines.length - 1;
+			this.column = last.length + 1;
+		}
+	}
+	fail(message) {
+		return {
+			message,
+			line: this.line,
+			column: this.column
+		};
+	}
+};
+const concat = (a, b) => {
+	if (a.byteLength === 0) return b;
+	const out = new Uint8Array(a.byteLength + b.byteLength);
+	out.set(a);
+	out.set(b, a.byteLength);
+	return out;
+};
+const utf8Decoder = () => {
+	const position = new Position();
+	let carry = /* @__PURE__ */ new Uint8Array(0);
+	let atStart = true;
+	const withoutBom = (text) => atStart && text.startsWith("") ? text.slice(1) : text;
+	const decode = (bytes) => Result.match(fatalUtf8(bytes, false), {
+		onSuccess: (text) => {
+			const out = withoutBom(text);
+			if (text !== "") atStart = false;
+			position.advance(out);
+			return out;
+		},
+		onFailure: () => {
+			const bad = Result.isSuccess(fatalUtf8(bytes, true)) ? bytes.length : validPrefix(bytes, 0, bytes.length);
+			position.advance(withoutBom(Result.getOrElse(fatalUtf8(bytes.subarray(0, bad), true), () => "")));
+			const byte = bytes[bad];
+			return position.fail(byte === void 0 ? "Invalid UTF-8: the input ends inside a multi-byte sequence" : `Invalid UTF-8: byte 0x${byte.toString(16).padStart(2, "0")} cannot appear here`);
+		}
+	});
+	return {
+		push: (chunk) => {
+			const bytes = concat(carry, chunk);
+			const complete = bytes.byteLength - incompleteTail(bytes);
+			carry = bytes.slice(complete);
+			return decode(bytes.subarray(0, complete));
+		},
+		end: () => carry.byteLength === 0 ? "" : decode(carry)
+	};
+};
+const otherDecoder = (charset) => {
+	const position = new Position();
+	let text = Option.none();
+	const run = (chunk) => Result.match(Result.try({
+		try: () => {
+			const decoder = Option.getOrElse(text, () => new TextDecoder(charset, { fatal: true }));
+			text = Option.some(decoder);
+			return Option.match(chunk, {
+				onNone: () => decoder.decode(),
+				onSome: (bytes) => decoder.decode(bytes, { stream: true })
+			});
+		},
+		catch: (error) => error instanceof RangeError ? `Unsupported charset: ${charset}` : `Invalid ${charset}: the input is not well formed`
+	}), {
+		onSuccess: (decoded) => {
+			position.advance(decoded);
+			return decoded;
+		},
+		onFailure: (message) => position.fail(message)
+	});
+	return {
+		push: (chunk) => run(Option.some(chunk)),
+		end: () => run(Option.none())
+	};
+};
+/** A decoder for `charset` (default UTF-8). */
+const make = (charset = "utf-8") => isUtf8(charset) ? utf8Decoder() : otherDecoder(charset);
+/** Whether `push` / `end` failed. */
+const isFailure = (result) => !Predicate.isString(result);
+// src/Serialization.ts
+/**
+* Serialisation interfaces shared by every RDF syntax package.
+*
+* A syntax package (Turtle, JSON-LD, RDF/XML, …) provides a `Parser` and a
+* `Serializer`, usually combined into a `Codec`. Codecs expose an Effect
+* `Schema` transforming `string ⇄ Dataset`, and can be registered in the
+* `Formats` service for media-type based lookup and content negotiation.
+*
+* @since 0.1.0
+*/
+var Serialization_exports = /* @__PURE__ */ __exportAll({
+	Formats: () => Formats,
+	RdfParseError: () => RdfParseError,
+	RdfSerializeError: () => RdfSerializeError,
+	formatError: () => formatError,
+	freshBlankNodePrefix: () => freshBlankNodePrefix,
+	layer: () => layer,
+	makeCodec: () => makeCodec,
+	makeFormat: () => makeFormat,
+	makeParser: () => makeParser,
+	makeSerializer: () => makeSerializer,
+	negotiate: () => negotiate,
+	parseAccept: () => parseAccept,
+	parseBytes: () => parseBytes,
+	parseBytesDocument: () => parseBytesDocument,
+	parserFor: () => parserFor,
+	parserForExtension: () => parserForExtension,
+	readFile: () => readFile,
+	serializeBytes: () => serializeBytes,
+	serializerFor: () => serializerFor,
+	serializerForExtension: () => serializerForExtension,
+	toSchema: () => toSchema,
+	withParseSpan: () => withParseSpan,
+	withSerializeSpan: () => withSerializeSpan,
+	withStreamSpan: () => withStreamSpan,
+	writeFile: () => writeFile
+});
+/**
+* A syntax or semantic error encountered while parsing an RDF document.
+*
+* @since 0.1.0
+* @category errors
+*/
+var RdfParseError = class extends Schema.TaggedError()("RdfParseError", {
+	format: Schema.String,
+	message: Schema.String,
+	line: Schema.optional(Schema.Number),
+	column: Schema.optional(Schema.Number)
+}) {};
+/**
+* An error encountered while serialising quads, e.g. a quad that cannot be
+* represented in the target syntax (a named graph in Turtle).
+*
+* @since 0.1.0
+* @category errors
+*/
+var RdfSerializeError = class extends Schema.TaggedError()("RdfSerializeError", {
+	format: Schema.String,
+	message: Schema.String
+}) {};
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const makeFormat = (format) => ({
+	...format,
+	mediaTypes: format.mediaTypes ?? [format.mediaType]
+});
+/**
+* Builds a `Parser`. When `parseStream` is not provided the stream is
+* buffered and parsed as a whole.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const makeParser = (options) => ({
+	format: options.format,
+	parse: options.parse,
+	parseStream: options.parseStream ?? ((input, parseOptions) => Stream.mkString(input).pipe(Effect.flatMap((text) => options.parse(text, parseOptions)), Effect.map((result) => result.dataset), Stream.fromIterableEffect))
+});
+/**
+* Builds a `Serializer`. When `serializeStream` is not provided the stream is
+* buffered and serialised as a whole.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const makeSerializer = (options) => ({
+	format: options.format,
+	serialize: options.serialize,
+	serializeStream: options.serializeStream ?? ((quads, serializeOptions) => Stream.runCollect(quads).pipe(Effect.flatMap((all) => options.serialize(all, serializeOptions)), Stream.fromEffect))
+});
+/**
+* Combines a parser and serializer into a `Codec`.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const makeCodec = (parser, serializer) => ({
+	format: parser.format,
+	parse: parser.parse,
+	parseStream: parser.parseStream,
+	serialize: serializer.serialize,
+	serializeStream: serializer.serializeStream,
+	schema: toSchema(parser, serializer)
+});
+/**
+* Builds a `Schema` that decodes documents to datasets with `parser` and
+* encodes datasets with `serializer`.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const toSchema = (parser, serializer) => Schema.String.pipe(Schema.decodeTo(DatasetSchema, SchemaTransformation.transformEffect({
+	decode: (input) => parser.parse(input).pipe(Effect.map((r) => r.dataset), Effect.mapError((e) => new SchemaIssue.InvalidValue({ message: formatError(e) }, input))),
+	encode: (dataset) => serializer.serialize(dataset).pipe(Effect.mapError((e) => new SchemaIssue.InvalidValue({ message: e.message }, dataset)))
+})));
+/**
+* Formats a parse error with its position.
+*
+* @since 0.1.0
+* @category errors
+*/
+const formatError = (error) => error.line !== void 0 ? `${error.format} parse error at line ${error.line}${error.column !== void 0 ? `, column ${error.column}` : ""}: ${error.message}` : `${error.format} parse error: ${error.message}`;
+/**
+* A registry of available parsers and serializers, used for media-type
+* lookup and HTTP content negotiation.
+*
+* @since 0.1.0
+* @category services
+*/
+var Formats = class extends Context.Service()("@thomasfosterau/effect-rdf/Formats") {};
+/**
+* Creates a `Formats` layer from codecs, parsers and serializers.
+*
+* @since 0.1.0
+* @category layers
+*/
+const layer = (...entries) => Layer.succeed(Formats, {
+	parsers: entries.filter((e) => "parse" in e),
+	serializers: entries.filter((e) => "serialize" in e)
+});
+const normalizeMediaType = (mediaType) => (mediaType.split(";")[0] ?? "").trim().toLowerCase();
+/**
+* Finds a parser for a media type (parameters such as `charset` are ignored).
+*
+* @since 0.1.0
+* @category lookup
+*/
+const parserFor = (formats, mediaType) => {
+	const mt = normalizeMediaType(mediaType);
+	return Option.fromNullishOr(formats.parsers.find((p) => p.format.mediaTypes.includes(mt)));
+};
+/**
+* Finds a serializer for a media type.
+*
+* @since 0.1.0
+* @category lookup
+*/
+const serializerFor = (formats, mediaType) => {
+	const mt = normalizeMediaType(mediaType);
+	return Option.fromNullishOr(formats.serializers.find((s) => s.format.mediaTypes.includes(mt)));
+};
+/**
+* Finds a parser for a file extension (with or without leading dot).
+*
+* @since 0.1.0
+* @category lookup
+*/
+const parserForExtension = (formats, extension) => {
+	const ext = extension.replace(/^\./, "").toLowerCase();
+	return Option.fromNullishOr(formats.parsers.find((p) => p.format.extensions.includes(ext)));
+};
+/**
+* Finds a serializer for a file extension (with or without leading dot).
+*
+* @since 0.1.0
+* @category lookup
+*/
+const serializerForExtension = (formats, extension) => {
+	const ext = extension.replace(/^\./, "").toLowerCase();
+	return Option.fromNullishOr(formats.serializers.find((s) => s.format.extensions.includes(ext)));
+};
+/**
+* Parses an HTTP `Accept` header, sorted by preference.
+*
+* @since 0.1.0
+* @category negotiation
+*/
+const parseAccept = (header) => Arr.sort(header.split(",").map((part, index) => {
+	const [type, ...params] = part.split(";").map((s) => s.trim());
+	const q = Arr.reduce(params, 1, (acc, p) => {
+		const [k, v] = p.split("=").map((s) => s.trim());
+		return k === "q" && v !== void 0 ? Number(v) : acc;
+	});
+	return {
+		mediaType: (type ?? "").toLowerCase(),
+		q: Number.isNaN(q) ? 0 : q,
+		index
+	};
+}).filter((e) => e.mediaType !== "" && e.q > 0), acceptOrder).map(({ mediaType, q }) => ({
+	mediaType,
+	q
+}));
+/** Highest quality first, then the most specific range, then header order. */
+const acceptOrder = Order.combineAll([
+	Order.flip(Order.mapInput(Order.Number, (e) => e.q)),
+	Order.flip(Order.mapInput(Order.Number, (e) => specificity(e.mediaType))),
+	Order.mapInput(Order.Number, (e) => e.index)
+]);
+const specificity = (mt) => mt === "*/*" ? 0 : mt.endsWith("/*") ? 1 : 2;
+/**
+* Selects the best of `available` media types for an `Accept` header.
+* Returns the first available type when the header is empty or absent.
+*
+* @since 0.1.0
+* @category negotiation
+*/
+const negotiate = (accept, available) => {
+	if (!Arr.isReadonlyArrayNonEmpty(available)) return Option.none();
+	if (accept === void 0 || accept.trim() === "") return Option.some(available[0]);
+	return Arr.findFirst(parseAccept(accept), (entry) => {
+		if (entry.mediaType === "*/*") return Option.some(available[0]);
+		if (entry.mediaType.endsWith("/*")) {
+			const prefix = entry.mediaType.slice(0, -1);
+			return Arr.findFirst(available, (a) => a.startsWith(prefix));
+		}
+		return available.includes(entry.mediaType) ? Option.some(entry.mediaType) : Option.none();
+	});
+};
+/**
+* Generates a fresh blank node label prefix for a parsed document.
+*
+* @since 0.1.0
+* @category utils
+*/
+const freshBlankNodePrefix = () => `b${(documentCounter++).toString(36)}_`;
+let documentCounter = 0;
+const decodeFailure = (format, failure) => new RdfParseError({
+	format: format.name,
+	message: failure.message,
+	line: failure.line,
+	column: failure.column
+});
+/**
+* Parses a stream of bytes (from `FileSystem.stream`, an HTTP body, a socket
+* or a child process) into a stream of quads. The bytes are decoded as UTF-8
+* by default (or as `options.charset`), across chunk boundaries; ill-formed
+* input fails with an `RdfParseError` at the line and column of the bad
+* byte, never a defect.
+*
+* @since 0.1.0
+* @category parsing
+*/
+const parseBytes = (parser, input, options) => Stream.suspend(() => {
+	const decoder = make(options?.charset);
+	const step = (result) => isFailure(result) ? Effect.fail(decodeFailure(parser.format, result)) : Effect.succeed(result);
+	const text = input.pipe(Stream.mapEffect((chunk) => step(decoder.push(chunk))), Stream.concat(Stream.fromEffect(Effect.suspend(() => step(decoder.end())))), Stream.filter((chunk) => chunk !== ""));
+	return parser.parseStream(text, options);
+});
+/**
+* Decodes a complete document's bytes as `parseBytes` does, then parses it
+* with `parser.parse` (so the result keeps the document's prefixes and base).
+*
+* @since 0.1.0
+* @category parsing
+*/
+const parseBytesDocument = (parser, input, options) => Effect.suspend(() => {
+	const decoder = make(options?.charset);
+	const body = decoder.push(input);
+	if (isFailure(body)) return Effect.fail(decodeFailure(parser.format, body));
+	const rest = decoder.end();
+	if (isFailure(rest)) return Effect.fail(decodeFailure(parser.format, rest));
+	return parser.parse(body + rest, options);
+});
+/**
+* Serialises quads to a stream of UTF-8 bytes.
+*
+* @since 0.1.0
+* @category serializing
+*/
+const serializeBytes = (serializer, quads, options) => Stream.encodeText(serializer.serializeStream(Stream.fromIterable(quads), options));
+const fromFormats = (explicit, lookup) => Option.isSome(explicit) ? Effect.succeed(explicit) : Effect.map(Effect.serviceOption(Formats), Option.flatMap(lookup));
+/**
+* Reads an RDF file through Effect's platform-agnostic `FileSystem` (the
+* consumer provides `NodeFileSystem`, Bun or another layer). The parser is
+* `options.parser`, or is looked up in the `Formats` service by
+* `options.mediaType` or the file extension. Relative IRIs resolve against
+* the file's `file:` URL unless `options.baseIri` is given.
+*
+* @since 0.1.0
+* @category files
+*/
+const readFile = (path, options) => Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const paths = yield* Path.Path;
+	const mediaType = options?.mediaType;
+	const parser = yield* fromFormats(Option.fromUndefinedOr(options?.parser), (formats) => mediaType === void 0 ? parserForExtension(formats, paths.extname(path)) : parserFor(formats, mediaType));
+	if (Option.isNone(parser)) return yield* new RdfParseError({
+		format: "unknown",
+		message: `No parser for ${mediaType ?? path} (provide one, or a Formats layer that has one)`
+	});
+	const bytes = yield* fs.readFile(path);
+	const baseIri = options?.baseIri ?? Option.getOrUndefined(Option.map(yield* Effect.option(paths.toFileUrl(paths.resolve(path))), (url) => url.href));
+	return yield* parseBytesDocument(parser.value, bytes, {
+		...options,
+		baseIri
+	});
+});
+/**
+* Writes quads to an RDF file through Effect's `FileSystem`, as UTF-8. The
+* serializer is `options.serializer`, or is looked up in the `Formats`
+* service by `options.mediaType` or the file extension.
+*
+* @since 0.1.0
+* @category files
+*/
+const writeFile = (path, quads, options) => Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const paths = yield* Path.Path;
+	const mediaType = options?.mediaType;
+	const serializer = yield* fromFormats(Option.fromUndefinedOr(options?.serializer), (formats) => mediaType === void 0 ? serializerForExtension(formats, paths.extname(path)) : serializerFor(formats, mediaType));
+	if (Option.isNone(serializer)) return yield* new RdfSerializeError({
+		format: "unknown",
+		message: `No serializer for ${mediaType ?? path} (provide one, or a Formats layer that has one)`
+	});
+	return yield* Stream.run(serializeBytes(serializer.value, quads, options), fs.sink(path));
+});
+const formatAttributes = (format) => ({
+	"rdf.format": format.name,
+	"rdf.media_type": format.mediaType
+});
+/**
+* Wraps a whole-document parse in a span named `<module>.<operation>`
+* (`operation` defaults to `parse`), with the format, media type and input
+* length in characters as attributes and the number of statements parsed
+* (`rdf.quads`, which counts a statement the document repeats each time) on
+* completion. The input text itself is never recorded.
+* With no target the effect is returned unchanged.
+*
+* @since 0.1.0
+* @category tracing
+*/
+const withParseSpan = (target, input, operation = "parse") => (self) => target === void 0 ? self : self.pipe(Effect.tap((result) => Effect.annotateCurrentSpan("rdf.quads", statementCount(result.dataset))), Effect.withSpan(`${target.module}.${operation}`, { attributes: {
+	...formatAttributes(target.format),
+	"rdf.input.length": input.length
+} }));
+/**
+* Wraps a whole-document serialisation in a span named
+* `<module>.serialize`, with the format and media type as attributes and the
+* output length in characters (`rdf.output.length`) on completion. With no
+* target the effect is returned unchanged.
+*
+* @since 0.1.0
+* @category tracing
+*/
+const withSerializeSpan = (target) => (self) => target === void 0 ? self : self.pipe(Effect.tap((output) => Effect.annotateCurrentSpan("rdf.output.length", output.length)), Effect.withSpan(`${target.module}.serialize`, { attributes: formatAttributes(target.format) }));
+/**
+* Wraps a streaming parse or serialisation in a span named
+* `<module>.<operation>` (e.g. `Turtle.parseStream`) that lasts while the
+* stream runs, with the format and media type as attributes. Nothing is
+* recorded per element. With no target the stream is returned unchanged.
+*
+* @since 0.1.0
+* @category tracing
+*/
+const withStreamSpan = (target, operation) => (self) => target === void 0 ? self : Stream.withSpan(self, `${target.module}.${operation}`, { attributes: formatAttributes(target.format) });
+export { withParseSpan as C, writeFile as E, toSchema as S, withStreamSpan as T, parserForExtension as _, formatError as a, serializerFor as b, makeCodec as c, makeSerializer as d, negotiate as f, parserFor as g, parseBytesDocument as h, Serialization_exports as i, makeFormat as l, parseBytes as m, RdfParseError as n, freshBlankNodePrefix as o, parseAccept as p, RdfSerializeError as r, layer as s, Formats as t, makeParser as u, readFile as v, withSerializeSpan as w, serializerForExtension as x, serializeBytes as y };
+
+//# sourceMappingURL=Serialization-DP9H5bYQ.mjs.map

package/dist/Serialization-DP9H5bYQ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Serialization-DP9H5bYQ.mjs","names":["Dataset.DatasetSchema","TextDecoder.make","TextDecoder.isFailure"],"sources":["../src/internal/textDecoder.ts","../src/Serialization.ts"],"sourcesContent":["/**\n * Incremental, strict text decoding for the byte entry points of\n * `Serialization`. Validation is `TextDecoder`'s `fatal` mode; when it\n * rejects UTF-8, a binary search over prefixes finds the exact bad byte, so\n * the failure carries the line and column reached before it. A leading byte\n * order mark is dropped. Other charsets go through a fatal `TextDecoder` too,\n * with failures positioned at the start of the failing chunk.\n */\nimport * as Option from 'effect/Option';\nimport * as Predicate from 'effect/Predicate';\nimport * as Result from 'effect/Result';\n\n/** Where decoding failed: a message, and the 1-based line and column of the bad input. */\nexport interface DecodeFailure {\n  readonly message: string;\n  readonly line: number;\n  readonly column: number;\n}\n\n/** A stateful decoder: `push` each chunk in order, then `end`. */\nexport interface Decoder {\n  /** Decodes a chunk; a sequence split across chunks is completed by the next one. */\n  readonly push: (chunk: Uint8Array) => string | DecodeFailure;\n  /** Flushes the decoder; fails if the input ended inside a sequence. */\n  readonly end: () => string | DecodeFailure;\n}\n\nconst isUtf8 = (charset: string): boolean => /^utf-?8$/i.test(charset.trim());\n\n/** The byte at `i` from the end of `bytes` (1 is the last), if there is one. */\nconst fromEnd = (bytes: Uint8Array, i: number): Option.Option<number> =>\n  Option.fromUndefinedOr(bytes[bytes.length - i]);\n\nconst isContinuation = (b: Option.Option<number>): boolean =>\n  Option.exists(b, (byte) => byte >= 0x80 && byte < 0xc0);\n\n// The length of the sequence a lead byte starts (1 for anything that is not a multi-byte lead).\nconst sequenceLength = (lead: Option.Option<number>): number =>\n  Option.match(lead, {\n    onNone: () => 1,\n    onSome: (l) => (l < 0xc2 ? 1 : l < 0xe0 ? 2 : l < 0xf0 ? 3 : l < 0xf5 ? 4 : 1),\n  });\n\n/**\n * How many trailing bytes start a sequence the chunk does not finish (0–3):\n * they are held back for the next chunk. Whether they are well formed is\n * left to the decoder.\n */\nconst incompleteTail = (bytes: Uint8Array): number => {\n  if (sequenceLength(fromEnd(bytes, 1)) > 1) return 1;\n  if (sequenceLength(fromEnd(bytes, 2)) > 2 && isContinuation(fromEnd(bytes, 1))) return 2;\n  if (\n    sequenceLength(fromEnd(bytes, 3)) > 3 &&\n    isContinuation(fromEnd(bytes, 2)) &&\n    isContinuation(fromEnd(bytes, 1))\n  )\n    return 3;\n  return 0;\n};\n\nconst fatalUtf8 = (bytes: Uint8Array, stream: boolean): Result.Result<string, unknown> =>\n  Result.try(() =>\n    new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(bytes, { stream }),\n  );\n\n/**\n * The length of the longest prefix of `bytes` with no ill-formed byte (an\n * incomplete sequence at its end is allowed), given that `bytes.subarray(0,\n * valid)` has none and `bytes.subarray(0, invalid)` has one.\n */\nconst validPrefix = (bytes: Uint8Array, valid: number, invalid: number): number => {\n  if (invalid - valid <= 1) return valid;\n  const mid = Math.floor((valid + invalid) / 2);\n  return Result.isSuccess(fatalUtf8(bytes.subarray(0, mid), true))\n    ? validPrefix(bytes, mid, invalid)\n    : validPrefix(bytes, valid, mid);\n};\n\nclass Position {\n  line = 1;\n  column = 1;\n  advance(text: string): void {\n    const lines = text.split('\\n');\n    const last = lines.at(-1) ?? '';\n    if (lines.length === 1) this.column += last.length;\n    else {\n      this.line += lines.length - 1;\n      this.column = last.length + 1;\n    }\n  }\n  fail(message: string): DecodeFailure {\n    return { message, line: this.line, column: this.column };\n  }\n}\n\nconst concat = (a: Uint8Array, b: Uint8Array): Uint8Array => {\n  if (a.byteLength === 0) return b;\n  const out = new Uint8Array(a.byteLength + b.byteLength);\n  out.set(a);\n  out.set(b, a.byteLength);\n  return out;\n};\n\nconst utf8Decoder = (): Decoder => {\n  const position = new Position();\n  let carry: Uint8Array = new Uint8Array(0);\n  let atStart = true;\n  // Drop a byte order mark at the very start of the input.\n  const withoutBom = (text: string): string =>\n    atStart && text.startsWith('') ? text.slice(1) : text;\n  const decode = (bytes: Uint8Array): string | DecodeFailure =>\n    Result.match(fatalUtf8(bytes, false), {\n      onSuccess: (text) => {\n        const out = withoutBom(text);\n        if (text !== '') atStart = false;\n        position.advance(out);\n        return out;\n      },\n      onFailure: () => {\n        // Either the bytes end inside a sequence (a streaming decode accepts them) or one is bad.\n        const bad = Result.isSuccess(fatalUtf8(bytes, true))\n          ? bytes.length\n          : validPrefix(bytes, 0, bytes.length);\n        // The text before the bad byte: the valid prefix, without a sequence it leaves unfinished.\n        position.advance(\n          withoutBom(Result.getOrElse(fatalUtf8(bytes.subarray(0, bad), true), () => '')),\n        );\n        const byte = bytes[bad];\n        return position.fail(\n          byte === undefined\n            ? 'Invalid UTF-8: the input ends inside a multi-byte sequence'\n            : `Invalid UTF-8: byte 0x${byte.toString(16).padStart(2, '0')} cannot appear here`,\n        );\n      },\n    });\n  return {\n    push: (chunk) => {\n      const bytes = concat(carry, chunk);\n      const complete = bytes.byteLength - incompleteTail(bytes);\n      carry = bytes.slice(complete);\n      return decode(bytes.subarray(0, complete));\n    },\n    end: () => (carry.byteLength === 0 ? '' : decode(carry)),\n  };\n};\n\nconst otherDecoder = (charset: string): Decoder => {\n  const position = new Position();\n  let text: Option.Option<TextDecoder> = Option.none();\n  const run = (chunk: Option.Option<Uint8Array>): string | DecodeFailure =>\n    Result.match(\n      Result.try({\n        try: () => {\n          const decoder = Option.getOrElse(text, () => new TextDecoder(charset, { fatal: true }));\n          text = Option.some(decoder);\n          return Option.match(chunk, {\n            onNone: () => decoder.decode(),\n            onSome: (bytes) => decoder.decode(bytes, { stream: true }),\n          });\n        },\n        catch: (error) =>\n          error instanceof RangeError\n            ? `Unsupported charset: ${charset}`\n            : `Invalid ${charset}: the input is not well formed`,\n      }),\n      {\n        onSuccess: (decoded) => {\n          position.advance(decoded);\n          return decoded;\n        },\n        onFailure: (message) => position.fail(message),\n      },\n    );\n  return { push: (chunk) => run(Option.some(chunk)), end: () => run(Option.none()) };\n};\n\n/** A decoder for `charset` (default UTF-8). */\nexport const make = (charset: string = 'utf-8'): Decoder =>\n  isUtf8(charset) ? utf8Decoder() : otherDecoder(charset);\n\n/** Whether `push` / `end` failed. */\nexport const isFailure = (result: string | DecodeFailure): result is DecodeFailure =>\n  !Predicate.isString(result);\n","/**\n * Serialisation interfaces shared by every RDF syntax package.\n *\n * A syntax package (Turtle, JSON-LD, RDF/XML, …) provides a `Parser` and a\n * `Serializer`, usually combined into a `Codec`. Codecs expose an Effect\n * `Schema` transforming `string ⇄ Dataset`, and can be registered in the\n * `Formats` service for media-type based lookup and content negotiation.\n *\n * @since 0.1.0\n */\nimport * as Arr from 'effect/Array';\nimport * as Context from 'effect/Context';\nimport * as Effect from 'effect/Effect';\nimport * as FileSystem from 'effect/FileSystem';\nimport * as Layer from 'effect/Layer';\nimport * as Option from 'effect/Option';\nimport * as Order from 'effect/Order';\nimport * as Path from 'effect/Path';\nimport type * as PlatformError from 'effect/PlatformError';\nimport * as Schema from 'effect/Schema';\nimport { statementCount } from './internal/pending.ts';\nimport * as SchemaIssue from 'effect/SchemaIssue';\nimport * as SchemaTransformation from 'effect/SchemaTransformation';\nimport * as Stream from 'effect/Stream';\nimport * as Dataset from './Dataset.ts';\nimport * as PrefixMap from './PrefixMap.ts';\nimport * as TextDecoder from './internal/textDecoder.ts';\nimport type * as Term from './Term.ts';\n\n// -----------------------------------------------------------------------------\n// Errors\n// -----------------------------------------------------------------------------\n\n/**\n * A syntax or semantic error encountered while parsing an RDF document.\n *\n * @since 0.1.0\n * @category errors\n */\nexport class RdfParseError extends Schema.TaggedError<RdfParseError>()('RdfParseError', {\n  format: Schema.String,\n  message: Schema.String,\n  line: Schema.optional(Schema.Number),\n  column: Schema.optional(Schema.Number),\n}) {}\n\n/**\n * An error encountered while serialising quads, e.g. a quad that cannot be\n * represented in the target syntax (a named graph in Turtle).\n *\n * @since 0.1.0\n * @category errors\n */\nexport class RdfSerializeError extends Schema.TaggedError<RdfSerializeError>()(\n  'RdfSerializeError',\n  {\n    format: Schema.String,\n    message: Schema.String,\n  },\n) {}\n\n// -----------------------------------------------------------------------------\n// Formats\n// -----------------------------------------------------------------------------\n\n/**\n * Metadata describing an RDF concrete syntax.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Format {\n  /** Human-readable name, e.g. `\"Turtle\"`. */\n  readonly name: string;\n  /** The preferred media type. */\n  readonly mediaType: string;\n  /** All media types (including the preferred one) that identify the syntax. */\n  readonly mediaTypes: ReadonlyArray<string>;\n  /** File extensions without the leading dot. */\n  readonly extensions: ReadonlyArray<string>;\n  /** Whether the syntax can represent named graphs. */\n  readonly datasets: boolean;\n}\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const makeFormat = (\n  format: Omit<Format, 'mediaTypes'> & { readonly mediaTypes?: ReadonlyArray<string> },\n): Format => ({\n  ...format,\n  mediaTypes: format.mediaTypes ?? [format.mediaType],\n});\n\n// -----------------------------------------------------------------------------\n// Parsing\n// -----------------------------------------------------------------------------\n\n/**\n * @since 0.1.0\n * @category models\n */\nexport interface ParseOptions {\n  /** The base IRI against which relative IRIs are resolved. */\n  readonly baseIri?: string | undefined;\n  /**\n   * The graph in which triples are placed when parsing a triples-only syntax.\n   * Defaults to the default graph.\n   */\n  readonly graph?: Term.Graph | undefined;\n  /**\n   * Prefix for generated blank node labels. Defaults to a fresh prefix per\n   * document so that blank nodes from different documents never clash.\n   */\n  readonly blankNodePrefix?: string | undefined;\n}\n\n/**\n * The result of parsing a complete document.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface ParseResult {\n  readonly dataset: Dataset.Dataset;\n  /** Prefixes declared by the document, if the syntax supports them. */\n  readonly prefixes: PrefixMap.PrefixMap;\n  /** The final base IRI of the document, if any. */\n  readonly baseIri: string | undefined;\n}\n\n/**\n * @since 0.1.0\n * @category models\n */\nexport interface Parser<Options extends ParseOptions = ParseOptions> {\n  readonly format: Format;\n  /** Parses a complete document. */\n  readonly parse: (input: string, options?: Options) => Effect.Effect<ParseResult, RdfParseError>;\n  /** Parses a stream of text chunks into a stream of quads. */\n  readonly parseStream: <E, R>(\n    input: Stream.Stream<string, E, R>,\n    options?: Options,\n  ) => Stream.Stream<Term.Quad, RdfParseError | E, R>;\n}\n\n/**\n * Builds a `Parser`. When `parseStream` is not provided the stream is\n * buffered and parsed as a whole.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const makeParser = <Options extends ParseOptions = ParseOptions>(options: {\n  readonly format: Format;\n  readonly parse: (input: string, options?: Options) => Effect.Effect<ParseResult, RdfParseError>;\n  readonly parseStream?: Parser<Options>['parseStream'];\n}): Parser<Options> => ({\n  format: options.format,\n  parse: options.parse,\n  parseStream:\n    options.parseStream ??\n    (<E, R>(input: Stream.Stream<string, E, R>, parseOptions?: Options) =>\n      Stream.mkString(input).pipe(\n        Effect.flatMap((text) => options.parse(text, parseOptions)),\n        Effect.map((result) => result.dataset),\n        Stream.fromIterableEffect,\n      )),\n});\n\n// -----------------------------------------------------------------------------\n// Serialising\n// -----------------------------------------------------------------------------\n\n/**\n * @since 0.1.0\n * @category models\n */\nexport interface SerializeOptions {\n  /** Prefixes to use for abbreviating IRIs, if the syntax supports them. */\n  readonly prefixes?: PrefixMap.PrefixMap | undefined;\n  /** The base IRI used to relativise IRIs, if the syntax supports it. */\n  readonly baseIri?: string | undefined;\n}\n\n/**\n * @since 0.1.0\n * @category models\n */\nexport interface Serializer<Options extends SerializeOptions = SerializeOptions> {\n  readonly format: Format;\n  /** Serialises quads to a complete document. */\n  readonly serialize: (\n    quads: Iterable<Term.Quad>,\n    options?: Options,\n  ) => Effect.Effect<string, RdfSerializeError>;\n  /** Serialises a stream of quads to a stream of text chunks. */\n  readonly serializeStream: <E, R>(\n    quads: Stream.Stream<Term.Quad, E, R>,\n    options?: Options,\n  ) => Stream.Stream<string, RdfSerializeError | E, R>;\n}\n\n/**\n * Builds a `Serializer`. When `serializeStream` is not provided the stream is\n * buffered and serialised as a whole.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const makeSerializer = <Options extends SerializeOptions = SerializeOptions>(options: {\n  readonly format: Format;\n  readonly serialize: (\n    quads: Iterable<Term.Quad>,\n    options?: Options,\n  ) => Effect.Effect<string, RdfSerializeError>;\n  readonly serializeStream?: Serializer<Options>['serializeStream'];\n}): Serializer<Options> => ({\n  format: options.format,\n  serialize: options.serialize,\n  serializeStream:\n    options.serializeStream ??\n    (<E, R>(quads: Stream.Stream<Term.Quad, E, R>, serializeOptions?: Options) =>\n      Stream.runCollect(quads).pipe(\n        Effect.flatMap((all) => options.serialize(all, serializeOptions)),\n        Stream.fromEffect,\n      )),\n});\n\n// -----------------------------------------------------------------------------\n// Codecs\n// -----------------------------------------------------------------------------\n\n/**\n * A parser and serializer for the same syntax.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Codec<\n  ParseOpts extends ParseOptions = ParseOptions,\n  SerializeOpts extends SerializeOptions = SerializeOptions,\n>\n  extends Parser<ParseOpts>, Serializer<SerializeOpts> {\n  /** A schema transforming documents (`string`) to `Dataset`s and back. */\n  readonly schema: Schema.Codec<Dataset.Dataset, string>;\n}\n\n/**\n * Combines a parser and serializer into a `Codec`.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const makeCodec = <ParseOpts extends ParseOptions, SerializeOpts extends SerializeOptions>(\n  parser: Parser<ParseOpts>,\n  serializer: Serializer<SerializeOpts>,\n): Codec<ParseOpts, SerializeOpts> => ({\n  format: parser.format,\n  parse: parser.parse,\n  parseStream: parser.parseStream,\n  serialize: serializer.serialize,\n  serializeStream: serializer.serializeStream,\n  schema: toSchema(parser, serializer),\n});\n\n/**\n * Builds a `Schema` that decodes documents to datasets with `parser` and\n * encodes datasets with `serializer`.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const toSchema = (\n  parser: Parser<any>,\n  serializer: Serializer<any>,\n): Schema.Codec<Dataset.Dataset, string> =>\n  Schema.String.pipe(\n    Schema.decodeTo(\n      Dataset.DatasetSchema,\n      SchemaTransformation.transformEffect({\n        decode: (input: string) =>\n          parser.parse(input).pipe(\n            Effect.map((r) => r.dataset),\n            Effect.mapError(\n              (e) => new SchemaIssue.InvalidValue({ message: formatError(e) }, input),\n            ),\n          ),\n        encode: (dataset: Dataset.Dataset) =>\n          serializer\n            .serialize(dataset)\n            .pipe(\n              Effect.mapError((e) => new SchemaIssue.InvalidValue({ message: e.message }, dataset)),\n            ),\n      }),\n    ),\n  );\n\n/**\n * Formats a parse error with its position.\n *\n * @since 0.1.0\n * @category errors\n */\nexport const formatError = (error: RdfParseError): string =>\n  error.line !== undefined\n    ? `${error.format} parse error at line ${error.line}${error.column !== undefined ? `, column ${error.column}` : ''}: ${error.message}`\n    : `${error.format} parse error: ${error.message}`;\n\n// -----------------------------------------------------------------------------\n// Registry\n// -----------------------------------------------------------------------------\n\n/**\n * A registry of available parsers and serializers, used for media-type\n * lookup and HTTP content negotiation.\n *\n * @since 0.1.0\n * @category services\n */\nexport class Formats extends Context.Service<\n  Formats,\n  {\n    readonly parsers: ReadonlyArray<Parser<any>>;\n    readonly serializers: ReadonlyArray<Serializer<any>>;\n  }\n>()('@thomasfosterau/effect-rdf/Formats') {}\n\n/**\n * Creates a `Formats` layer from codecs, parsers and serializers.\n *\n * @since 0.1.0\n * @category layers\n */\nexport const layer = (\n  ...entries: ReadonlyArray<Codec<any, any> | Parser<any> | Serializer<any>>\n): Layer.Layer<Formats> =>\n  Layer.succeed(Formats, {\n    parsers: entries.filter((e): e is Parser<any> => 'parse' in e),\n    serializers: entries.filter((e): e is Serializer<any> => 'serialize' in e),\n  });\n\nconst normalizeMediaType = (mediaType: string): string =>\n  (mediaType.split(';')[0] ?? '').trim().toLowerCase();\n\n/**\n * Finds a parser for a media type (parameters such as `charset` are ignored).\n *\n * @since 0.1.0\n * @category lookup\n */\nexport const parserFor = (\n  formats: Formats['Service'],\n  mediaType: string,\n): Option.Option<Parser<any>> => {\n  const mt = normalizeMediaType(mediaType);\n  return Option.fromNullishOr(formats.parsers.find((p) => p.format.mediaTypes.includes(mt)));\n};\n\n/**\n * Finds a serializer for a media type.\n *\n * @since 0.1.0\n * @category lookup\n */\nexport const serializerFor = (\n  formats: Formats['Service'],\n  mediaType: string,\n): Option.Option<Serializer<any>> => {\n  const mt = normalizeMediaType(mediaType);\n  return Option.fromNullishOr(formats.serializers.find((s) => s.format.mediaTypes.includes(mt)));\n};\n\n/**\n * Finds a parser for a file extension (with or without leading dot).\n *\n * @since 0.1.0\n * @category lookup\n */\nexport const parserForExtension = (\n  formats: Formats['Service'],\n  extension: string,\n): Option.Option<Parser<any>> => {\n  const ext = extension.replace(/^\\./, '').toLowerCase();\n  return Option.fromNullishOr(formats.parsers.find((p) => p.format.extensions.includes(ext)));\n};\n\n/**\n * Finds a serializer for a file extension (with or without leading dot).\n *\n * @since 0.1.0\n * @category lookup\n */\nexport const serializerForExtension = (\n  formats: Formats['Service'],\n  extension: string,\n): Option.Option<Serializer<any>> => {\n  const ext = extension.replace(/^\\./, '').toLowerCase();\n  return Option.fromNullishOr(formats.serializers.find((s) => s.format.extensions.includes(ext)));\n};\n\n/**\n * A parsed `Accept` header entry.\n *\n * @since 0.1.0\n * @category negotiation\n */\nexport interface AcceptEntry {\n  readonly mediaType: string;\n  readonly q: number;\n}\n\n/**\n * Parses an HTTP `Accept` header, sorted by preference.\n *\n * @since 0.1.0\n * @category negotiation\n */\nexport const parseAccept = (header: string): ReadonlyArray<AcceptEntry> =>\n  Arr.sort(\n    header\n      .split(',')\n      .map((part, index) => {\n        const [type, ...params] = part.split(';').map((s) => s.trim());\n        // The last `q` parameter wins\n        const q = Arr.reduce(params, 1, (acc, p) => {\n          const [k, v] = p.split('=').map((s) => s.trim());\n          return k === 'q' && v !== undefined ? Number(v) : acc;\n        });\n        return { mediaType: (type ?? '').toLowerCase(), q: Number.isNaN(q) ? 0 : q, index };\n      })\n      .filter((e) => e.mediaType !== '' && e.q > 0),\n    acceptOrder,\n  ).map(({ mediaType, q }) => ({ mediaType, q }));\n\ninterface AcceptCandidate {\n  readonly mediaType: string;\n  readonly q: number;\n  readonly index: number;\n}\n\n/** Highest quality first, then the most specific range, then header order. */\nconst acceptOrder: Order.Order<AcceptCandidate> = Order.combineAll([\n  Order.flip(Order.mapInput(Order.Number, (e: AcceptCandidate) => e.q)),\n  Order.flip(Order.mapInput(Order.Number, (e: AcceptCandidate) => specificity(e.mediaType))),\n  Order.mapInput(Order.Number, (e: AcceptCandidate) => e.index),\n]);\n\nconst specificity = (mt: string): number => (mt === '*/*' ? 0 : mt.endsWith('/*') ? 1 : 2);\n\n/**\n * Selects the best of `available` media types for an `Accept` header.\n * Returns the first available type when the header is empty or absent.\n *\n * @since 0.1.0\n * @category negotiation\n */\nexport const negotiate = (\n  accept: string | undefined,\n  available: ReadonlyArray<string>,\n): Option.Option<string> => {\n  if (!Arr.isReadonlyArrayNonEmpty(available)) return Option.none();\n  if (accept === undefined || accept.trim() === '') return Option.some(available[0]);\n  // The first entry, by preference, that one of the available types satisfies\n  return Arr.findFirst(parseAccept(accept), (entry): Option.Option<string> => {\n    if (entry.mediaType === '*/*') return Option.some(available[0]);\n    if (entry.mediaType.endsWith('/*')) {\n      const prefix = entry.mediaType.slice(0, -1);\n      return Arr.findFirst(available, (a) => a.startsWith(prefix));\n    }\n    return available.includes(entry.mediaType) ? Option.some(entry.mediaType) : Option.none();\n  });\n};\n\n/**\n * Generates a fresh blank node label prefix for a parsed document.\n *\n * @since 0.1.0\n * @category utils\n */\nexport const freshBlankNodePrefix = (): string => `b${(documentCounter++).toString(36)}_`;\n\nlet documentCounter = 0;\n\n// -----------------------------------------------------------------------------\n// Bytes\n// -----------------------------------------------------------------------------\n\n/**\n * Options for reading bytes: a parser's options plus the text encoding.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface BytesOptions {\n  /**\n   * The character encoding of the input, as in a `charset` media-type\n   * parameter. Defaults to UTF-8, which is validated strictly; a leading byte\n   * order mark is dropped.\n   */\n  readonly charset?: string | undefined;\n}\n\nconst decodeFailure = (format: Format, failure: TextDecoder.DecodeFailure): RdfParseError =>\n  new RdfParseError({\n    format: format.name,\n    message: failure.message,\n    line: failure.line,\n    column: failure.column,\n  });\n\n/**\n * Parses a stream of bytes (from `FileSystem.stream`, an HTTP body, a socket\n * or a child process) into a stream of quads. The bytes are decoded as UTF-8\n * by default (or as `options.charset`), across chunk boundaries; ill-formed\n * input fails with an `RdfParseError` at the line and column of the bad\n * byte, never a defect.\n *\n * @since 0.1.0\n * @category parsing\n */\nexport const parseBytes = <Options extends ParseOptions, E, R>(\n  parser: Parser<Options>,\n  input: Stream.Stream<Uint8Array, E, R>,\n  options?: Options & BytesOptions,\n): Stream.Stream<Term.Quad, RdfParseError | E, R> =>\n  Stream.suspend(() => {\n    const decoder = TextDecoder.make(options?.charset);\n    const step = (result: string | TextDecoder.DecodeFailure) =>\n      TextDecoder.isFailure(result)\n        ? Effect.fail(decodeFailure(parser.format, result))\n        : Effect.succeed(result);\n    const text = input.pipe(\n      Stream.mapEffect((chunk) => step(decoder.push(chunk))),\n      Stream.concat(Stream.fromEffect(Effect.suspend(() => step(decoder.end())))),\n      Stream.filter((chunk) => chunk !== ''),\n    );\n    return parser.parseStream(text, options);\n  });\n\n/**\n * Decodes a complete document's bytes as `parseBytes` does, then parses it\n * with `parser.parse` (so the result keeps the document's prefixes and base).\n *\n * @since 0.1.0\n * @category parsing\n */\nexport const parseBytesDocument = <Options extends ParseOptions>(\n  parser: Parser<Options>,\n  input: Uint8Array,\n  options?: Options & BytesOptions,\n): Effect.Effect<ParseResult, RdfParseError> =>\n  Effect.suspend(() => {\n    const decoder = TextDecoder.make(options?.charset);\n    const body = decoder.push(input);\n    if (TextDecoder.isFailure(body)) return Effect.fail(decodeFailure(parser.format, body));\n    const rest = decoder.end();\n    if (TextDecoder.isFailure(rest)) return Effect.fail(decodeFailure(parser.format, rest));\n    return parser.parse(body + rest, options);\n  });\n\n/**\n * Serialises quads to a stream of UTF-8 bytes.\n *\n * @since 0.1.0\n * @category serializing\n */\nexport const serializeBytes = <Options extends SerializeOptions>(\n  serializer: Serializer<Options>,\n  quads: Iterable<Term.Quad>,\n  options?: Options,\n): Stream.Stream<Uint8Array, RdfSerializeError> =>\n  Stream.encodeText(serializer.serializeStream(Stream.fromIterable(quads), options));\n\n// -----------------------------------------------------------------------------\n// Files\n// -----------------------------------------------------------------------------\n\n/**\n * Options for `readFile`.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface ReadFileOptions extends ParseOptions, BytesOptions {\n  /** The parser to use; otherwise one is chosen by `mediaType` or the file extension. */\n  readonly parser?: Parser<any> | undefined;\n  /** A media type to find the parser by in the `Formats` service. */\n  readonly mediaType?: string | undefined;\n}\n\n/**\n * Options for `writeFile`.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface WriteFileOptions extends SerializeOptions {\n  /** The serializer to use; otherwise one is chosen by `mediaType` or the file extension. */\n  readonly serializer?: Serializer<any> | undefined;\n  /** A media type to find the serializer by in the `Formats` service. */\n  readonly mediaType?: string | undefined;\n}\n\nconst fromFormats = <A>(\n  explicit: Option.Option<A>,\n  lookup: (formats: Formats['Service']) => Option.Option<A>,\n): Effect.Effect<Option.Option<A>> =>\n  Option.isSome(explicit)\n    ? Effect.succeed(explicit)\n    : Effect.map(Effect.serviceOption(Formats), Option.flatMap(lookup));\n\n/**\n * Reads an RDF file through Effect's platform-agnostic `FileSystem` (the\n * consumer provides `NodeFileSystem`, Bun or another layer). The parser is\n * `options.parser`, or is looked up in the `Formats` service by\n * `options.mediaType` or the file extension. Relative IRIs resolve against\n * the file's `file:` URL unless `options.baseIri` is given.\n *\n * @since 0.1.0\n * @category files\n */\nexport const readFile = (\n  path: string,\n  options?: ReadFileOptions,\n): Effect.Effect<\n  ParseResult,\n  RdfParseError | PlatformError.PlatformError,\n  FileSystem.FileSystem | Path.Path\n> =>\n  Effect.gen(function* () {\n    const fs = yield* FileSystem.FileSystem;\n    const paths = yield* Path.Path;\n    const mediaType = options?.mediaType;\n    const parser = yield* fromFormats(Option.fromUndefinedOr(options?.parser), (formats) =>\n      mediaType === undefined\n        ? parserForExtension(formats, paths.extname(path))\n        : parserFor(formats, mediaType),\n    );\n    if (Option.isNone(parser)) {\n      return yield* new RdfParseError({\n        format: 'unknown',\n        message: `No parser for ${mediaType ?? path} (provide one, or a Formats layer that has one)`,\n      });\n    }\n    const bytes = yield* fs.readFile(path);\n    const baseIri =\n      options?.baseIri ??\n      Option.getOrUndefined(\n        Option.map(yield* Effect.option(paths.toFileUrl(paths.resolve(path))), (url) => url.href),\n      );\n    return yield* parseBytesDocument(parser.value, bytes, { ...options, baseIri });\n  });\n\n/**\n * Writes quads to an RDF file through Effect's `FileSystem`, as UTF-8. The\n * serializer is `options.serializer`, or is looked up in the `Formats`\n * service by `options.mediaType` or the file extension.\n *\n * @since 0.1.0\n * @category files\n */\nexport const writeFile = (\n  path: string,\n  quads: Iterable<Term.Quad>,\n  options?: WriteFileOptions,\n): Effect.Effect<\n  void,\n  RdfSerializeError | PlatformError.PlatformError,\n  FileSystem.FileSystem | Path.Path\n> =>\n  Effect.gen(function* () {\n    const fs = yield* FileSystem.FileSystem;\n    const paths = yield* Path.Path;\n    const mediaType = options?.mediaType;\n    const serializer = yield* fromFormats(Option.fromUndefinedOr(options?.serializer), (formats) =>\n      mediaType === undefined\n        ? serializerForExtension(formats, paths.extname(path))\n        : serializerFor(formats, mediaType),\n    );\n    if (Option.isNone(serializer)) {\n      return yield* new RdfSerializeError({\n        format: 'unknown',\n        message: `No serializer for ${mediaType ?? path} (provide one, or a Formats layer that has one)`,\n      });\n    }\n    return yield* Stream.run(serializeBytes(serializer.value, quads, options), fs.sink(path));\n  });\n\n// -----------------------------------------------------------------------------\n// Tracing\n// -----------------------------------------------------------------------------\n\n/**\n * What a syntax's spans are named after: `<module>.<operation>` (e.g.\n * `Turtle.parse`), with the format's name and media type as attributes.\n *\n * @since 0.1.0\n * @category tracing\n */\nexport interface SpanTarget {\n  readonly module: string;\n  readonly format: Format;\n}\n\nconst formatAttributes = (format: Format) => ({\n  'rdf.format': format.name,\n  'rdf.media_type': format.mediaType,\n});\n\n/**\n * Wraps a whole-document parse in a span named `<module>.<operation>`\n * (`operation` defaults to `parse`), with the format, media type and input\n * length in characters as attributes and the number of statements parsed\n * (`rdf.quads`, which counts a statement the document repeats each time) on\n * completion. The input text itself is never recorded.\n * With no target the effect is returned unchanged.\n *\n * @since 0.1.0\n * @category tracing\n */\nexport const withParseSpan =\n  (target: SpanTarget | undefined, input: string, operation: string = 'parse') =>\n  <A extends ParseResult, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>\n    target === undefined\n      ? self\n      : self.pipe(\n          // The statements parsed, counted without building a dataset that was not built yet\n          Effect.tap((result) =>\n            Effect.annotateCurrentSpan('rdf.quads', statementCount(result.dataset)),\n          ),\n          Effect.withSpan(`${target.module}.${operation}`, {\n            attributes: { ...formatAttributes(target.format), 'rdf.input.length': input.length },\n          }),\n        );\n\n/**\n * Wraps a whole-document serialisation in a span named\n * `<module>.serialize`, with the format and media type as attributes and the\n * output length in characters (`rdf.output.length`) on completion. With no\n * target the effect is returned unchanged.\n *\n * @since 0.1.0\n * @category tracing\n */\nexport const withSerializeSpan =\n  (target: SpanTarget | undefined) =>\n  <E, R>(self: Effect.Effect<string, E, R>): Effect.Effect<string, E, R> =>\n    target === undefined\n      ? self\n      : self.pipe(\n          Effect.tap((output) => Effect.annotateCurrentSpan('rdf.output.length', output.length)),\n          Effect.withSpan(`${target.module}.serialize`, {\n            attributes: formatAttributes(target.format),\n          }),\n        );\n\n/**\n * Wraps a streaming parse or serialisation in a span named\n * `<module>.<operation>` (e.g. `Turtle.parseStream`) that lasts while the\n * stream runs, with the format and media type as attributes. Nothing is\n * recorded per element. With no target the stream is returned unchanged.\n *\n * @since 0.1.0\n * @category tracing\n */\nexport const withStreamSpan =\n  (target: SpanTarget | undefined, operation: 'parseStream' | 'serializeStream') =>\n  <A, E, R>(self: Stream.Stream<A, E, R>): Stream.Stream<A, E, R> =>\n    target === undefined\n      ? self\n      : Stream.withSpan(self, `${target.module}.${operation}`, {\n          attributes: formatAttributes(target.format),\n        });\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,MAAM,UAAU,YAA6B,YAAY,KAAK,QAAQ,KAAK,CAAC;;AAG5E,MAAM,WAAW,OAAmB,MAClC,OAAO,gBAAgB,MAAM,MAAM,SAAS,EAAE;AAEhD,MAAM,kBAAkB,MACtB,OAAO,OAAO,IAAI,SAAS,QAAQ,OAAQ,OAAO,GAAI;AAGxD,MAAM,kBAAkB,SACtB,OAAO,MAAM,MAAM;CACjB,cAAc;CACd,SAAS,MAAO,IAAI,MAAO,IAAI,IAAI,MAAO,IAAI,IAAI,MAAO,IAAI,IAAI,MAAO,IAAI;AAC9E,CAAC;;;;;;AAOH,MAAM,kBAAkB,UAA8B;CACpD,IAAI,eAAe,QAAQ,OAAO,CAAC,CAAC,IAAI,GAAG,OAAO;CAClD,IAAI,eAAe,QAAQ,OAAO,CAAC,CAAC,IAAI,KAAK,eAAe,QAAQ,OAAO,CAAC,CAAC,GAAG,OAAO;CACvF,IACE,eAAe,QAAQ,OAAO,CAAC,CAAC,IAAI,KACpC,eAAe,QAAQ,OAAO,CAAC,CAAC,KAChC,eAAe,QAAQ,OAAO,CAAC,CAAC,GAEhC,OAAO;CACT,OAAO;AACT;AAEA,MAAM,aAAa,OAAmB,WACpC,OAAO,UACL,IAAI,YAAY,SAAS;CAAE,OAAO;CAAM,WAAW;AAAK,CAAC,CAAC,CAAC,OAAO,OAAO,EAAE,OAAO,CAAC,CACrF;;;;;;AAOF,MAAM,eAAe,OAAmB,OAAe,YAA4B;CACjF,IAAI,UAAU,SAAS,GAAG,OAAO;CACjC,MAAM,MAAM,KAAK,OAAO,QAAQ,WAAW,CAAC;CAC5C,OAAO,OAAO,UAAU,UAAU,MAAM,SAAS,GAAG,GAAG,GAAG,IAAI,CAAC,IAC3D,YAAY,OAAO,KAAK,OAAO,IAC/B,YAAY,OAAO,OAAO,GAAG;AACnC;AAEA,IAAM,WAAN,MAAe;CACb,OAAO;CACP,SAAS;CACT,QAAQ,MAAoB;EAC1B,MAAM,QAAQ,KAAK,MAAM,IAAI;EAC7B,MAAM,OAAO,MAAM,GAAG,EAAE,KAAK;EAC7B,IAAI,MAAM,WAAW,GAAG,KAAK,UAAU,KAAK;OACvC;GACH,KAAK,QAAQ,MAAM,SAAS;GAC5B,KAAK,SAAS,KAAK,SAAS;EAC9B;CACF;CACA,KAAK,SAAgC;EACnC,OAAO;GAAE;GAAS,MAAM,KAAK;GAAM,QAAQ,KAAK;EAAO;CACzD;AACF;AAEA,MAAM,UAAU,GAAe,MAA8B;CAC3D,IAAI,EAAE,eAAe,GAAG,OAAO;CAC/B,MAAM,MAAM,IAAI,WAAW,EAAE,aAAa,EAAE,UAAU;CACtD,IAAI,IAAI,CAAC;CACT,IAAI,IAAI,GAAG,EAAE,UAAU;CACvB,OAAO;AACT;AAEA,MAAM,oBAA6B;CACjC,MAAM,WAAW,IAAI,SAAS;CAC9B,IAAI,wBAAoB,IAAI,WAAW,CAAC;CACxC,IAAI,UAAU;CAEd,MAAM,cAAc,SAClB,WAAW,KAAK,WAAW,GAAG,IAAI,KAAK,MAAM,CAAC,IAAI;CACpD,MAAM,UAAU,UACd,OAAO,MAAM,UAAU,OAAO,KAAK,GAAG;EACpC,YAAY,SAAS;GACnB,MAAM,MAAM,WAAW,IAAI;GAC3B,IAAI,SAAS,IAAI,UAAU;GAC3B,SAAS,QAAQ,GAAG;GACpB,OAAO;EACT;EACA,iBAAiB;GAEf,MAAM,MAAM,OAAO,UAAU,UAAU,OAAO,IAAI,CAAC,IAC/C,MAAM,SACN,YAAY,OAAO,GAAG,MAAM,MAAM;GAEtC,SAAS,QACP,WAAW,OAAO,UAAU,UAAU,MAAM,SAAS,GAAG,GAAG,GAAG,IAAI,SAAS,EAAE,CAAC,CAChF;GACA,MAAM,OAAO,MAAM;GACnB,OAAO,SAAS,KACd,SAAS,KAAA,IACL,+DACA,yBAAyB,KAAK,SAAS,EAAE,CAAC,CAAC,SAAS,GAAG,GAAG,EAAE,oBAClE;EACF;CACF,CAAC;CACH,OAAO;EACL,OAAO,UAAU;GACf,MAAM,QAAQ,OAAO,OAAO,KAAK;GACjC,MAAM,WAAW,MAAM,aAAa,eAAe,KAAK;GACxD,QAAQ,MAAM,MAAM,QAAQ;GAC5B,OAAO,OAAO,MAAM,SAAS,GAAG,QAAQ,CAAC;EAC3C;EACA,WAAY,MAAM,eAAe,IAAI,KAAK,OAAO,KAAK;CACxD;AACF;AAEA,MAAM,gBAAgB,YAA6B;CACjD,MAAM,WAAW,IAAI,SAAS;CAC9B,IAAI,OAAmC,OAAO,KAAK;CACnD,MAAM,OAAO,UACX,OAAO,MACL,OAAO,IAAI;EACT,WAAW;GACT,MAAM,UAAU,OAAO,UAAU,YAAY,IAAI,YAAY,SAAS,EAAE,OAAO,KAAK,CAAC,CAAC;GACtF,OAAO,OAAO,KAAK,OAAO;GAC1B,OAAO,OAAO,MAAM,OAAO;IACzB,cAAc,QAAQ,OAAO;IAC7B,SAAS,UAAU,QAAQ,OAAO,OAAO,EAAE,QAAQ,KAAK,CAAC;GAC3D,CAAC;EACH;EACA,QAAQ,UACN,iBAAiB,aACb,wBAAwB,YACxB,WAAW,QAAQ;CAC3B,CAAC,GACD;EACE,YAAY,YAAY;GACtB,SAAS,QAAQ,OAAO;GACxB,OAAO;EACT;EACA,YAAY,YAAY,SAAS,KAAK,OAAO;CAC/C,CACF;CACF,OAAO;EAAE,OAAO,UAAU,IAAI,OAAO,KAAK,KAAK,CAAC;EAAG,WAAW,IAAI,OAAO,KAAK,CAAC;CAAE;AACnF;;AAGA,MAAa,QAAQ,UAAkB,YACrC,OAAO,OAAO,IAAI,YAAY,IAAI,aAAa,OAAO;;AAGxD,MAAa,aAAa,WACxB,CAAC,UAAU,SAAS,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC/I5B,IAAa,gBAAb,cAAmC,OAAO,YAA2B,CAAC,CAAC,iBAAiB;CACtF,QAAQ,OAAO;CACf,SAAS,OAAO;CAChB,MAAM,OAAO,SAAS,OAAO,MAAM;CACnC,QAAQ,OAAO,SAAS,OAAO,MAAM;AACvC,CAAC,CAAC,CAAC,CAAC;;;;;;;;AASJ,IAAa,oBAAb,cAAuC,OAAO,YAA+B,CAAC,CAC5E,qBACA;CACE,QAAQ,OAAO;CACf,SAAS,OAAO;AAClB,CACF,CAAC,CAAC,CAAC;;;;;AA6BH,MAAa,cACX,YACY;CACZ,GAAG;CACH,YAAY,OAAO,cAAc,CAAC,OAAO,SAAS;AACpD;;;;;;;;AA6DA,MAAa,cAA2D,aAIhD;CACtB,QAAQ,QAAQ;CAChB,OAAO,QAAQ;CACf,aACE,QAAQ,iBACA,OAAoC,iBAC1C,OAAO,SAAS,KAAK,CAAC,CAAC,KACrB,OAAO,SAAS,SAAS,QAAQ,MAAM,MAAM,YAAY,CAAC,GAC1D,OAAO,KAAK,WAAW,OAAO,OAAO,GACrC,OAAO,kBACT;AACN;;;;;;;;AA0CA,MAAa,kBAAuE,aAOxD;CAC1B,QAAQ,QAAQ;CAChB,WAAW,QAAQ;CACnB,iBACE,QAAQ,qBACA,OAAuC,qBAC7C,OAAO,WAAW,KAAK,CAAC,CAAC,KACvB,OAAO,SAAS,QAAQ,QAAQ,UAAU,KAAK,gBAAgB,CAAC,GAChE,OAAO,UACT;AACN;;;;;;;AA2BA,MAAa,aACX,QACA,gBACqC;CACrC,QAAQ,OAAO;CACf,OAAO,OAAO;CACd,aAAa,OAAO;CACpB,WAAW,WAAW;CACtB,iBAAiB,WAAW;CAC5B,QAAQ,SAAS,QAAQ,UAAU;AACrC;;;;;;;;AASA,MAAa,YACX,QACA,eAEA,OAAO,OAAO,KACZ,OAAO,SACLA,eACA,qBAAqB,gBAAgB;CACnC,SAAS,UACP,OAAO,MAAM,KAAK,CAAC,CAAC,KAClB,OAAO,KAAK,MAAM,EAAE,OAAO,GAC3B,OAAO,UACJ,MAAM,IAAI,YAAY,aAAa,EAAE,SAAS,YAAY,CAAC,EAAE,GAAG,KAAK,CACxE,CACF;CACF,SAAS,YACP,WACG,UAAU,OAAO,CAAC,CAClB,KACC,OAAO,UAAU,MAAM,IAAI,YAAY,aAAa,EAAE,SAAS,EAAE,QAAQ,GAAG,OAAO,CAAC,CACtF;AACN,CAAC,CACH,CACF;;;;;;;AAQF,MAAa,eAAe,UAC1B,MAAM,SAAS,KAAA,IACX,GAAG,MAAM,OAAO,uBAAuB,MAAM,OAAO,MAAM,WAAW,KAAA,IAAY,YAAY,MAAM,WAAW,GAAG,IAAI,MAAM,YAC3H,GAAG,MAAM,OAAO,gBAAgB,MAAM;;;;;;;;AAa5C,IAAa,UAAb,cAA6B,QAAQ,QAMnC,CAAC,CAAC,oCAAoC,CAAC,CAAC,CAAC;;;;;;;AAQ3C,MAAa,SACX,GAAG,YAEH,MAAM,QAAQ,SAAS;CACrB,SAAS,QAAQ,QAAQ,MAAwB,WAAW,CAAC;CAC7D,aAAa,QAAQ,QAAQ,MAA4B,eAAe,CAAC;AAC3E,CAAC;AAEH,MAAM,sBAAsB,eACzB,UAAU,MAAM,GAAG,CAAC,CAAC,MAAM,GAAA,CAAI,KAAK,CAAC,CAAC,YAAY;;;;;;;AAQrD,MAAa,aACX,SACA,cAC+B;CAC/B,MAAM,KAAK,mBAAmB,SAAS;CACvC,OAAO,OAAO,cAAc,QAAQ,QAAQ,MAAM,MAAM,EAAE,OAAO,WAAW,SAAS,EAAE,CAAC,CAAC;AAC3F;;;;;;;AAQA,MAAa,iBACX,SACA,cACmC;CACnC,MAAM,KAAK,mBAAmB,SAAS;CACvC,OAAO,OAAO,cAAc,QAAQ,YAAY,MAAM,MAAM,EAAE,OAAO,WAAW,SAAS,EAAE,CAAC,CAAC;AAC/F;;;;;;;AAQA,MAAa,sBACX,SACA,cAC+B;CAC/B,MAAM,MAAM,UAAU,QAAQ,OAAO,EAAE,CAAC,CAAC,YAAY;CACrD,OAAO,OAAO,cAAc,QAAQ,QAAQ,MAAM,MAAM,EAAE,OAAO,WAAW,SAAS,GAAG,CAAC,CAAC;AAC5F;;;;;;;AAQA,MAAa,0BACX,SACA,cACmC;CACnC,MAAM,MAAM,UAAU,QAAQ,OAAO,EAAE,CAAC,CAAC,YAAY;CACrD,OAAO,OAAO,cAAc,QAAQ,YAAY,MAAM,MAAM,EAAE,OAAO,WAAW,SAAS,GAAG,CAAC,CAAC;AAChG;;;;;;;AAmBA,MAAa,eAAe,WAC1B,IAAI,KACF,OACG,MAAM,GAAG,CAAC,CACV,KAAK,MAAM,UAAU;CACpB,MAAM,CAAC,MAAM,GAAG,UAAU,KAAK,MAAM,GAAG,CAAC,CAAC,KAAK,MAAM,EAAE,KAAK,CAAC;CAE7D,MAAM,IAAI,IAAI,OAAO,QAAQ,IAAI,KAAK,MAAM;EAC1C,MAAM,CAAC,GAAG,KAAK,EAAE,MAAM,GAAG,CAAC,CAAC,KAAK,MAAM,EAAE,KAAK,CAAC;EAC/C,OAAO,MAAM,OAAO,MAAM,KAAA,IAAY,OAAO,CAAC,IAAI;CACpD,CAAC;CACD,OAAO;EAAE,YAAY,QAAQ,GAAA,CAAI,YAAY;EAAG,GAAG,OAAO,MAAM,CAAC,IAAI,IAAI;EAAG;CAAM;AACpF,CAAC,CAAC,CACD,QAAQ,MAAM,EAAE,cAAc,MAAM,EAAE,IAAI,CAAC,GAC9C,WACF,CAAC,CAAC,KAAK,EAAE,WAAW,SAAS;CAAE;CAAW;AAAE,EAAE;;AAShD,MAAM,cAA4C,MAAM,WAAW;CACjE,MAAM,KAAK,MAAM,SAAS,MAAM,SAAS,MAAuB,EAAE,CAAC,CAAC;CACpE,MAAM,KAAK,MAAM,SAAS,MAAM,SAAS,MAAuB,YAAY,EAAE,SAAS,CAAC,CAAC;CACzF,MAAM,SAAS,MAAM,SAAS,MAAuB,EAAE,KAAK;AAC9D,CAAC;AAED,MAAM,eAAe,OAAwB,OAAO,QAAQ,IAAI,GAAG,SAAS,IAAI,IAAI,IAAI;;;;;;;;AASxF,MAAa,aACX,QACA,cAC0B;CAC1B,IAAI,CAAC,IAAI,wBAAwB,SAAS,GAAG,OAAO,OAAO,KAAK;CAChE,IAAI,WAAW,KAAA,KAAa,OAAO,KAAK,MAAM,IAAI,OAAO,OAAO,KAAK,UAAU,EAAE;CAEjF,OAAO,IAAI,UAAU,YAAY,MAAM,IAAI,UAAiC;EAC1E,IAAI,MAAM,cAAc,OAAO,OAAO,OAAO,KAAK,UAAU,EAAE;EAC9D,IAAI,MAAM,UAAU,SAAS,IAAI,GAAG;GAClC,MAAM,SAAS,MAAM,UAAU,MAAM,GAAG,EAAE;GAC1C,OAAO,IAAI,UAAU,YAAY,MAAM,EAAE,WAAW,MAAM,CAAC;EAC7D;EACA,OAAO,UAAU,SAAS,MAAM,SAAS,IAAI,OAAO,KAAK,MAAM,SAAS,IAAI,OAAO,KAAK;CAC1F,CAAC;AACH;;;;;;;AAQA,MAAa,6BAAqC,KAAK,kBAAA,CAAmB,SAAS,EAAE,EAAE;AAEvF,IAAI,kBAAkB;AAqBtB,MAAM,iBAAiB,QAAgB,YACrC,IAAI,cAAc;CAChB,QAAQ,OAAO;CACf,SAAS,QAAQ;CACjB,MAAM,QAAQ;CACd,QAAQ,QAAQ;AAClB,CAAC;;;;;;;;;;;AAYH,MAAa,cACX,QACA,OACA,YAEA,OAAO,cAAc;CACnB,MAAM,UAAUC,KAAiB,SAAS,OAAO;CACjD,MAAM,QAAQ,WACZC,UAAsB,MAAM,IACxB,OAAO,KAAK,cAAc,OAAO,QAAQ,MAAM,CAAC,IAChD,OAAO,QAAQ,MAAM;CAC3B,MAAM,OAAO,MAAM,KACjB,OAAO,WAAW,UAAU,KAAK,QAAQ,KAAK,KAAK,CAAC,CAAC,GACrD,OAAO,OAAO,OAAO,WAAW,OAAO,cAAc,KAAK,QAAQ,IAAI,CAAC,CAAC,CAAC,CAAC,GAC1E,OAAO,QAAQ,UAAU,UAAU,EAAE,CACvC;CACA,OAAO,OAAO,YAAY,MAAM,OAAO;AACzC,CAAC;;;;;;;;AASH,MAAa,sBACX,QACA,OACA,YAEA,OAAO,cAAc;CACnB,MAAM,UAAUD,KAAiB,SAAS,OAAO;CACjD,MAAM,OAAO,QAAQ,KAAK,KAAK;CAC/B,IAAIC,UAAsB,IAAI,GAAG,OAAO,OAAO,KAAK,cAAc,OAAO,QAAQ,IAAI,CAAC;CACtF,MAAM,OAAO,QAAQ,IAAI;CACzB,IAAIA,UAAsB,IAAI,GAAG,OAAO,OAAO,KAAK,cAAc,OAAO,QAAQ,IAAI,CAAC;CACtF,OAAO,OAAO,MAAM,OAAO,MAAM,OAAO;AAC1C,CAAC;;;;;;;AAQH,MAAa,kBACX,YACA,OACA,YAEA,OAAO,WAAW,WAAW,gBAAgB,OAAO,aAAa,KAAK,GAAG,OAAO,CAAC;AAgCnF,MAAM,eACJ,UACA,WAEA,OAAO,OAAO,QAAQ,IAClB,OAAO,QAAQ,QAAQ,IACvB,OAAO,IAAI,OAAO,cAAc,OAAO,GAAG,OAAO,QAAQ,MAAM,CAAC;;;;;;;;;;;AAYtE,MAAa,YACX,MACA,YAMA,OAAO,IAAI,aAAa;CACtB,MAAM,KAAK,OAAO,WAAW;CAC7B,MAAM,QAAQ,OAAO,KAAK;CAC1B,MAAM,YAAY,SAAS;CAC3B,MAAM,SAAS,OAAO,YAAY,OAAO,gBAAgB,SAAS,MAAM,IAAI,YAC1E,cAAc,KAAA,IACV,mBAAmB,SAAS,MAAM,QAAQ,IAAI,CAAC,IAC/C,UAAU,SAAS,SAAS,CAClC;CACA,IAAI,OAAO,OAAO,MAAM,GACtB,OAAO,OAAO,IAAI,cAAc;EAC9B,QAAQ;EACR,SAAS,iBAAiB,aAAa,KAAK;CAC9C,CAAC;CAEH,MAAM,QAAQ,OAAO,GAAG,SAAS,IAAI;CACrC,MAAM,UACJ,SAAS,WACT,OAAO,eACL,OAAO,IAAI,OAAO,OAAO,OAAO,MAAM,UAAU,MAAM,QAAQ,IAAI,CAAC,CAAC,IAAI,QAAQ,IAAI,IAAI,CAC1F;CACF,OAAO,OAAO,mBAAmB,OAAO,OAAO,OAAO;EAAE,GAAG;EAAS;CAAQ,CAAC;AAC/E,CAAC;;;;;;;;;AAUH,MAAa,aACX,MACA,OACA,YAMA,OAAO,IAAI,aAAa;CACtB,MAAM,KAAK,OAAO,WAAW;CAC7B,MAAM,QAAQ,OAAO,KAAK;CAC1B,MAAM,YAAY,SAAS;CAC3B,MAAM,aAAa,OAAO,YAAY,OAAO,gBAAgB,SAAS,UAAU,IAAI,YAClF,cAAc,KAAA,IACV,uBAAuB,SAAS,MAAM,QAAQ,IAAI,CAAC,IACnD,cAAc,SAAS,SAAS,CACtC;CACA,IAAI,OAAO,OAAO,UAAU,GAC1B,OAAO,OAAO,IAAI,kBAAkB;EAClC,QAAQ;EACR,SAAS,qBAAqB,aAAa,KAAK;CAClD,CAAC;CAEH,OAAO,OAAO,OAAO,IAAI,eAAe,WAAW,OAAO,OAAO,OAAO,GAAG,GAAG,KAAK,IAAI,CAAC;AAC1F,CAAC;AAkBH,MAAM,oBAAoB,YAAoB;CAC5C,cAAc,OAAO;CACrB,kBAAkB,OAAO;AAC3B;;;;;;;;;;;;AAaA,MAAa,iBACV,QAAgC,OAAe,YAAoB,aACtC,SAC5B,WAAW,KAAA,IACP,OACA,KAAK,KAEH,OAAO,KAAK,WACV,OAAO,oBAAoB,aAAa,eAAe,OAAO,OAAO,CAAC,CACxE,GACA,OAAO,SAAS,GAAG,OAAO,OAAO,GAAG,aAAa,EAC/C,YAAY;CAAE,GAAG,iBAAiB,OAAO,MAAM;CAAG,oBAAoB,MAAM;AAAO,EACrF,CAAC,CACH;;;;;;;;;;AAWR,MAAa,qBACV,YACM,SACL,WAAW,KAAA,IACP,OACA,KAAK,KACH,OAAO,KAAK,WAAW,OAAO,oBAAoB,qBAAqB,OAAO,MAAM,CAAC,GACrF,OAAO,SAAS,GAAG,OAAO,OAAO,aAAa,EAC5C,YAAY,iBAAiB,OAAO,MAAM,EAC5C,CAAC,CACH;;;;;;;;;;AAWR,MAAa,kBACV,QAAgC,eACvB,SACR,WAAW,KAAA,IACP,OACA,OAAO,SAAS,MAAM,GAAG,OAAO,OAAO,GAAG,aAAa,EACrD,YAAY,iBAAiB,OAAO,MAAM,EAC5C,CAAC"}