@thomasfosterau/effect-rdf 0.0.0 → 0.1.0

package/dist/Term-CFLG1qu4.mjs

@@ -0,0 +1,991 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { a as NamedNodeSchema$1, c as TermSchema$1, i as LiteralSchema$1, l as TripleSchema$1, o as QuadSchema$1, r as GroundTermSchema$1, t as BlankNodeSchema$1, u as VariableSchema$1 } from "./TermJson-FAg3lvjl.mjs";
+import * as Equal from "effect/Equal";
+import * as Hash from "effect/Hash";
+import { NodeInspectSymbol } from "effect/Inspectable";
+import { pipeArguments } from "effect/Pipeable";
+import { hasProperty, isString, isTagged } from "effect/Predicate";
+import * as Schema from "effect/Schema";
+import * as SchemaTransformation from "effect/SchemaTransformation";
+import * as Effect from "effect/Effect";
+import * as equivalence from "effect/Equivalence";
+import * as Match from "effect/Match";
+import * as order from "effect/Order";
+import * as SchemaIssue from "effect/SchemaIssue";
+// src/internal/arbitrary.ts
+/**
+* Generation representations for the term declarations' `toCodecArbitrary`
+* hooks: `TermJson`-shaped schemas whose native arbitraries produce realistic
+* values — IRIs from a small pool (so values collide across quads), BCP 47
+* language tags, both base directions, well-formed lexical forms for common
+* XSD datatypes, and triple terms nested at most two deep. Generated data is
+* RDF 1.2: triple terms appear only in the object position (of a quad or of
+* another triple term), never as subjects, as RDF 1.2 Concepts requires.
+*
+* Plain data only (no `Term` import), so `Term` can link to it without a
+* cycle; `Term` decodes these with `fromJson` and checks the result.
+*/
+const XSD$1 = "http://www.w3.org/2001/XMLSchema#";
+const NAMESPACES = [
+	"http://example.org/",
+	"http://example.org/vocab#",
+	"https://example.com/a/b/",
+	"urn:example:"
+];
+const LOCAL_NAMES = [
+	"a",
+	"b",
+	"c",
+	"knows",
+	"name",
+	"Thing",
+	"x-1",
+	"é"
+];
+/** The IRI pool: every namespace × local name. */
+const IRIS = NAMESPACES.flatMap((ns) => LOCAL_NAMES.map((local) => `${ns}${local}`));
+const pattern = (re) => Schema.String.check(Schema.isPattern(re));
+const NamedNode$1 = Schema.Struct({
+	type: Schema.Literal("uri"),
+	value: Schema.Literals(IRIS)
+});
+const BlankNode$1 = Schema.Struct({
+	type: Schema.Literal("bnode"),
+	value: Schema.Literals([
+		"b0",
+		"b1",
+		"b2",
+		"b3",
+		"node"
+	])
+});
+const LANGUAGES = Schema.Literals([
+	"en",
+	"en-gb",
+	"fr",
+	"de-ch-1901",
+	"ar",
+	"zh-hant-tw",
+	"x-private"
+]);
+const typedLiteral = (local, value) => Schema.Struct({
+	type: Schema.Literal("literal"),
+	value,
+	datatype: Schema.Literal(`${XSD$1}${local}`)
+});
+const DATE = "(19|20)[0-9]{2}-(0[1-9]|1[0-2])-(0[1-9]|1[0-9]|2[0-8])";
+const Literal$1 = Schema.Union([
+	Schema.Struct({
+		type: Schema.Literal("literal"),
+		value: Schema.String.check(Schema.isMaxLength(8))
+	}),
+	Schema.Struct({
+		type: Schema.Literal("literal"),
+		value: Schema.Literals([
+			"",
+			"a",
+			"Alice",
+			"hello world",
+			"ünïcödé"
+		]),
+		"xml:lang": LANGUAGES
+	}),
+	Schema.Struct({
+		type: Schema.Literal("literal"),
+		value: Schema.Literals([
+			"a",
+			"שלום",
+			"مرحبا"
+		]),
+		"xml:lang": LANGUAGES,
+		"its:dir": Schema.Literals(["ltr", "rtl"])
+	}),
+	typedLiteral("integer", pattern(/^-?(0|[1-9][0-9]{0,5})$/)),
+	typedLiteral("decimal", pattern(/^-?(0|[1-9][0-9]{0,3})\.[0-9]{1,3}$/)),
+	typedLiteral("double", pattern(/^-?[1-9]\.[0-9]{1,3}E-?[0-9]$/)),
+	typedLiteral("boolean", Schema.Literals(["true", "false"])),
+	typedLiteral("date", pattern(new RegExp(`^${DATE}$`))),
+	typedLiteral("dateTime", pattern(new RegExp(`^${DATE}T([01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9](Z|[+-]0[0-9]:00)?$`)))
+]);
+const Resource = Schema.Union([NamedNode$1, BlankNode$1]);
+const tripleOf = (object) => Schema.Struct({
+	type: Schema.Literal("triple"),
+	value: Schema.Struct({
+		subject: Resource,
+		predicate: NamedNode$1,
+		object
+	})
+});
+const Triple1 = tripleOf(Schema.Union([
+	NamedNode$1,
+	BlankNode$1,
+	Literal$1
+]));
+const Triple$1 = tripleOf(Schema.Union([
+	NamedNode$1,
+	BlankNode$1,
+	Literal$1,
+	Triple1
+]));
+const Variable$1 = Schema.Struct({
+	type: Schema.Literal("variable"),
+	value: Schema.Literals([
+		"s",
+		"p",
+		"o",
+		"x"
+	])
+});
+const DefaultGraph$1 = Schema.Struct({ type: Schema.Literal("default-graph") });
+const GroundTerm = Schema.Union([
+	NamedNode$1,
+	BlankNode$1,
+	Literal$1,
+	Triple$1
+]);
+/** The representation each term declaration's `toCodecArbitrary` links to. */
+const representations = {
+	NamedNode: NamedNode$1,
+	BlankNode: BlankNode$1,
+	Literal: Literal$1,
+	Triple: Triple$1,
+	Variable: Variable$1,
+	DefaultGraph: DefaultGraph$1,
+	GroundTerm,
+	Term: Schema.Union([
+		NamedNode$1,
+		BlankNode$1,
+		Literal$1,
+		Triple$1,
+		Variable$1,
+		DefaultGraph$1
+	]),
+	Quad: Schema.Struct({
+		subject: Resource,
+		predicate: NamedNode$1,
+		object: GroundTerm,
+		graph: Schema.optionalKey(Resource)
+	})
+};
+// src/Term.ts
+/**
+* The RDF 1.2 term model.
+*
+* Terms are immutable values that implement Effect's `Equal` and `Hash`
+* protocols, so they can be used directly as keys of `HashMap`/`HashSet` and
+* compared with `Equal.equals`. Every term carries a canonical `key` — its
+* N-Triples / N-Quads serialisation — which is also what `toString()` returns.
+*
+* The model supports RDF 1.2 (and RDF-star) triple terms, directional
+* language-tagged strings, and SPARQL variables (used only in patterns).
+*
+* @since 0.1.0
+*/
+var Term_exports = /* @__PURE__ */ __exportAll({
+	BlankNode: () => BlankNode,
+	BlankNodeSchema: () => BlankNodeSchema,
+	DefaultGraph: () => DefaultGraph,
+	Equivalence: () => Equivalence,
+	GroundTermSchema: () => GroundTermSchema,
+	Literal: () => Literal,
+	LiteralSchema: () => LiteralSchema,
+	NamedNode: () => NamedNode,
+	NamedNodeSchema: () => NamedNodeSchema,
+	Order: () => Order,
+	Quad: () => Quad,
+	QuadEquivalence: () => QuadEquivalence,
+	QuadOrder: () => QuadOrder,
+	QuadSchema: () => QuadSchema,
+	RDF_DIR_LANG_STRING: () => RDF_DIR_LANG_STRING,
+	RDF_LANG_STRING: () => RDF_LANG_STRING,
+	TermSchema: () => TermSchema,
+	Triple: () => Triple,
+	TripleSchema: () => TripleSchema,
+	TypeId: () => TypeId,
+	Variable: () => Variable,
+	VariableSchema: () => VariableSchema,
+	XSD_STRING: () => XSD_STRING,
+	blankNode: () => blankNode,
+	compare: () => compare,
+	compareQuads: () => compareQuads,
+	defaultGraph: () => defaultGraph,
+	escapeIri: () => escapeIri,
+	escapeString: () => escapeString,
+	fromJson: () => fromJson,
+	hasBlankNodes: () => hasBlankNodes,
+	isBlankNode: () => isBlankNode,
+	isDefaultGraph: () => isDefaultGraph,
+	isGraph: () => isGraph,
+	isGround: () => isGround,
+	isGroundTerm: () => isGroundTerm,
+	isLanguageTagged: () => isLanguageTagged,
+	isLiteral: () => isLiteral,
+	isNamedNode: () => isNamedNode,
+	isObject: () => isObject,
+	isQuad: () => isQuad,
+	isResource: () => isResource,
+	isSubject: () => isSubject,
+	isTerm: () => isTerm,
+	isTriple: () => isTriple,
+	isVariable: () => isVariable,
+	isWellFormed: () => isWellFormed,
+	literal: () => literal,
+	mapTerms: () => mapTerms,
+	namedNode: () => namedNode,
+	quad: () => quad,
+	quadFromJson: () => quadFromJson,
+	quadToJson: () => quadToJson,
+	toJson: () => toJson,
+	toQuad: () => toQuad,
+	triple: () => triple,
+	variable: () => variable
+});
+const RDF = "http://www.w3.org/1999/02/22-rdf-syntax-ns#";
+const XSD = "http://www.w3.org/2001/XMLSchema#";
+/**
+* @since 0.1.0
+* @category symbols
+*/
+const TypeId = Symbol.for("@thomasfosterau/effect-rdf/Term");
+/** `isTerm` for a value already known to be an object. */
+const hasTermTypeId = (u) => TypeId in u;
+/** Mixed into the hashes of blank nodes and variables, so that `_:a` and `?a` differ from `<a>`. */
+const BLANK_SALT = 24378;
+const VARIABLE_SALT = 63;
+var TermBase = class {
+	[TypeId] = TypeId;
+	#key = "";
+	#hash = 0;
+	#hashed = false;
+	/** The canonical N-Triples serialisation of this term. */
+	get key() {
+		if (this.#key === "") this.#key = this.computeKey();
+		return this.#key;
+	}
+	/** RDF/JS compatible alias of `_tag`. */
+	get termType() {
+		return this._tag;
+	}
+	/** RDF/JS compatible equality. */
+	equals(that) {
+		return isTerm(that) && that.key === this.key;
+	}
+	[Equal.symbol](that) {
+		return hasTermTypeId(that) && that.key === this.key;
+	}
+	[Hash.symbol]() {
+		if (!this.#hashed) {
+			this.#hash = this.computeHash();
+			this.#hashed = true;
+		}
+		return this.#hash;
+	}
+	/**
+	* The hash, consistent with `key` (terms with equal keys have equal
+	* hashes). IRIs, blank nodes, variables and literals hash their parts, so
+	* that hashing one builds no key.
+	*/
+	computeHash() {
+		return Hash.string(this.key);
+	}
+	pipe() {
+		return pipeArguments(this, arguments);
+	}
+	toString() {
+		return this.key;
+	}
+	toJSON() {
+		return {
+			_tag: this._tag,
+			value: this.key
+		};
+	}
+	[NodeInspectSymbol]() {
+		return `${this._tag}(${this.key})`;
+	}
+};
+/**
+* An IRI.
+*
+* @since 0.1.0
+* @category models
+*/
+var NamedNode = class extends TermBase {
+	_tag = "NamedNode";
+	value;
+	constructor(value) {
+		super();
+		this.value = value;
+	}
+	computeKey() {
+		return `<${escapeIri(this.value)}>`;
+	}
+	computeHash() {
+		return Hash.string(this.value);
+	}
+};
+/**
+* A blank node. Labels are scoped to the dataset or document that contains
+* them.
+*
+* @since 0.1.0
+* @category models
+*/
+var BlankNode = class extends TermBase {
+	_tag = "BlankNode";
+	value;
+	constructor(value) {
+		super();
+		this.value = value;
+	}
+	computeKey() {
+		return `_:${this.value}`;
+	}
+	computeHash() {
+		return Hash.combine(Hash.string(this.value), BLANK_SALT);
+	}
+};
+/**
+* A literal. Language-tagged strings have datatype `rdf:langString`, and
+* directional language-tagged strings (RDF 1.2) have datatype
+* `rdf:dirLangString`.
+*
+* @since 0.1.0
+* @category models
+*/
+var Literal = class extends TermBase {
+	_tag = "Literal";
+	value;
+	datatype;
+	language;
+	direction;
+	constructor(value, datatype, language = "", direction) {
+		super();
+		this.value = value;
+		this.datatype = datatype;
+		this.language = language;
+		this.direction = direction;
+	}
+	computeKey() {
+		const lexical = `"${escapeString(this.value)}"`;
+		if (this.language !== "") return this.direction === void 0 ? `${lexical}@${this.language}` : `${lexical}@${this.language}--${this.direction}`;
+		if (this.datatype.value === "http://www.w3.org/2001/XMLSchema#string") return lexical;
+		return `${lexical}^^${this.datatype.key}`;
+	}
+	computeHash() {
+		const h = Hash.combine(Hash.string(this.value), this.datatype[Hash.symbol]());
+		return this.language === "" ? h : Hash.combine(h, Hash.string(this.language));
+	}
+};
+/**
+* A SPARQL query variable. Variables never appear in RDF data; they are used
+* in quad patterns.
+*
+* @since 0.1.0
+* @category models
+*/
+var Variable = class extends TermBase {
+	_tag = "Variable";
+	value;
+	constructor(value) {
+		super();
+		this.value = value;
+	}
+	computeKey() {
+		return `?${this.value}`;
+	}
+	computeHash() {
+		return Hash.combine(Hash.string(this.value), VARIABLE_SALT);
+	}
+};
+/**
+* The default graph of a dataset.
+*
+* @since 0.1.0
+* @category models
+*/
+var DefaultGraph = class extends TermBase {
+	_tag = "DefaultGraph";
+	value = "";
+	computeKey() {
+		return "";
+	}
+};
+/**
+* An RDF triple. Triples are also terms (RDF 1.2 "triple terms", RDF-star
+* "quoted triples") and may appear in the subject or object position of
+* other triples.
+*
+* @since 0.1.0
+* @category models
+*/
+var Triple = class extends TermBase {
+	_tag = "Triple";
+	subject;
+	predicate;
+	object;
+	constructor(subject, predicate, object) {
+		super();
+		this.subject = subject;
+		this.predicate = predicate;
+		this.object = object;
+	}
+	computeKey() {
+		return `<<( ${this.subject.key} ${this.predicate.key} ${this.object.key} )>>`;
+	}
+	/** Always the default graph: a triple term carries no graph name. */
+	get graph() {
+		return defaultGraph;
+	}
+};
+/**
+* An RDF quad: a triple together with the graph that contains it.
+*
+* `Quad` is a statement, not a term; use `Triple` for triple terms.
+*
+* @since 0.1.0
+* @category models
+*/
+var Quad = class Quad {
+	_tag = "Quad";
+	#key = "";
+	#hash = 0;
+	#hashed = false;
+	subject;
+	predicate;
+	object;
+	graph;
+	constructor(subject, predicate, object, graph) {
+		this.subject = subject;
+		this.predicate = predicate;
+		this.object = object;
+		this.graph = graph;
+	}
+	/** The canonical N-Quads statement (without the trailing ` .`). */
+	get key() {
+		if (this.#key === "") {
+			const triple = `${this.subject.key} ${this.predicate.key} ${this.object.key}`;
+			this.#key = this.graph._tag === "DefaultGraph" ? triple : `${triple} ${this.graph.key}`;
+		}
+		return this.#key;
+	}
+	/** The triple of this quad, without its graph. */
+	get triple() {
+		return new Triple(this.subject, this.predicate, this.object);
+	}
+	equals(that) {
+		return isQuad(that) && that.key === this.key;
+	}
+	[Equal.symbol](that) {
+		return that instanceof Quad && that.key === this.key;
+	}
+	[Hash.symbol]() {
+		if (!this.#hashed) {
+			this.#hash = Hash.string(this.key);
+			this.#hashed = true;
+		}
+		return this.#hash;
+	}
+	pipe() {
+		return pipeArguments(this, arguments);
+	}
+	toString() {
+		return `${this.key} .`;
+	}
+	toJSON() {
+		return {
+			_tag: "Quad",
+			value: this.toString()
+		};
+	}
+	[NodeInspectSymbol]() {
+		return `Quad(${this.key})`;
+	}
+};
+/**
+* The singleton default graph.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const defaultGraph = new DefaultGraph();
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const namedNode = (iri) => new NamedNode(iri);
+let blankNodeCounter = 0;
+/**
+* Creates a blank node. When no label is given a fresh, process-unique label
+* is generated.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const blankNode = (label) => new BlankNode(label ?? `b${(blankNodeCounter++).toString(36)}`);
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const variable = (name) => new Variable(name);
+/** @internal */
+const XSD_STRING = `${XSD}string`;
+/** @internal */
+const RDF_LANG_STRING = `${RDF}langString`;
+/** @internal */
+const RDF_DIR_LANG_STRING = `${RDF}dirLangString`;
+const xsdString = new NamedNode(XSD_STRING);
+const rdfLangString = new NamedNode(RDF_LANG_STRING);
+const rdfDirLangString = new NamedNode(RDF_DIR_LANG_STRING);
+/**
+* Creates a literal.
+*
+* - `literal("x")` is an `xsd:string`
+* - `literal("x", "en")` is a language-tagged string
+* - `literal("x", { language: "ar", direction: "rtl" })` is a directional
+*   language-tagged string
+* - `literal("1", xsd.integer)` is a typed literal
+*
+* Language tags are normalised to lower case.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const literal = (value, languageOrDatatype) => {
+	if (languageOrDatatype === void 0) return new Literal(value, xsdString);
+	if (isString(languageOrDatatype)) return new Literal(value, rdfLangString, languageOrDatatype.toLowerCase());
+	if ("language" in languageOrDatatype) {
+		const language = languageOrDatatype.language.toLowerCase();
+		return languageOrDatatype.direction === void 0 ? new Literal(value, rdfLangString, language) : new Literal(value, rdfDirLangString, language, languageOrDatatype.direction);
+	}
+	if (languageOrDatatype.value === "http://www.w3.org/1999/02/22-rdf-syntax-ns#langString" || languageOrDatatype.value === "http://www.w3.org/1999/02/22-rdf-syntax-ns#dirLangString") return new Literal(value, xsdString);
+	return new Literal(value, languageOrDatatype);
+};
+/**
+* Creates a triple (and triple term).
+*
+* @since 0.1.0
+* @category constructors
+*/
+const triple = (subject, predicate, object) => new Triple(subject, predicate, object);
+function quad(subject, predicate, object, graph = defaultGraph) {
+	return new Quad(subject, predicate, object, graph);
+}
+/**
+* Converts a triple to a quad in the given graph (default graph when omitted).
+*
+* @since 0.1.0
+* @category constructors
+*/
+const toQuad = (self, graph) => new Quad(self.subject, self.predicate, self.object, graph ?? defaultGraph);
+/**
+* @since 0.1.0
+* @category guards
+*/
+const isTerm = (u) => hasProperty(u, TypeId);
+/**
+* @since 0.1.0
+* @category guards
+*/
+const isNamedNode = (u) => isTerm(u) && isTagged(u, "NamedNode");
+/**
+* @since 0.1.0
+* @category guards
+*/
+const isBlankNode = (u) => isTerm(u) && isTagged(u, "BlankNode");
+/**
+* @since 0.1.0
+* @category guards
+*/
+const isLiteral = (u) => isTerm(u) && isTagged(u, "Literal");
+/**
+* @since 0.1.0
+* @category guards
+*/
+const isVariable = (u) => isTerm(u) && isTagged(u, "Variable");
+/**
+* @since 0.1.0
+* @category guards
+*/
+const isDefaultGraph = (u) => isTerm(u) && isTagged(u, "DefaultGraph");
+/**
+* @since 0.1.0
+* @category guards
+*/
+const isTriple = (u) => isTerm(u) && isTagged(u, "Triple");
+/**
+* @since 0.1.0
+* @category guards
+*/
+const isQuad = (u) => u instanceof Quad;
+/**
+* @since 0.1.0
+* @category guards
+*/
+const isResource = (u) => isNamedNode(u) || isBlankNode(u);
+/**
+* @since 0.1.0
+* @category guards
+*/
+const isSubject = (u) => isNamedNode(u) || isBlankNode(u) || isTriple(u);
+/**
+* @since 0.1.0
+* @category guards
+*/
+const isObject = (u) => isNamedNode(u) || isBlankNode(u) || isLiteral(u) || isTriple(u);
+/**
+* @since 0.1.0
+* @category guards
+*/
+const isGraph = (u) => isNamedNode(u) || isBlankNode(u) || isDefaultGraph(u);
+/**
+* @since 0.1.0
+* @category guards
+*/
+const isGroundTerm = (u) => isNamedNode(u) || isBlankNode(u) || isLiteral(u) || isTriple(u);
+/**
+* Whether a literal is a (possibly directional) language-tagged string.
+*
+* @since 0.1.0
+* @category guards
+*/
+const isLanguageTagged = (self) => self.language !== "";
+const blankNodesIn = Match.type().pipe(Match.tag("BlankNode", () => true), Match.tag("Triple", (self) => hasBlankNodes(self.subject) || hasBlankNodes(self.object)), Match.tag("Quad", (self) => hasBlankNodes(self.subject) || hasBlankNodes(self.object) || hasBlankNodes(self.graph)), Match.orElse(() => false));
+/**
+* Whether a triple or quad mentions a blank node anywhere, including inside
+* nested triple terms.
+*
+* @since 0.1.0
+* @category predicates
+*/
+const hasBlankNodes = (self) => blankNodesIn(self);
+const groundCheck = Match.type().pipe(Match.tag("Variable", () => false), Match.tag("Triple", (self) => isGround(self.subject) && isGround(self.predicate) && isGround(self.object)), Match.tag("Quad", (self) => isGround(self.subject) && isGround(self.predicate) && isGround(self.object) && isGround(self.graph)), Match.orElse(() => true));
+/**
+* Whether a term or quad is free of variables.
+*
+* @since 0.1.0
+* @category predicates
+*/
+const isGround = (self) => groundCheck(self);
+function mapTerms(self, f) {
+	const go = (term) => isTripleTerm(term) ? goTriple(term) : f(term);
+	const goTriple = (term) => {
+		const s = subjectOr(go(term.subject), term.subject);
+		const p = predicateOr(go(term.predicate), term.predicate);
+		const o = objectOr(go(term.object), term.object);
+		return s === term.subject && p === term.predicate && o === term.object ? term : new Triple(s, p, o);
+	};
+	if (isTripleTerm(self)) return goTriple(self);
+	const s = subjectOr(go(self.subject), self.subject);
+	const p = predicateOr(go(self.predicate), self.predicate);
+	const o = objectOr(go(self.object), self.object);
+	const g = graphOr(go(self.graph), self.graph);
+	return s === self.subject && p === self.predicate && o === self.object && g === self.graph ? self : new Quad(s, p, o, g);
+}
+const isTripleTerm = (t) => isTagged(t, "Triple");
+const isResourceTerm = (t) => isTagged(t, "NamedNode") || isTagged(t, "BlankNode");
+const subjectOr = (t, fallback) => isResourceTerm(t) || isTripleTerm(t) ? t : fallback;
+const predicateOr = (t, fallback) => isTagged(t, "NamedNode") ? t : fallback;
+const objectOr = (t, fallback) => isResourceTerm(t) || isTripleTerm(t) || isTagged(t, "Literal") ? t : fallback;
+const graphOr = (t, fallback) => isResourceTerm(t) || isTagged(t, "DefaultGraph") ? t : fallback;
+/**
+* A total ordering of terms suitable for deterministic serialisation:
+* default graph < blank nodes < IRIs < literals < triple terms < variables,
+* then by canonical key.
+*
+* @since 0.1.0
+* @category ordering
+*/
+const compare = (a, b) => {
+	const ra = rank[a._tag];
+	const rb = rank[b._tag];
+	if (ra !== rb) return ra < rb ? -1 : 1;
+	return a.key < b.key ? -1 : a.key > b.key ? 1 : 0;
+};
+const rank = {
+	DefaultGraph: 0,
+	BlankNode: 1,
+	NamedNode: 2,
+	Literal: 3,
+	Triple: 4,
+	Variable: 5
+};
+/**
+* Orders quads by graph, subject, predicate, object.
+*
+* @since 0.1.0
+* @category ordering
+*/
+const compareQuads = (a, b) => compare(a.graph, b.graph) || compare(a.subject, b.subject) || compare(a.predicate, b.predicate) || compare(a.object, b.object);
+/**
+* The `compare` ordering of terms as an Effect `Order`, for `Array.sort`,
+* `Order.mapInput` and the other `Order` combinators.
+*
+* @since 0.1.0
+* @category ordering
+*/
+const Order = order.make(compare);
+/**
+* The `compareQuads` ordering (graph, subject, predicate, object) as an
+* Effect `Order`.
+*
+* @since 0.1.0
+* @category ordering
+*/
+const QuadOrder = order.make(compareQuads);
+/**
+* Term equality as an Effect `Equivalence`: the same as `Equal.equals`
+* (equal canonical keys).
+*
+* @since 0.1.0
+* @category equivalence
+*/
+const Equivalence = equivalence.make((a, b) => a.key === b.key);
+/**
+* Quad equality as an Effect `Equivalence`: the same as `Equal.equals`.
+*
+* @since 0.1.0
+* @category equivalence
+*/
+const QuadEquivalence = equivalence.make((a, b) => a.key === b.key);
+const escapeChar = Match.type().pipe(Match.when("\"", () => "\\\""), Match.when("\\", () => "\\\\"), Match.when("\n", () => "\\n"), Match.when("\r", () => "\\r"), Match.when("	", () => "\\t"), Match.when("\b", () => "\\b"), Match.when("\f", () => "\\f"), Match.orElse((ch) => {
+	const code = ch.codePointAt(0) ?? 0;
+	return code < 32 || code === 127 || code === 65534 || code === 65535 ? `\\u${code.toString(16).toUpperCase().padStart(4, "0")}` : ch;
+}));
+/**
+* Escapes a string for use inside a double-quoted N-Triples / Turtle string
+* literal, using the canonical N-Triples escapes.
+*
+* @since 0.1.0
+* @category formatting
+*/
+const escapeString = (value) => {
+	if (!/["\\\u0000-\u001f\u007f\ufffe\uffff]/.test(value)) return value;
+	return value.replace(/[\s\S]/gu, (ch) => escapeChar(ch));
+};
+const IRI_UNSAFE = /[\u0000- <>"{}|^`\\]/;
+const IRI_UNSAFE_ALL = /[\u0000- <>"{}|^`\\]/g;
+/**
+* Escapes characters that are not allowed inside `<...>` IRI references.
+*
+* @since 0.1.0
+* @category formatting
+*/
+const escapeIri = (value) => IRI_UNSAFE.test(value) ? value.replace(IRI_UNSAFE_ALL, (ch) => `\\u${ch.charCodeAt(0).toString(16).toUpperCase().padStart(4, "0")}`) : value;
+const namedNodeToJson = (n) => ({
+	type: "uri",
+	value: n.value
+});
+const blankNodeToJson = (b) => ({
+	type: "bnode",
+	value: b.value
+});
+const resourceToJson = Match.type().pipe(Match.tag("NamedNode", namedNodeToJson), Match.tag("BlankNode", blankNodeToJson), Match.exhaustive);
+const literalToJson = (l) => {
+	if (l.language !== "") return l.direction === void 0 ? {
+		type: "literal",
+		value: l.value,
+		"xml:lang": l.language
+	} : {
+		type: "literal",
+		value: l.value,
+		"xml:lang": l.language,
+		"its:dir": l.direction
+	};
+	return l.datatype.value === "http://www.w3.org/2001/XMLSchema#string" ? {
+		type: "literal",
+		value: l.value
+	} : {
+		type: "literal",
+		value: l.value,
+		datatype: l.datatype.value
+	};
+};
+const tripleToJson = (x) => ({
+	type: "triple",
+	value: {
+		subject: toJson(x.subject),
+		predicate: namedNodeToJson(x.predicate),
+		object: toJson(x.object)
+	}
+});
+const variableToJson = (v) => ({
+	type: "variable",
+	value: v.value
+});
+const defaultGraphToJson = () => ({ type: "default-graph" });
+const groundToJson = Match.type().pipe(Match.tag("NamedNode", namedNodeToJson), Match.tag("BlankNode", blankNodeToJson), Match.tag("Literal", literalToJson), Match.tag("Triple", tripleToJson), Match.exhaustive);
+const termToJson = Match.type().pipe(Match.tag("Variable", variableToJson), Match.tag("DefaultGraph", defaultGraphToJson), Match.orElse(groundToJson));
+function toJson(self) {
+	return termToJson(self);
+}
+const literalFromJson = (l) => {
+	const lang = l["xml:lang"];
+	if (lang !== void 0 && lang !== "") {
+		const dir = l["its:dir"];
+		return dir === "ltr" || dir === "rtl" ? literal(l.value, {
+			language: lang,
+			direction: dir
+		}) : literal(l.value, lang);
+	}
+	return l.datatype === void 0 ? literal(l.value) : literal(l.value, namedNode(l.datatype));
+};
+const tripleFromJson = (x) => new Triple(fromJson(x.value.subject), fromJson(x.value.predicate), fromJson(x.value.object));
+const groundFromJson = Match.type().pipe(Match.when({ type: "uri" }, (u) => namedNode(u.value)), Match.when({ type: "bnode" }, (b) => blankNode(b.value)), Match.when({ type: Match.is("literal", "typed-literal") }, literalFromJson), Match.when({ type: "triple" }, tripleFromJson), Match.exhaustive);
+const termFromJson = Match.type().pipe(Match.when({ type: "variable" }, (v) => variable(v.value)), Match.when({ type: "default-graph" }, () => defaultGraph), Match.orElse(groundFromJson));
+function fromJson(json) {
+	return termFromJson(json);
+}
+const subjectToJson = Match.type().pipe(Match.tag("Triple", tripleToJson), Match.orElse(resourceToJson));
+/**
+* Encodes a quad as JSON; `graph` is omitted for the default graph.
+*
+* @since 0.1.0
+* @category json
+*/
+const quadToJson = (self) => {
+	const subject = subjectToJson(self.subject);
+	const predicate = namedNodeToJson(self.predicate);
+	const object = groundToJson(self.object);
+	return Match.value(self.graph).pipe(Match.tag("DefaultGraph", () => ({
+		subject,
+		predicate,
+		object
+	})), Match.orElse((graph) => ({
+		subject,
+		predicate,
+		object,
+		graph: resourceToJson(graph)
+	})));
+};
+const resourceFromJson = (json) => json.type === "uri" ? namedNode(json.value) : blankNode(json.value);
+/**
+* Decodes a JSON quad; a missing `graph` is the default graph. Triple terms
+* are trusted as in `fromJson`.
+*
+* @since 0.1.0
+* @category json
+*/
+const quadFromJson = (json) => new Quad(json.subject.type === "triple" ? tripleFromJson(json.subject) : resourceFromJson(json.subject), namedNode(json.predicate.value), groundFromJson(json.object), json.graph === void 0 ? defaultGraph : resourceFromJson(json.graph));
+/**
+* Whether every triple term inside a term or quad, at any depth, has a
+* subject (IRI, blank node or triple term), an IRI predicate and an object
+* (anything but a variable or the default graph) — always true for terms
+* built with `triple` and `quad`.
+*
+* @since 0.1.0
+* @category predicates
+*/
+const isWellFormed = (self) => wellFormedCheck(self);
+const wellFormedCheck = Match.type().pipe(Match.tag("Quad", (q) => isWellFormed(q.subject) && isWellFormed(q.object)), Match.tag("Triple", (x) => isSubject(x.subject) && isNamedNode(x.predicate) && isObject(x.object) && isWellFormed(x.subject) && isWellFormed(x.object)), Match.orElse(() => true));
+/**
+* The `toCodecJson` (and `toCodecArbitrary`) link of a term declaration, to a
+* `TermJson`-shaped schema: decodes through `fromJson` and fails unless the
+* result is the declared kind and well formed.
+*/
+const jsonLink = (json, is, encode, expected) => () => Schema.link()(json, SchemaTransformation.transformEffect({
+	decode: (j, options) => {
+		const term = fromJson(j);
+		return is(term) && isWellFormed(term) ? Effect.succeed(term) : Effect.fail(new SchemaIssue.InvalidValue({ expected }, j, options));
+	},
+	encode: (term) => Effect.succeed(encode(term))
+}));
+/** The `toCodecJson` / `toCodecArbitrary` link of `QuadSchema`. */
+const quadLink = (json) => () => Schema.link()(json, SchemaTransformation.transformEffect({
+	decode: (j, options) => {
+		const q = quadFromJson(j);
+		return isWellFormed(q) ? Effect.succeed(q) : Effect.fail(new SchemaIssue.InvalidValue({ expected: "a well-formed quad" }, j, options));
+	},
+	encode: (q) => Effect.succeed(quadToJson(q))
+}));
+/**
+* Schema of an IRI term; its JSON codec is `TermJson.NamedNode`.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const NamedNodeSchema = Schema.declare(isNamedNode, {
+	identifier: "NamedNode",
+	toCodecJson: jsonLink(NamedNodeSchema$1, isNamedNode, namedNodeToJson, "an IRI"),
+	toCodecArbitrary: jsonLink(representations.NamedNode, isNamedNode, namedNodeToJson, "an IRI")
+});
+/**
+* Schema of a blank node; its JSON codec is `TermJson.BlankNode`.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const BlankNodeSchema = Schema.declare(isBlankNode, {
+	identifier: "BlankNode",
+	toCodecJson: jsonLink(BlankNodeSchema$1, isBlankNode, blankNodeToJson, "a blank node"),
+	toCodecArbitrary: jsonLink(representations.BlankNode, isBlankNode, blankNodeToJson, "a blank node")
+});
+/**
+* Schema of a literal; its JSON codec is `TermJson.Literal`.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const LiteralSchema = Schema.declare(isLiteral, {
+	identifier: "Literal",
+	toCodecJson: jsonLink(LiteralSchema$1, isLiteral, literalToJson, "a literal"),
+	toCodecArbitrary: jsonLink(representations.Literal, isLiteral, literalToJson, "a literal")
+});
+/**
+* Schema of a variable; its JSON codec is `TermJson.Variable`.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const VariableSchema = Schema.declare(isVariable, {
+	identifier: "Variable",
+	toCodecJson: jsonLink(VariableSchema$1, isVariable, variableToJson, "a variable"),
+	toCodecArbitrary: jsonLink(representations.Variable, isVariable, variableToJson, "a variable")
+});
+/**
+* Schema of a triple term; its JSON codec is `TermJson.Triple`, and decoding rejects positions that don't fit RDF.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const TripleSchema = Schema.declare(isTriple, {
+	identifier: "Triple",
+	toCodecJson: jsonLink(TripleSchema$1, isTriple, tripleToJson, "a well-formed triple term"),
+	toCodecArbitrary: jsonLink(representations.Triple, isTriple, tripleToJson, "a well-formed triple term")
+});
+/**
+* Schema of a quad; its JSON codec is `TermJson.Quad`, with `graph` omitted for the default graph.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const QuadSchema = Schema.declare(isQuad, {
+	identifier: "Quad",
+	toCodecJson: quadLink(QuadSchema$1),
+	toCodecArbitrary: quadLink(representations.Quad)
+});
+/**
+* Schema of any term; its JSON codec is `TermJson.Term`.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const TermSchema = Schema.declare(isTerm, {
+	identifier: "Term",
+	toCodecJson: jsonLink(TermSchema$1, isTerm, termToJson, "a well-formed term"),
+	toCodecArbitrary: jsonLink(representations.Term, isTerm, termToJson, "a well-formed term")
+});
+/**
+* Schema of a ground term (no variables or default graph); its JSON codec is `TermJson.GroundTerm`.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const GroundTermSchema = Schema.declare(isGroundTerm, {
+	identifier: "GroundTerm",
+	toCodecJson: jsonLink(GroundTermSchema$1, isGroundTerm, groundToJson, "a well-formed ground term"),
+	toCodecArbitrary: jsonLink(representations.GroundTerm, isGroundTerm, groundToJson, "a well-formed ground term")
+});
+export { quadFromJson as $, escapeString as A, isNamedNode as B, VariableSchema as C, compareQuads as D, compare as E, isGraph as F, isTerm as G, isQuad as H, isGround as I, isWellFormed as J, isTriple as K, isGroundTerm as L, hasBlankNodes as M, isBlankNode as N, defaultGraph as O, isDefaultGraph as P, quad as Q, isLanguageTagged as R, Variable as S, blankNode as T, isResource as U, isObject as V, isSubject as W, mapTerms as X, literal as Y, namedNode as Z, TermSchema as _, GroundTermSchema as a, TripleSchema as b, NamedNode as c, Quad as d, quadToJson as et, QuadEquivalence as f, RDF_LANG_STRING as g, RDF_DIR_LANG_STRING as h, Equivalence as i, variable as it, fromJson as j, escapeIri as k, NamedNodeSchema as l, QuadSchema as m, BlankNodeSchema as n, toQuad as nt, Literal as o, QuadOrder as p, isVariable as q, DefaultGraph as r, triple as rt, LiteralSchema as s, BlankNode as t, toJson as tt, Order as u, Term_exports as v, XSD_STRING as w, TypeId as x, Triple as y, isLiteral as z };
+
+//# sourceMappingURL=Term-CFLG1qu4.mjs.map