@thomasfosterau/effect-rdf 0.0.0 → 0.1.0

package/dist/Xsd-D2elNhSm.d.mts

@@ -0,0 +1,187 @@
+import { d as NamedNode, l as Literal } from "./Term-B_4ezyXq.mjs";
+import * as Option from "effect/Option";
+import * as BigDecimal from "effect/BigDecimal";
+declare namespace Xsd_d_exports {
+  export { Value, anyURI, boolean, canonicalDecimal, canonicalDouble, canonicalize, date, dateTime, decimal, double, float, fromJs, integer, isIntegerDatatype, isKnownDatatype, isNumericDatatype, isValidLexical, isWellFormed, numericDatatypes, string, toJs, toValue, typed };
+}
+/**
+ * The XSD numeric datatypes recognised by SPARQL, ordered by type promotion.
+ *
+ * @since 0.1.0
+ */
+declare const numericDatatypes: ReadonlySet<string>;
+/**
+ * Whether a datatype IRI is one of the XSD integer types (including derived
+ * types such as `xsd:int`).
+ *
+ * @since 0.1.0
+ */
+declare const isIntegerDatatype: (datatype: string) => boolean;
+/**
+ * Whether a datatype IRI is numeric.
+ *
+ * @since 0.1.0
+ */
+declare const isNumericDatatype: (datatype: string) => boolean;
+/**
+ * Whether this implementation knows the lexical space of a datatype.
+ *
+ * @since 0.1.0
+ */
+declare const isKnownDatatype: (datatype: string) => boolean;
+/**
+ * Checks whether a lexical form is in the lexical space of a datatype.
+ * Unknown datatypes are treated as valid.
+ *
+ * @since 0.1.0
+ */
+declare const isValidLexical: (datatype: string, value: string) => boolean;
+/**
+ * Whether a literal is well-formed: its lexical form is in the lexical space
+ * of its (known) datatype. Language-tagged strings must have a well-formed
+ * BCP 47 tag.
+ *
+ * @since 0.1.0
+ */
+declare const isWellFormed: (self: Literal) => boolean;
+/**
+ * A literal's value in the XSD value space.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type Value = {
+  readonly _tag: 'String';
+  readonly value: string;
+  readonly language: string;
+  readonly direction: 'ltr' | 'rtl' | undefined;
+} | {
+  readonly _tag: 'Boolean';
+  readonly value: boolean;
+} | {
+  readonly _tag: 'Integer';
+  readonly value: bigint;
+} | {
+  readonly _tag: 'Decimal';
+  readonly value: BigDecimal.BigDecimal;
+} | {
+  readonly _tag: 'Float';
+  readonly value: number;
+} | {
+  readonly _tag: 'Double';
+  readonly value: number;
+} | {
+  readonly _tag: 'DateTime';
+  readonly kind: 'dateTime' | 'date' | 'time' | 'gYear' | 'gYearMonth' | 'gMonth' | 'gMonthDay' | 'gDay';
+  /** Milliseconds since the epoch, interpreting missing timezones as UTC. */
+  readonly epochMillis: number;
+  /** Timezone offset in minutes, or `undefined` when absent. */
+  readonly timezone: number | undefined;
+} | {
+  readonly _tag: 'Duration';
+  readonly months: number;
+  readonly seconds: number;
+} | {
+  readonly _tag: 'Other';
+  readonly lexical: string;
+  readonly datatype: string;
+};
+/**
+ * Maps a literal to its value. Ill-formed literals and unknown datatypes map
+ * to `Other`.
+ *
+ * @since 0.1.0
+ */
+declare const toValue: (self: Literal) => Value;
+/**
+ * Formats a number in the canonical `xsd:double` form (e.g. `1.0E0`).
+ *
+ * @since 0.1.0
+ */
+declare const canonicalDouble: (n: number) => string;
+/**
+ * Formats a `BigDecimal` in the canonical `xsd:decimal` form (always
+ * containing a decimal point).
+ *
+ * @since 0.1.0
+ */
+declare const canonicalDecimal: (d: BigDecimal.BigDecimal) => string;
+/**
+ * Returns the canonical form of a literal, or the literal unchanged if its
+ * datatype has no known canonical mapping or it is ill-formed.
+ *
+ * @since 0.1.0
+ */
+declare const canonicalize: (self: Literal) => Literal;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const string: (value: string) => Literal;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const boolean: (value: boolean) => Literal;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const integer: (value: number | bigint) => Literal;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const decimal: (value: BigDecimal.BigDecimal | number | string) => Literal;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const double: (value: number) => Literal;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const float: (value: number) => Literal;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const dateTime: (value: Date) => Literal;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const date: (value: Date) => Literal;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const anyURI: (value: string) => Literal;
+/**
+ * Creates a typed literal from a datatype and lexical form.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const typed: (value: string, datatype: NamedNode) => Literal;
+/**
+ * Converts a JavaScript value to the most natural literal: strings become
+ * `xsd:string`, booleans `xsd:boolean`, integers `xsd:integer`, other numbers
+ * `xsd:double`, bigints `xsd:integer` and dates `xsd:dateTime`.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const fromJs: (value: string | number | bigint | boolean | Date) => Literal;
+/**
+ * Converts a literal to a natural JavaScript value: strings, booleans,
+ * numbers (for integers within the safe range, decimals, floats and doubles),
+ * bigints (for large integers) and `Date`s (for `xsd:dateTime` and
+ * `xsd:date`). Returns `None` for ill-formed literals and unknown datatypes.
+ *
+ * @since 0.1.0
+ */
+declare const toJs: (self: Literal) => Option.Option<string | number | bigint | boolean | Date>;
+export { toValue as C, toJs as S, isNumericDatatype as _, canonicalDecimal as a, numericDatatypes as b, date as c, double as d, float as f, isKnownDatatype as g, isIntegerDatatype as h, boolean as i, dateTime as l, integer as m, Xsd_d_exports as n, canonicalDouble as o, fromJs as p, anyURI as r, canonicalize as s, Value as t, decimal as u, isValidLexical as v, typed as w, string as x, isWellFormed as y };
+//# sourceMappingURL=Xsd-D2elNhSm.d.mts.map

package/dist/Xsd.d.mts

@@ -0,0 +1,2 @@
+import { C as toValue, S as toJs, _ as isNumericDatatype, a as canonicalDecimal, b as numericDatatypes, c as date, d as double, f as float, g as isKnownDatatype, h as isIntegerDatatype, i as boolean, l as dateTime, m as integer, o as canonicalDouble, p as fromJs, r as anyURI, s as canonicalize, t as Value, u as decimal, v as isValidLexical, w as typed, x as string, y as isWellFormed } from "./Xsd-D2elNhSm.mjs";
+export { Value, anyURI, boolean, canonicalDecimal, canonicalDouble, canonicalize, date, dateTime, decimal, double, float, fromJs, integer, isIntegerDatatype, isKnownDatatype, isNumericDatatype, isValidLexical, isWellFormed, numericDatatypes, string, toJs, toValue, typed };

package/dist/Xsd.mjs

@@ -0,0 +1 @@
+export { n as anyURI, r as boolean, i as canonicalDecimal, a as canonicalDouble, o as canonicalize, s as date, c as dateTime, l as decimal, u as double, d as float, f as fromJs, p as integer, m as isIntegerDatatype, h as isKnownDatatype, g as isNumericDatatype, _ as isValidLexical, v as isWellFormed, y as numericDatatypes, b as string, x as toJs, S as toValue, C as typed } from "./Xsd-Cdgx5zRB.mjs";

package/dist/accessors-CEjaojuQ.mjs

@@ -0,0 +1,28 @@
+import { C as set, E as text$1, S as seq, a as bag, d as getLocalized, f as getText, u as getItems, w as setLocalized$1 } from "./Metadata-BbffwGDZ.mjs";
+import { dual } from "effect/Function";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+import * as DateTime from "effect/DateTime";
+// src/xmp/internal/accessors.ts
+/**
+* Factories for the typed property accessors of the schema modules.
+*/
+const text = (iri) => (self) => getText(self, iri);
+const items = (iri) => (self) => getItems(self, iri);
+const localized = (iri) => (self, language) => getLocalized(self, iri, language);
+const boolean = (iri) => (self) => Option.flatMap(getText(self, iri), (value) => value === "True" ? Option.some(true) : value === "False" ? Option.some(false) : Option.none());
+const dualSetter = (f) => dual(2, f);
+const setter = (iri, toValue) => dualSetter((self, value) => set(self, iri, toValue(value)));
+const setText = (iri) => setter(iri, text$1);
+const setBag = (iri) => setter(iri, bag);
+const setSeq = (iri) => setter(iri, seq);
+const setBoolean = (iri) => setter(iri, (value) => text$1(value ? "True" : "False"));
+/** XMP dates are ISO 8601 with a time-zone offset (ISO 16684-1 §8.2.1.1). */
+const setDate = (iri) => setter(iri, (value) => text$1(DateTime.isDateTime(value) ? DateTime.formatIsoOffset(value) : value));
+const isMetadata = (u) => Predicate.hasProperty(u, "properties") && Predicate.hasProperty(u, "about");
+const setLocalized = (iri) => dual((args) => isMetadata(args[0]), (self, value, language) => setLocalized$1(self, iri, value, language));
+const integer = (iri) => (self) => Option.flatMap(getText(self, iri), (value) => /^[+-]?[0-9]+$/.test(value.trim()) ? Option.some(Number(value)) : Option.none());
+const setInteger = (iri) => setter(iri, (value) => text$1(String(Math.trunc(value))));
+export { localized as a, setDate as c, setSeq as d, setText as f, items as i, setInteger as l, dualSetter as n, setBag as o, text as p, integer as r, setBoolean as s, boolean as t, setLocalized as u };
+
+//# sourceMappingURL=accessors-CEjaojuQ.mjs.map

package/dist/accessors-CEjaojuQ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"accessors-CEjaojuQ.mjs","names":["Metadata.getText","Metadata.getItems","Metadata.getLocalized","Metadata.set","Metadata.text","Metadata.bag","Metadata.seq","Metadata.setLocalized"],"sources":["../src/xmp/internal/accessors.ts"],"sourcesContent":["/**\n * Factories for the typed property accessors of the schema modules.\n */\nimport * as DateTime from 'effect/DateTime';\nimport { dual } from 'effect/Function';\nimport * as Option from 'effect/Option';\nimport * as Predicate from 'effect/Predicate';\nimport * as Metadata from '../Metadata.ts';\n\nexport const text =\n  (iri: string) =>\n  (self: Metadata.Metadata): Option.Option<string> =>\n    Metadata.getText(self, iri);\n\nexport const items =\n  (iri: string) =>\n  (self: Metadata.Metadata): Option.Option<ReadonlyArray<string>> =>\n    Metadata.getItems(self, iri);\n\nexport const localized =\n  (iri: string) =>\n  (self: Metadata.Metadata, language?: string): Option.Option<string> =>\n    Metadata.getLocalized(self, iri, language);\n\nexport const boolean =\n  (iri: string) =>\n  (self: Metadata.Metadata): Option.Option<boolean> =>\n    Option.flatMap(Metadata.getText(self, iri), (value) =>\n      value === 'True' ? Option.some(true) : value === 'False' ? Option.some(false) : Option.none(),\n    );\n\nexport const dualSetter = <A>(\n  f: (self: Metadata.Metadata, value: A) => Metadata.Metadata,\n): Metadata.Setter<A> => dual(2, f);\n\nexport const setter = <A>(iri: string, toValue: (value: A) => Metadata.Value): Metadata.Setter<A> =>\n  dualSetter((self: Metadata.Metadata, value: A) => Metadata.set(self, iri, toValue(value)));\n\nexport const setText = (iri: string): Metadata.Setter<string> => setter(iri, Metadata.text);\n\nexport const setBag = (iri: string): Metadata.Setter<Iterable<string>> => setter(iri, Metadata.bag);\n\nexport const setSeq = (iri: string): Metadata.Setter<Iterable<string>> => setter(iri, Metadata.seq);\n\nexport const setBoolean = (iri: string): Metadata.Setter<boolean> =>\n  setter(iri, (value: boolean) => Metadata.text(value ? 'True' : 'False'));\n\n/** XMP dates are ISO 8601 with a time-zone offset (ISO 16684-1 §8.2.1.1). */\nexport const setDate = (iri: string): Metadata.Setter<DateTime.DateTime | string> =>\n  setter(iri, (value: DateTime.DateTime | string) =>\n    Metadata.text(DateTime.isDateTime(value) ? DateTime.formatIsoOffset(value) : value),\n  );\n\nconst isMetadata = (u: unknown): u is Metadata.Metadata =>\n  Predicate.hasProperty(u, 'properties') && Predicate.hasProperty(u, 'about');\n\nexport const setLocalized = (iri: string): Metadata.LocalizedSetter =>\n  dual(\n    (args) => isMetadata(args[0]),\n    (self: Metadata.Metadata, value: string, language?: string) =>\n      Metadata.setLocalized(self, iri, value, language),\n  );\n\nexport const integer =\n  (iri: string) =>\n  (self: Metadata.Metadata): Option.Option<number> =>\n    Option.flatMap(Metadata.getText(self, iri), (value) =>\n      /^[+-]?[0-9]+$/.test(value.trim()) ? Option.some(Number(value)) : Option.none(),\n    );\n\nexport const setInteger = (iri: string): Metadata.Setter<number> =>\n  setter(iri, (value: number) => Metadata.text(String(Math.trunc(value))));\n"],"mappings":";;;;;;;;;AASA,MAAa,QACV,SACA,SACCA,QAAiB,MAAM,GAAG;AAE9B,MAAa,SACV,SACA,SACCC,SAAkB,MAAM,GAAG;AAE/B,MAAa,aACV,SACA,MAAyB,aACxBC,aAAsB,MAAM,KAAK,QAAQ;AAE7C,MAAa,WACV,SACA,SACC,OAAO,QAAQF,QAAiB,MAAM,GAAG,IAAI,UAC3C,UAAU,SAAS,OAAO,KAAK,IAAI,IAAI,UAAU,UAAU,OAAO,KAAK,KAAK,IAAI,OAAO,KAAK,CAC9F;AAEJ,MAAa,cACX,MACuB,KAAK,GAAG,CAAC;AAElC,MAAa,UAAa,KAAa,YACrC,YAAY,MAAyB,UAAaG,IAAa,MAAM,KAAK,QAAQ,KAAK,CAAC,CAAC;AAE3F,MAAa,WAAW,QAAyC,OAAO,KAAKC,MAAa;AAE1F,MAAa,UAAU,QAAmD,OAAO,KAAKC,GAAY;AAElG,MAAa,UAAU,QAAmD,OAAO,KAAKC,GAAY;AAElG,MAAa,cAAc,QACzB,OAAO,MAAM,UAAmBF,OAAc,QAAQ,SAAS,OAAO,CAAC;;AAGzE,MAAa,WAAW,QACtB,OAAO,MAAM,UACXA,OAAc,SAAS,WAAW,KAAK,IAAI,SAAS,gBAAgB,KAAK,IAAI,KAAK,CACpF;AAEF,MAAM,cAAc,MAClB,UAAU,YAAY,GAAG,YAAY,KAAK,UAAU,YAAY,GAAG,OAAO;AAE5E,MAAa,gBAAgB,QAC3B,MACG,SAAS,WAAW,KAAK,EAAE,IAC3B,MAAyB,OAAe,aACvCG,eAAsB,MAAM,KAAK,OAAO,QAAQ,CACpD;AAEF,MAAa,WACV,SACA,SACC,OAAO,QAAQP,QAAiB,MAAM,GAAG,IAAI,UAC3C,gBAAgB,KAAK,MAAM,KAAK,CAAC,IAAI,OAAO,KAAK,OAAO,KAAK,CAAC,IAAI,OAAO,KAAK,CAChF;AAEJ,MAAa,cAAc,QACzB,OAAO,MAAM,UAAkBI,OAAc,OAAO,KAAK,MAAM,KAAK,CAAC,CAAC,CAAC"}

package/dist/codec-Lb2T96rv.d.mts

@@ -0,0 +1,20 @@
+import "./Term-B_4ezyXq.mjs";
+import { p as SerializeOptions$1 } from "./Serialization-Df8iVauT.mjs";
+import "effect/Effect";
+import "effect/Stream";
+/**
+ * Options for the N-Triples and N-Quads serializers.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface SerializeOptions extends SerializeOptions$1 {
+  /**
+   * Sort statements (by graph, subject, predicate, object) for a fully
+   * deterministic document. Defaults to `false`, which keeps input order.
+   * Ignored by `serializeStream`.
+   */
+  readonly sort?: boolean | undefined;
+}
+export { SerializeOptions as t };
+//# sourceMappingURL=codec-Lb2T96rv.d.mts.map

package/dist/codec-QNo7IdJF.mjs

@@ -0,0 +1,389 @@
+import { D as compareQuads, O as defaultGraph, c as NamedNode, d as Quad, k as escapeIri, t as BlankNode, y as Triple } from "./Term-CFLG1qu4.mjs";
+import { m as fromIterable } from "./Dataset-BlmlcI7J.mjs";
+import { i as empty } from "./PrefixMap-BHFPDLO-.mjs";
+import { C as withParseSpan, T as withStreamSpan, n as RdfParseError, o as freshBlankNodePrefix, r as RdfSerializeError, w as withSerializeSpan } from "./Serialization-DP9H5bYQ.mjs";
+import { _ as makeLiteral, a as formatIri, c as isAbsoluteIri, f as isIriChar, g as isWritableIri, h as isPnCharsU, i as decodeUchar, r as decodeEchar, s as formatTerm, u as isDigit, v as parseLanguageTag } from "./Lexical-Cg0JHrf6.mjs";
+import * as Arr from "effect/Array";
+import * as Iterable from "effect/Iterable";
+import * as MutableHashMap from "effect/MutableHashMap";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+import * as Effect from "effect/Effect";
+import * as Match from "effect/Match";
+import * as Stream from "effect/Stream";
+// src/ntriples/internal/loop.ts
+/**
+* A loop as a function, for the line parser's scans through escapes (runs
+* of plain characters are skipped with sticky patterns).
+*
+* @internal
+*/
+const naturals = Iterable.makeBy((i) => i);
+/** Calls `step` until it returns `false`. */
+const loop = (step) => {
+	Iterable.some(naturals, () => !step());
+};
+// src/ntriples/internal/lineParser.ts
+/** Spaces and tabs (sticky: matched from `lastIndex`). */
+const WS = /[ \t]*/y;
+/** Runs of string characters that need no decoding, in `"…"` and `'…'` strings (sticky). */
+const PLAIN_DOUBLE = /[^"\\\n\r]*/y;
+const PLAIN_SINGLE = /[^'\\\n\r]*/y;
+/**
+* The rest of a blank node label: `PN_CHARS` and `.` (sticky, by code point).
+* Spelt as a string, so that its escapes stay escapes.
+*/
+const LABEL_REST = /* @__PURE__ */ new RegExp("[A-Za-z0-9_.\\u00B7\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u037D\\u037F-\\u1FFF\\u200C\\u200D\\u203F\\u2040\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\u{10000}-\\u{EFFFF}-]*", "uy");
+/** The `.`s a label ends with, which end the statement instead. */
+const TRAILING_DOTS = /\.+$/;
+/** The characters a language tag (with its direction) may hold (sticky). */
+const LANGUAGE_CHARS = /[a-zA-Z0-9-]*/y;
+/** @internal */
+var SyntaxFailure = class extends Error {
+	line;
+	column;
+	constructor(message, line, column) {
+		super(message);
+		this.line = line;
+		this.column = column;
+	}
+};
+/**
+* A parser for single N-Triples / N-Quads lines. Each line holds at most one
+* statement, so documents can be parsed incrementally line by line.
+*
+* @internal
+*/
+var LineParser = class {
+	input = "";
+	pos = 0;
+	line = 0;
+	blankNodes = MutableHashMap.empty();
+	options;
+	constructor(options) {
+		this.options = options;
+	}
+	/** Parses one line (without its line terminator): its statement, if it holds one. */
+	parseLine(input, line) {
+		this.input = input;
+		this.pos = 0;
+		this.line = line;
+		this.ws();
+		if (this.atEnd() || this.peek() === 35) return Option.none();
+		if (this.input.startsWith("VERSION", this.pos)) {
+			this.pos += 7;
+			this.ws();
+			const q = this.peek();
+			if (q !== 34 && q !== 39) this.fail("Expected a version string after VERSION");
+			this.string(q);
+			this.end();
+			return Option.none();
+		}
+		const subject = this.subject();
+		this.ws();
+		const predicate = this.predicate();
+		this.ws();
+		const object = this.object();
+		this.ws();
+		let graph = this.options.graph;
+		if (this.options.quads) {
+			const c = this.peek();
+			if (c === 60 || c === 95) {
+				graph = c === 60 ? this.iri() : this.blankNode();
+				this.ws();
+			}
+		}
+		if (this.peek() !== 46) this.fail("Expected '.' at the end of the statement");
+		this.pos++;
+		this.end();
+		return Option.some(new Quad(subject, predicate, object, graph));
+	}
+	fail(message, pos = this.pos) {
+		throw new SyntaxFailure(message, this.line, pos + 1);
+	}
+	atEnd() {
+		return this.pos >= this.input.length;
+	}
+	peek() {
+		return this.input.charCodeAt(this.pos);
+	}
+	/** Skips `pattern` (sticky, matching the empty string too) from the current position. */
+	skip(pattern) {
+		pattern.lastIndex = this.pos;
+		pattern.test(this.input);
+		this.pos = pattern.lastIndex;
+	}
+	ws() {
+		const c = this.input.charCodeAt(this.pos);
+		if (c === 32 || c === 9) this.skip(WS);
+	}
+	/** Expects optional whitespace, an optional comment, then end of line. */
+	end() {
+		this.ws();
+		if (!this.atEnd() && this.peek() !== 35) this.fail("Unexpected content after statement");
+	}
+	subject() {
+		const c = this.peek();
+		if (c === 60) {
+			if (this.input.startsWith("<<", this.pos)) this.fail("Triple terms are only allowed in the object position");
+			return this.iri();
+		}
+		if (c === 95) return this.blankNode();
+		return this.fail("Expected an IRI or blank node as subject");
+	}
+	predicate() {
+		if (this.peek() !== 60 || this.input.startsWith("<<", this.pos)) this.fail("Expected an IRI as predicate");
+		return this.iri();
+	}
+	object() {
+		const c = this.peek();
+		if (c === 60) {
+			if (this.input.startsWith("<<(", this.pos)) return this.tripleTerm();
+			if (this.input.startsWith("<<", this.pos)) this.fail("Reified triples are not allowed in N-Triples; use <<( ... )>>");
+			return this.iri();
+		}
+		if (c === 95) return this.blankNode();
+		if (c === 34) return this.literal();
+		return this.fail("Expected an IRI, blank node, literal or triple term as object");
+	}
+	tripleTerm() {
+		this.pos += 3;
+		this.ws();
+		const s = this.subject();
+		this.ws();
+		const p = this.predicate();
+		this.ws();
+		const o = this.object();
+		this.ws();
+		if (!this.input.startsWith(")>>", this.pos)) this.fail("Expected ')>>'");
+		this.pos += 3;
+		return new Triple(s, p, o);
+	}
+	iri() {
+		const start = this.pos;
+		const end = this.input.indexOf(">", start + 1);
+		if (end !== -1) {
+			const plain = this.input.slice(start + 1, end);
+			if (escapeIri(plain) === plain && isAbsoluteIri(plain)) {
+				this.pos = end + 1;
+				return new NamedNode(plain);
+			}
+		}
+		this.pos++;
+		let value = "";
+		let chunk = this.pos;
+		loop(() => {
+			if (this.atEnd()) this.fail("Unterminated IRI", start);
+			const c = this.input.charCodeAt(this.pos);
+			if (c === 62) return false;
+			if (c === 92) {
+				value += this.input.slice(chunk, this.pos);
+				const decoded = decodeUchar(this.input, this.pos);
+				if (Predicate.isTagged(decoded, "Error")) return this.fail(decoded.message);
+				if (!isIriChar(decoded.value.codePointAt(0) ?? 0)) this.fail("Escaped character is not allowed in an IRI");
+				value += decoded.value;
+				this.pos += decoded.length;
+				chunk = this.pos;
+				return true;
+			}
+			if (!isIriChar(c)) this.fail("Invalid character in IRI");
+			this.pos++;
+			return true;
+		});
+		value += this.input.slice(chunk, this.pos);
+		this.pos++;
+		if (!isAbsoluteIri(value)) this.fail(`Relative IRI <${value}> is not allowed`, start);
+		return new NamedNode(value);
+	}
+	blankNode() {
+		const start = this.pos;
+		if (this.input.charCodeAt(this.pos + 1) !== 58) this.fail("Expected a blank node label");
+		this.pos += 2;
+		const first = this.input.codePointAt(this.pos);
+		if (first === void 0 || !isPnCharsU(first) && !isDigit(first)) this.fail("Invalid blank node label");
+		this.pos += first > 65535 ? 2 : 1;
+		this.skip(LABEL_REST);
+		const label = this.input.slice(start + 2, this.pos).replace(TRAILING_DOTS, "");
+		this.pos = start + 2 + label.length;
+		const known = MutableHashMap.get(this.blankNodes, label);
+		if (Option.isSome(known)) return known.value;
+		const node = new BlankNode(this.options.blankNodePrefix + (label.startsWith("_") ? `_${label}` : label));
+		MutableHashMap.set(this.blankNodes, label, node);
+		return node;
+	}
+	/** Parses a short string starting at the opening quote `q`. */
+	string(q) {
+		const start = this.pos;
+		this.pos++;
+		let value = "";
+		let chunk = this.pos;
+		const plain = q === 34 ? PLAIN_DOUBLE : PLAIN_SINGLE;
+		this.skip(plain);
+		if (this.peek() === q) {
+			this.pos++;
+			return this.input.slice(start + 1, this.pos - 1);
+		}
+		loop(() => {
+			this.skip(plain);
+			if (this.atEnd()) this.fail("Unterminated string literal", start);
+			const c = this.input.charCodeAt(this.pos);
+			if (c === q) return false;
+			if (c === 92) {
+				value += this.input.slice(chunk, this.pos);
+				const e = this.input.charCodeAt(this.pos + 1);
+				const echar = decodeEchar(e);
+				if (echar !== void 0) {
+					value += echar;
+					this.pos += 2;
+				} else {
+					const decoded = decodeUchar(this.input, this.pos);
+					if (Predicate.isTagged(decoded, "Error")) return this.fail(decoded.message);
+					value += decoded.value;
+					this.pos += decoded.length;
+				}
+				chunk = this.pos;
+				return true;
+			}
+			if (c === 10 || c === 13) this.fail("Line break in string literal");
+			this.pos++;
+			return true;
+		});
+		value += this.input.slice(chunk, this.pos);
+		this.pos++;
+		return value;
+	}
+	literal() {
+		const start = this.pos;
+		const value = this.string(34);
+		this.ws();
+		const c = this.peek();
+		if (c === 64) {
+			const tagStart = ++this.pos;
+			this.skip(LANGUAGE_CHARS);
+			const tag = parseLanguageTag(this.input.slice(tagStart, this.pos));
+			if (tag === void 0) return this.fail("Invalid language tag", tagStart);
+			return this.made(makeLiteral(value, tag), start);
+		}
+		if (c === 94) {
+			if (this.input.charCodeAt(this.pos + 1) !== 94) this.fail("Expected '^^'");
+			this.pos += 2;
+			this.ws();
+			if (this.peek() !== 60) this.fail("Expected a datatype IRI");
+			return this.made(makeLiteral(value, this.iri()), start);
+		}
+		return this.made(makeLiteral(value, void 0), start);
+	}
+	/** The literal `makeLiteral` made, or a failure at `start` with its message. */
+	made(literal, start) {
+		return Predicate.isString(literal) ? this.fail(literal, start) : literal;
+	}
+};
+/**
+* Splits text into lines on `\n`, `\r` and `\r\n`.
+*
+* @internal
+*/
+const splitLines = (input) => input.includes("\r") ? input.split(LINE_END) : input.split("\n");
+const LINE_END = /\r\n|\r|\n/;
+// src/ntriples/internal/codec.ts
+const makeLineParser = (syntax, options) => new LineParser({
+	quads: syntax.quads,
+	blankNodePrefix: options?.blankNodePrefix ?? freshBlankNodePrefix(),
+	graph: options?.graph ?? defaultGraph
+});
+const toParseError = (syntax) => (cause) => cause instanceof SyntaxFailure ? new RdfParseError({
+	format: syntax.name,
+	message: cause.message,
+	line: cause.line,
+	column: cause.column
+}) : new RdfParseError({
+	format: syntax.name,
+	message: String(cause)
+});
+const stripBom = (line, lineNumber) => lineNumber === 1 && line.charCodeAt(0) === 65279 ? line.slice(1) : line;
+/**
+* Parses a whole document synchronously into an array of quads, in document
+* order.
+*
+* @internal
+*/
+const parseQuads = (syntax, input, options) => Effect.try({
+	try: () => parseLines(makeLineParser(syntax, options), input),
+	catch: toParseError(syntax)
+});
+/** The statements of every line of `input`, in order (throws a `SyntaxFailure`). */
+const parseLines = (parser, input) => {
+	const out = [];
+	splitLines(input).forEach((line, i) => {
+		const q = parser.parseLine(stripBom(line, i + 1), i + 1);
+		if (Option.isSome(q)) out.push(q.value);
+	});
+	return out;
+};
+/** @internal */
+const parse = (syntax, input, options) => Effect.map(parseQuads(syntax, input, options), (quads) => ({
+	dataset: fromIterable(quads),
+	prefixes: empty,
+	baseIri: void 0
+})).pipe(withParseSpan(syntax.trace, input));
+/** @internal */
+const parseStream = (syntax) => (input, options) => Stream.suspend(() => {
+	const parser = makeLineParser(syntax, options);
+	return input.pipe(Stream.splitLines, Stream.mapAccumArrayEffect(() => 0, (lineNumber, lines) => Effect.try({
+		try: () => {
+			const out = [];
+			let n = lineNumber;
+			Arr.forEach(lines, (line) => {
+				n++;
+				const q = parser.parseLine(stripBom(line, n), n);
+				if (Option.isSome(q)) out.push(q.value);
+			});
+			return [n, out];
+		},
+		catch: toParseError(syntax)
+	})));
+}).pipe(withStreamSpan(syntax.trace, "parseStream"));
+var SerializeFailure = class extends Error {};
+const checkIris = Match.type().pipe(Match.withReturnType(), Match.tag("NamedNode", (term) => {
+	if (!isWritableIri(term.value)) throw new SerializeFailure(`Invalid or relative IRI ${term.key}`);
+}), Match.tag("Literal", (term) => checkIris(term.datatype)), Match.tag("Triple", (term) => {
+	checkIris(term.subject);
+	checkIris(term.predicate);
+	checkIris(term.object);
+}), Match.orElse(() => void 0));
+const formatGraph = Match.fn((quad, _syntax, _triple) => quad.graph).pipe(Match.withReturnType(), Match.tag("DefaultGraph", (_graph, _quad, _syntax, triple) => `${triple} .\n`), Match.tag("NamedNode", "BlankNode", (graph, quad, syntax, triple) => {
+	if (!syntax.quads) throw new SerializeFailure(`${syntax.name} cannot represent quads in named graphs: ${quad.key}`);
+	return `${triple} ${formatTerm(graph) ?? ""} .\n`;
+}), Match.orElse((_graph, quad) => {
+	throw new SerializeFailure(`Invalid graph term in ${quad.key}`);
+}));
+const formatQuad = (syntax, quad) => {
+	checkIris(quad.subject);
+	checkIris(quad.predicate);
+	checkIris(quad.object);
+	checkIris(quad.graph);
+	if (Predicate.isTagged(quad.subject, "Triple")) throw new SerializeFailure(`Triple terms are not allowed in the subject position in ${syntax.name}: ${quad.key}`);
+	const s = formatTerm(quad.subject);
+	const o = formatTerm(quad.object);
+	if (s === void 0 || o === void 0 || !Predicate.isTagged(quad.predicate, "NamedNode")) throw new SerializeFailure(`Cannot serialise non-ground quad ${quad.key}`);
+	const triple = `${s} ${formatIri(quad.predicate.value)} ${o}`;
+	return formatGraph(quad, syntax, triple);
+};
+const formatAll = (syntax, quads) => Iterable.reduce(quads, "", (out, q) => out + formatQuad(syntax, q));
+const toSerializeError = (syntax) => (cause) => new RdfSerializeError({
+	format: syntax.name,
+	message: Predicate.isError(cause) ? cause.message : String(cause)
+});
+/** @internal */
+const serialize = (syntax, quads, options) => Effect.try({
+	try: () => formatAll(syntax, options?.sort === true ? Arr.sort(quads, compareQuads) : quads),
+	catch: toSerializeError(syntax)
+}).pipe(withSerializeSpan(syntax.trace));
+/** @internal */
+const serializeStream = (syntax) => (quads, _options) => quads.pipe(Stream.chunks, Stream.mapEffect((chunk) => Effect.try({
+	try: () => formatAll(syntax, chunk),
+	catch: toSerializeError(syntax)
+})), withStreamSpan(syntax.trace, "serializeStream"));
+export { serializeStream as a, serialize as i, parseQuads as n, parseStream as r, parse as t };
+
+//# sourceMappingURL=codec-QNo7IdJF.mjs.map