@thomasfosterau/effect-rdf 0.0.0-stage → 0.1.0

package/dist/Model-DlPzRYhF.mjs

@@ -0,0 +1,528 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { B as isNamedNode$1, C as VariableSchema, N as isBlankNode$1, S as Variable, Z as namedNode, c as NamedNode, l as NamedNodeSchema, n as BlankNodeSchema, o as Literal, q as isVariable$1, s as LiteralSchema, t as BlankNode, y as Triple, z as isLiteral$1 } from "./Term-CFLG1qu4.mjs";
+import { i as empty } from "./PrefixMap-BHFPDLO-.mjs";
+import * as Arr from "effect/Array";
+import * as Equal from "effect/Equal";
+import * as Hash from "effect/Hash";
+import { NodeInspectSymbol } from "effect/Inspectable";
+import * as Iterable from "effect/Iterable";
+import * as MutableHashMap from "effect/MutableHashMap";
+import { pipeArguments } from "effect/Pipeable";
+import { hasProperty } from "effect/Predicate";
+import * as Schema from "effect/Schema";
+import * as SchemaTransformation from "effect/SchemaTransformation";
+import * as Order from "effect/Order";
+// src/n3/internal/guards.ts
+/**
+* Class refinements of the core terms, for the walks that test every term
+* they visit (`Term.isVariable` and its siblings check the `TypeId` through
+* a `dual` call first; a class check is one instruction).
+*
+* @internal
+*/
+/** @internal */
+const isNamedNode = (u) => u instanceof NamedNode;
+/** @internal */
+const isBlankNode = (u) => u instanceof BlankNode;
+/** @internal */
+const isLiteral = (u) => u instanceof Literal;
+/** @internal */
+const isVariable = (u) => u instanceof Variable;
+/** @internal */
+const isTriple = (u) => u instanceof Triple;
+// src/n3/internal/loop.ts
+/**
+* A loop as a function, for the scans that step until a condition holds
+* (probing a hash table, walking a list, backtracking a search).
+*
+* @internal
+*/
+const BLOCK = 1024;
+/** `0 … BLOCK - 1`: the steps of one block run as an array scan, which engines optimise well. */
+const offsets = Array.from({ length: BLOCK }, (_, i) => i);
+/** The first step of each block after the first: `BLOCK, 2 * BLOCK, …`. */
+const blocks = Iterable.makeBy((b) => (b + 1) * BLOCK);
+/**
+* Calls `step` with 0, 1, 2, … until it returns `false`. It never recurses,
+* so a loop of any length takes no stack.
+*
+* @internal
+*/
+const loop = (step) => {
+	if (offsets.every(step)) Iterable.some(blocks, (base) => offsets.some((i) => !step(base + i)));
+};
+// src/n3/Model.ts
+/**
+* The Notation3 data model.
+*
+* N3 extends RDF with quoted graphs (formulas), first-class lists
+* (collections), universally quantified variables and literals or other
+* non-IRI terms in any position of a statement. Core RDF `Quad`s only allow
+* ground terms, so this module defines an N3-specific model on top of the
+* core term classes:
+*
+* - `N3Term` = core `NamedNode` | `BlankNode` | `Literal` | `Variable`, plus
+*   the N3-only `Collection` (an N3 list) and `Formula` (a graph term).
+* - `Statement` — a triple of arbitrary `N3Term`s.
+* - `Formula` — an unordered set of statements. Formulas are values: two
+*   formulas with the same statements are equal (`Equal.equals`), which
+*   matches the N3 semantics of graph terms.
+* - `Document` — a parsed N3 document: its top-level formula together with
+*   the prefixes and base IRI it declared.
+*
+* Quick variables (`?x`) are represented by core `Term.Variable`s. Blank
+* nodes keep their core representation; a blank node is implicitly
+* existentially quantified in the innermost formula that contains all of its
+* occurrences.
+*
+* Like core terms, `Collection`, `Formula` and `Statement` implement `Equal`
+* and `Hash` through a canonical `key`.
+*
+* @since 0.1.0
+*/
+var Model_exports = /* @__PURE__ */ __exportAll({
+	Collection: () => Collection,
+	CollectionSchema: () => CollectionSchema,
+	Formula: () => Formula,
+	FormulaSchema: () => FormulaSchema,
+	N3TermSchema: () => N3TermSchema,
+	Statement: () => Statement,
+	StatementSchema: () => StatementSchema,
+	TypeId: () => TypeId,
+	addStatements: () => addStatements,
+	blankNodes: () => blankNodes,
+	collection: () => collection,
+	document: () => document,
+	emptyFormula: () => emptyFormula,
+	formula: () => formula,
+	hasStatement: () => hasStatement,
+	isCollection: () => isCollection,
+	isFormula: () => isFormula,
+	isGround: () => isGround,
+	isN3Term: () => isN3Term,
+	isStatement: () => isStatement,
+	mapTerms: () => mapTerms,
+	statement: () => statement,
+	substitute: () => substitute,
+	variables: () => variables
+});
+/**
+* @since 0.1.0
+* @category symbols
+*/
+const TypeId = Symbol.for("@thomasfosterau/effect-rdf/n3/Model");
+var N3Base = class {
+	[TypeId] = TypeId;
+	/** The key once computed (no key is empty: the shortest are `()` and `{}`). */
+	#key = "";
+	/** The hash once computed (0 until then; a hash of 0 is merely computed again). */
+	#hash = 0;
+	/** A canonical, N3-like serialisation used for equality and hashing. */
+	get key() {
+		if (this.#key === "") this.#key = this.computeKey();
+		return this.#key;
+	}
+	/**
+	* Statements, collections and formulas override this to combine their
+	* parts' hashes, so that a formula deduplicating its statements builds no
+	* key; whatever the override, equal keys give equal hashes.
+	*/
+	computeHash() {
+		return Hash.string(this.key);
+	}
+	/** RDF/JS-style alias of `_tag`. */
+	get termType() {
+		return this._tag;
+	}
+	equals(that) {
+		return isN3Base(that) && that.key === this.key;
+	}
+	[Equal.symbol](that) {
+		return this.equals(that);
+	}
+	[Hash.symbol]() {
+		if (this.#hash === 0) this.#hash = this.computeHash();
+		return this.#hash;
+	}
+	pipe() {
+		return pipeArguments(this, arguments);
+	}
+	toString() {
+		return this.key;
+	}
+	toJSON() {
+		return {
+			_tag: this._tag,
+			value: this.key
+		};
+	}
+	[NodeInspectSymbol]() {
+		return `${this._tag}(${this.key})`;
+	}
+};
+/** Whether a value is an N3 collection, statement or formula (it carries the `TypeId`). */
+const isN3Base = (u) => hasProperty(u, TypeId);
+/**
+* An N3 list (collection): an ordered, first-class sequence of terms,
+* written `( a b c )`. The empty collection corresponds to `rdf:nil`.
+*
+* @since 0.1.0
+* @category models
+*/
+var Collection = class extends N3Base {
+	_tag = "Collection";
+	items;
+	constructor(items) {
+		super();
+		this.items = items;
+	}
+	computeHash() {
+		return this.items.reduce((h, item) => Hash.combine(h, item[Hash.symbol]()), Hash.string("()"));
+	}
+	computeKey() {
+		return Arr.isReadonlyArrayEmpty(this.items) ? "()" : `( ${this.items.map((t) => t.key).join(" ")} )`;
+	}
+};
+/**
+* An N3 statement: a triple whose subject, predicate and object may be any
+* `N3Term`.
+*
+* @since 0.1.0
+* @category models
+*/
+var Statement = class extends N3Base {
+	_tag = "Statement";
+	subject;
+	predicate;
+	object;
+	constructor(subject, predicate, object) {
+		super();
+		this.subject = subject;
+		this.predicate = predicate;
+		this.object = object;
+	}
+	computeHash() {
+		return Hash.combine(Hash.combine(this.subject[Hash.symbol](), this.predicate[Hash.symbol]()), this.object[Hash.symbol]());
+	}
+	computeKey() {
+		return `${this.subject.key} ${this.predicate.key} ${this.object.key}`;
+	}
+};
+/**
+* Whether two terms are equal (have the same key), compared by their parts
+* where that avoids building keys: identical or differently hashed terms are
+* decided at once, and statements, collections and formulas are compared
+* part by part. Only leaf terms (IRIs, literals, blank nodes, variables) are
+* compared by key.
+*/
+const sameTerm = (a, b) => {
+	if (a === b) return true;
+	if (a[Hash.symbol]() !== b[Hash.symbol]()) return false;
+	if (a instanceof Formula) return b instanceof Formula && sameFormula(a, b);
+	if (a instanceof Collection) return b instanceof Collection && a.items.length === b.items.length && a.items.every((item, i) => sameTerm(item, b.items[i] ?? item));
+	if (b instanceof Formula || b instanceof Collection) return false;
+	return a.key === b.key;
+};
+/** Whether two statements are equal: their terms are (`sameTerm`). */
+const sameStatement = (a, b) => sameTerm(a.subject, b.subject) && sameTerm(a.predicate, b.predicate) && sameTerm(a.object, b.object);
+/** Whether two formulas have the same statements (searched for small ones, by key otherwise). */
+const sameFormula = (a, b) => {
+	const as = a.statements;
+	const bs = b.statements;
+	if (as.length !== bs.length) return false;
+	if (as.length > 8) return a.key === b.key;
+	return as.every((s) => bs.some((t) => sameStatement(s, t)));
+};
+/** A placeholder for the probe's statement before the first is placed. */
+const emptyStatement = new Statement(namedNode(""), namedNode(""), namedNode(""));
+/**
+* The statements without duplicates, keeping the first of each: by their
+* structural hashes, comparing keys only when two hashes are equal, so that
+* no key is built for statements that differ.
+*/
+const deduplicate = (all) => {
+	const n = all.length;
+	if (n < 2) return all;
+	const mask = 2 ** Math.ceil(Math.log2(n * 2)) - 1;
+	const hashes = new Int32Array(mask + 1);
+	const slots = new Int32Array(mask + 1);
+	const unique = [];
+	let current = emptyStatement;
+	let hash = 0;
+	let i = 0;
+	let duplicate = false;
+	const probe = () => {
+		const slot = slots[i] ?? 0;
+		if (slot === 0) return false;
+		if (hashes[i] === hash && sameStatement(current, all[slot - 1] ?? current)) {
+			duplicate = true;
+			return false;
+		}
+		i = i + 1 & mask;
+		return true;
+	};
+	all.forEach((s, k) => {
+		current = s;
+		hash = s[Hash.symbol]() | 0;
+		i = hash & mask;
+		duplicate = false;
+		loop(probe);
+		if (duplicate) return;
+		hashes[i] = hash;
+		slots[i] = k + 1;
+		unique.push(s);
+	});
+	return unique.length === n ? all : unique;
+};
+/**
+* An N3 formula (graph term): an unordered set of statements, written
+* `{ ... }`. Duplicate statements are removed (when the statements are first
+* read), and equality is set equality of the statements (blank node labels are compared
+* literally; use `Isomorphism.isomorphic` for a blank-node-aware comparison).
+*
+* @since 0.1.0
+* @category models
+*/
+var Formula = class extends N3Base {
+	_tag = "Formula";
+	/** The statements as given (copied), then without duplicates once first read. */
+	#statements;
+	#deduplicated = false;
+	constructor(statements) {
+		super();
+		this.#statements = Array.from(statements);
+	}
+	/**
+	* The statements, without duplicates, in the order first given. They are
+	* deduplicated the first time they are read, not when the formula is
+	* made, so a formula that is never read (a parse whose result is only
+	* checked for errors, a formula a rule discards) costs nothing to dedupe.
+	*/
+	get statements() {
+		if (!this.#deduplicated) {
+			this.#statements = deduplicate(this.#statements);
+			this.#deduplicated = true;
+		}
+		return this.#statements;
+	}
+	/** The sum of the statements' hashes: the same for the same set, whatever the order. */
+	computeHash() {
+		return Hash.optimize(this.statements.reduce((h, st) => h + st[Hash.symbol]() | 0, 31613));
+	}
+	/** The number of statements in the formula. */
+	get size() {
+		return this.#statements.length < 2 ? this.#statements.length : this.statements.length;
+	}
+	computeKey() {
+		if (Arr.isReadonlyArrayEmpty(this.statements)) return "{}";
+		return `{ ${Arr.sort(this.statements.map((s) => s.key), Order.String).join(" . ")} }`;
+	}
+	[Symbol.iterator]() {
+		return this.statements[Symbol.iterator]();
+	}
+};
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const statement = (subject, predicate, object) => new Statement(subject, predicate, object);
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const formula = (statements = []) => new Formula(statements);
+/**
+* The empty formula `{}`.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const emptyFormula = new Formula([]);
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const collection = (items = []) => new Collection(Array.from(items));
+/**
+* Creates a document from a formula.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const document = (formula, options) => ({
+	formula,
+	prefixes: options?.prefixes ?? empty,
+	baseIri: options?.baseIri
+});
+/**
+* @since 0.1.0
+* @category guards
+*/
+const isFormula = (u) => u instanceof Formula;
+/**
+* @since 0.1.0
+* @category guards
+*/
+const isCollection = (u) => u instanceof Collection;
+/**
+* @since 0.1.0
+* @category guards
+*/
+const isStatement = (u) => u instanceof Statement;
+/**
+* Whether a value is an `N3Term` (a core IRI, blank node, literal or
+* variable, or an N3 collection or formula).
+*
+* @since 0.1.0
+* @category guards
+*/
+const isN3Term = (u) => isFormula(u) || isCollection(u) || isNamedNode$1(u) || isBlankNode$1(u) || isLiteral$1(u) || isVariable$1(u);
+/**
+* Whether a term, statement or formula is free of variables (recursively).
+*
+* @since 0.1.0
+* @category predicates
+*/
+const isGround = (self) => groundness(self);
+const groundness = (self) => self instanceof Statement ? groundness(self.subject) && groundness(self.predicate) && groundness(self.object) : self instanceof Formula ? self.statements.every(groundness) : self instanceof Collection ? self.items.every(groundness) : !isVariable(self);
+/** Adds the atoms of `self` that pass `test` to `out`, by key, in order of first occurrence. */
+const collect = (self, test, out) => {
+	if (self instanceof Statement) {
+		collect(self.subject, test, out);
+		collect(self.predicate, test, out);
+		collect(self.object, test, out);
+	} else if (self instanceof Formula) self.statements.forEach((s) => collect(s, test, out));
+	else if (self instanceof Collection) self.items.forEach((i) => collect(i, test, out));
+	else if (test(self)) MutableHashMap.set(out, self.key, self);
+};
+/**
+* All distinct variables occurring in a term, statement or formula
+* (including inside nested formulas and collections), in order of first
+* occurrence.
+*
+* @since 0.1.0
+* @category getters
+*/
+const variables = (self) => {
+	const out = MutableHashMap.empty();
+	collect(self, isVariable, out);
+	return Arr.fromIterable(MutableHashMap.values(out));
+};
+/**
+* All distinct blank nodes occurring in a term, statement or formula
+* (including inside nested formulas and collections).
+*
+* @since 0.1.0
+* @category getters
+*/
+const blankNodes = (self) => {
+	const out = MutableHashMap.empty();
+	collect(self, isBlankNode, out);
+	return Arr.fromIterable(MutableHashMap.values(out));
+};
+function mapTerms(self, f) {
+	return self instanceof Statement ? mapStatement(self, f) : mapTerm(self, f);
+}
+const mapTerm = (t, f) => t instanceof Formula ? new Formula(t.statements.map((s) => mapStatement(s, f))) : t instanceof Collection ? new Collection(t.items.map((i) => mapTerm(i, f))) : f(t);
+const mapStatement = (s, f) => new Statement(mapTerm(s.subject, f), mapTerm(s.predicate, f), mapTerm(s.object, f));
+function substitute(self, bindings) {
+	return mapTerms(self, (t) => isVariable(t) ? bindings.get(t.value) ?? t : t);
+}
+/**
+* Adds statements to a formula.
+*
+* @since 0.1.0
+* @category combinators
+*/
+const addStatements = (self, statements) => new Formula([...self.statements, ...statements]);
+/**
+* Whether a formula contains a statement.
+*
+* @since 0.1.0
+* @category predicates
+*/
+const hasStatement = (self, statement) => self.statements.some((s) => s.key === statement.key);
+/**
+* Schema of a formula; its JSON codec is
+* `{ "type": "formula", "statements": [{ subject, predicate, object }, …] }`
+* over JSON N3 terms.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const FormulaSchema = Schema.declare(isFormula, {
+	identifier: "Formula",
+	toCodecJson: () => Schema.link()(Schema.Struct({
+		type: Schema.tag("formula"),
+		statements: Schema.Array(Schema.suspend(() => StatementSchema))
+	}), SchemaTransformation.transform({
+		decode: (j) => new Formula(j.statements),
+		encode: (f) => ({
+			type: "formula",
+			statements: f.statements
+		})
+	}))
+});
+/**
+* Schema of a collection; its JSON codec is
+* `{ "type": "collection", "items": [ … ] }` over JSON N3 terms.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const CollectionSchema = Schema.declare(isCollection, {
+	identifier: "Collection",
+	toCodecJson: () => Schema.link()(Schema.Struct({
+		type: Schema.tag("collection"),
+		items: Schema.Array(Schema.suspend(() => N3TermSchema))
+	}), SchemaTransformation.transform({
+		decode: (j) => new Collection(j.items),
+		encode: (c) => ({
+			type: "collection",
+			items: c.items
+		})
+	}))
+});
+/**
+* Schema of a statement; its JSON codec is `{ subject, predicate, object }`
+* over JSON N3 terms.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const StatementSchema = Schema.declare(isStatement, {
+	identifier: "Statement",
+	toCodecJson: () => Schema.link()(Schema.Struct({
+		subject: Schema.suspend(() => N3TermSchema),
+		predicate: Schema.suspend(() => N3TermSchema),
+		object: Schema.suspend(() => N3TermSchema)
+	}), SchemaTransformation.transform({
+		decode: (j) => new Statement(j.subject, j.predicate, j.object),
+		encode: (st) => ({
+			subject: st.subject,
+			predicate: st.predicate,
+			object: st.object
+		})
+	}))
+});
+/**
+* Schema of any N3 term; its JSON codec is core's `TermJson` term (IRIs,
+* blank nodes, literals, variables) or a JSON collection or formula.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const N3TermSchema = Schema.declare(isN3Term, {
+	identifier: "N3Term",
+	toCodecJson: () => Schema.link()(Schema.Union([
+		NamedNodeSchema,
+		BlankNodeSchema,
+		LiteralSchema,
+		VariableSchema,
+		CollectionSchema,
+		FormulaSchema
+	]), SchemaTransformation.passthrough())
+});
+export { isTriple as A, statement as C, isBlankNode as D, loop as E, isLiteral as O, mapTerms as S, variables as T, isCollection as _, Model_exports as a, isN3Term as b, StatementSchema as c, blankNodes as d, collection as f, hasStatement as g, formula as h, FormulaSchema as i, isVariable as j, isNamedNode as k, TypeId as l, emptyFormula as m, CollectionSchema as n, N3TermSchema as o, document as p, Formula as r, Statement as s, Collection as t, addStatements as u, isFormula as v, substitute as w, isStatement as x, isGround as y };
+
+//# sourceMappingURL=Model-DlPzRYhF.mjs.map

package/dist/Model-DlPzRYhF.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Model-DlPzRYhF.mjs","names":["Term.NamedNode","Term.BlankNode","Term.Literal","Term.Variable","Term.Triple","Term.namedNode","PrefixMap.empty","Term.isNamedNode","Term.isBlankNode","Term.isLiteral","Term.isVariable","Guards.isVariable","Guards.isBlankNode","Term.NamedNodeSchema","Term.BlankNodeSchema","Term.LiteralSchema","Term.VariableSchema"],"sources":["../src/n3/internal/guards.ts","../src/n3/internal/loop.ts","../src/n3/Model.ts"],"sourcesContent":["/**\n * Class refinements of the core terms, for the walks that test every term\n * they visit (`Term.isVariable` and its siblings check the `TypeId` through\n * a `dual` call first; a class check is one instruction).\n *\n * @internal\n */\nimport * as Term from '../../Term.ts';\n\n/** @internal */\nexport const isNamedNode = (u: unknown): u is Term.NamedNode => u instanceof Term.NamedNode;\n\n/** @internal */\nexport const isBlankNode = (u: unknown): u is Term.BlankNode => u instanceof Term.BlankNode;\n\n/** @internal */\nexport const isLiteral = (u: unknown): u is Term.Literal => u instanceof Term.Literal;\n\n/** @internal */\nexport const isVariable = (u: unknown): u is Term.Variable => u instanceof Term.Variable;\n\n/** @internal */\nexport const isTriple = (u: unknown): u is Term.Triple => u instanceof Term.Triple;\n","/**\n * A loop as a function, for the scans that step until a condition holds\n * (probing a hash table, walking a list, backtracking a search).\n *\n * @internal\n */\nimport * as Iterable from 'effect/Iterable';\n\nconst BLOCK = 1024;\n\n/** `0 … BLOCK - 1`: the steps of one block run as an array scan, which engines optimise well. */\nconst offsets: ReadonlyArray<number> = Array.from({ length: BLOCK }, (_, i) => i);\n\n/** The first step of each block after the first: `BLOCK, 2 * BLOCK, …`. */\nconst blocks: Iterable<number> = Iterable.makeBy((b) => (b + 1) * BLOCK);\n\n/**\n * Calls `step` with 0, 1, 2, … until it returns `false`. It never recurses,\n * so a loop of any length takes no stack.\n *\n * @internal\n */\nexport const loop = (step: (i: number) => boolean): void => {\n  // Most loops end within the first block, which needs no iterator\n  if (offsets.every(step)) {\n    Iterable.some(blocks, (base) => offsets.some((i) => !step(base + i)));\n  }\n};\n","/**\n * The Notation3 data model.\n *\n * N3 extends RDF with quoted graphs (formulas), first-class lists\n * (collections), universally quantified variables and literals or other\n * non-IRI terms in any position of a statement. Core RDF `Quad`s only allow\n * ground terms, so this module defines an N3-specific model on top of the\n * core term classes:\n *\n * - `N3Term` = core `NamedNode` | `BlankNode` | `Literal` | `Variable`, plus\n *   the N3-only `Collection` (an N3 list) and `Formula` (a graph term).\n * - `Statement` — a triple of arbitrary `N3Term`s.\n * - `Formula` — an unordered set of statements. Formulas are values: two\n *   formulas with the same statements are equal (`Equal.equals`), which\n *   matches the N3 semantics of graph terms.\n * - `Document` — a parsed N3 document: its top-level formula together with\n *   the prefixes and base IRI it declared.\n *\n * Quick variables (`?x`) are represented by core `Term.Variable`s. Blank\n * nodes keep their core representation; a blank node is implicitly\n * existentially quantified in the innermost formula that contains all of its\n * occurrences.\n *\n * Like core terms, `Collection`, `Formula` and `Statement` implement `Equal`\n * and `Hash` through a canonical `key`.\n *\n * @since 0.1.0\n */\nimport * as Arr from 'effect/Array';\nimport * as Equal from 'effect/Equal';\nimport * as Hash from 'effect/Hash';\nimport { NodeInspectSymbol } from 'effect/Inspectable';\nimport * as MutableHashMap from 'effect/MutableHashMap';\nimport { pipeArguments, type Pipeable } from 'effect/Pipeable';\nimport * as Order from 'effect/Order';\nimport { hasProperty } from 'effect/Predicate';\nimport * as Schema from 'effect/Schema';\nimport * as SchemaTransformation from 'effect/SchemaTransformation';\nimport * as PrefixMap from '../PrefixMap.ts';\nimport * as Term from '../Term.ts';\nimport * as Guards from './internal/guards.ts';\nimport { loop } from './internal/loop.ts';\n\n/**\n * @since 0.1.0\n * @category symbols\n */\nexport const TypeId: unique symbol = Symbol.for('@thomasfosterau/effect-rdf/n3/Model');\n\n/**\n * @since 0.1.0\n * @category symbols\n */\nexport type TypeId = typeof TypeId;\n\nabstract class N3Base implements Equal.Equal, Pipeable {\n  readonly [TypeId]: TypeId = TypeId;\n  abstract readonly _tag: string;\n  /** The key once computed (no key is empty: the shortest are `()` and `{}`). */\n  #key = '';\n  /** The hash once computed (0 until then; a hash of 0 is merely computed again). */\n  #hash = 0;\n\n  /** A canonical, N3-like serialisation used for equality and hashing. */\n  get key(): string {\n    if (this.#key === '') this.#key = this.computeKey();\n    return this.#key;\n  }\n\n  protected abstract computeKey(): string;\n\n  /**\n   * Statements, collections and formulas override this to combine their\n   * parts' hashes, so that a formula deduplicating its statements builds no\n   * key; whatever the override, equal keys give equal hashes.\n   */\n  protected computeHash(): number {\n    return Hash.string(this.key);\n  }\n\n  /** RDF/JS-style alias of `_tag`. */\n  get termType(): this['_tag'] {\n    return this._tag;\n  }\n\n  equals(that: unknown): boolean {\n    return isN3Base(that) && that.key === this.key;\n  }\n\n  [Equal.symbol](that: Equal.Equal): boolean {\n    return this.equals(that);\n  }\n\n  [Hash.symbol](): number {\n    if (this.#hash === 0) this.#hash = this.computeHash();\n    return this.#hash;\n  }\n\n  pipe() {\n    return pipeArguments(this, arguments);\n  }\n\n  toString(): string {\n    return this.key;\n  }\n\n  toJSON(): unknown {\n    return { _tag: this._tag, value: this.key };\n  }\n\n  [NodeInspectSymbol](): string {\n    return `${this._tag}(${this.key})`;\n  }\n}\n\n/** Whether a value is an N3 collection, statement or formula (it carries the `TypeId`). */\nconst isN3Base = (u: unknown): u is N3Base => hasProperty(u, TypeId);\n\n/**\n * An N3 list (collection): an ordered, first-class sequence of terms,\n * written `( a b c )`. The empty collection corresponds to `rdf:nil`.\n *\n * @since 0.1.0\n * @category models\n */\nexport class Collection extends N3Base {\n  readonly _tag = 'Collection' as const;\n  readonly items: ReadonlyArray<N3Term>;\n  constructor(items: ReadonlyArray<N3Term>) {\n    super();\n    this.items = items;\n  }\n  protected override computeHash(): number {\n    return this.items.reduce((h, item) => Hash.combine(h, item[Hash.symbol]()), Hash.string('()'));\n  }\n  protected computeKey(): string {\n    return Arr.isReadonlyArrayEmpty(this.items)\n      ? '()'\n      : `( ${this.items.map((t) => t.key).join(' ')} )`;\n  }\n}\n\n/**\n * An N3 statement: a triple whose subject, predicate and object may be any\n * `N3Term`.\n *\n * @since 0.1.0\n * @category models\n */\nexport class Statement<\n  out S extends N3Term = N3Term,\n  out P extends N3Term = N3Term,\n  out O extends N3Term = N3Term,\n> extends N3Base {\n  readonly _tag = 'Statement' as const;\n  readonly subject: S;\n  readonly predicate: P;\n  readonly object: O;\n  constructor(subject: S, predicate: P, object: O) {\n    super();\n    this.subject = subject;\n    this.predicate = predicate;\n    this.object = object;\n  }\n  protected override computeHash(): number {\n    return Hash.combine(\n      Hash.combine(this.subject[Hash.symbol](), this.predicate[Hash.symbol]()),\n      this.object[Hash.symbol](),\n    );\n  }\n  protected computeKey(): string {\n    return `${this.subject.key} ${this.predicate.key} ${this.object.key}`;\n  }\n}\n\n/**\n * Whether two terms are equal (have the same key), compared by their parts\n * where that avoids building keys: identical or differently hashed terms are\n * decided at once, and statements, collections and formulas are compared\n * part by part. Only leaf terms (IRIs, literals, blank nodes, variables) are\n * compared by key.\n */\nconst sameTerm = (a: N3Term, b: N3Term): boolean => {\n  if (a === b) return true;\n  if (a[Hash.symbol]() !== b[Hash.symbol]()) return false;\n  if (a instanceof Formula) return b instanceof Formula && sameFormula(a, b);\n  if (a instanceof Collection) {\n    return (\n      b instanceof Collection &&\n      a.items.length === b.items.length &&\n      a.items.every((item, i) => sameTerm(item, b.items[i] ?? item))\n    );\n  }\n  if (b instanceof Formula || b instanceof Collection) return false;\n  return a.key === b.key;\n};\n\n/** Whether two statements are equal: their terms are (`sameTerm`). */\nconst sameStatement = (a: Statement, b: Statement): boolean =>\n  sameTerm(a.subject, b.subject) &&\n  sameTerm(a.predicate, b.predicate) &&\n  sameTerm(a.object, b.object);\n\n/** Whether two formulas have the same statements (searched for small ones, by key otherwise). */\nconst sameFormula = (a: Formula, b: Formula): boolean => {\n  const as = a.statements;\n  const bs = b.statements;\n  if (as.length !== bs.length) return false;\n  if (as.length > 8) return a.key === b.key;\n  return as.every((s) => bs.some((t) => sameStatement(s, t)));\n};\n\n/** A placeholder for the probe's statement before the first is placed. */\nconst emptyStatement: Statement = new Statement(\n  Term.namedNode(''),\n  Term.namedNode(''),\n  Term.namedNode(''),\n);\n\n/**\n * The statements without duplicates, keeping the first of each: by their\n * structural hashes, comparing keys only when two hashes are equal, so that\n * no key is built for statements that differ.\n */\nconst deduplicate = (all: ReadonlyArray<Statement>): ReadonlyArray<Statement> => {\n  const n = all.length;\n  if (n < 2) return all;\n  // Open addressing over a power-of-two table at most half full: each slot holds a statement's\n  // hash and its position + 1 (0 when empty), probed linearly\n  const mask = 2 ** Math.ceil(Math.log2(n * 2)) - 1;\n  const hashes = new Int32Array(mask + 1);\n  const slots = new Int32Array(mask + 1);\n  const unique: Array<Statement> = [];\n  // The probe of the statement being placed: one closure for the whole table\n  let current: Statement = emptyStatement;\n  let hash = 0;\n  let i = 0;\n  let duplicate = false;\n  const probe = (): boolean => {\n    const slot = slots[i] ?? 0;\n    if (slot === 0) return false;\n    if (hashes[i] === hash && sameStatement(current, all[slot - 1] ?? current)) {\n      duplicate = true;\n      return false;\n    }\n    i = (i + 1) & mask;\n    return true;\n  };\n  all.forEach((s, k) => {\n    current = s;\n    hash = s[Hash.symbol]() | 0;\n    i = hash & mask;\n    duplicate = false;\n    loop(probe);\n    if (duplicate) return;\n    hashes[i] = hash;\n    slots[i] = k + 1;\n    unique.push(s);\n  });\n  return unique.length === n ? all : unique;\n};\n\n/**\n * An N3 formula (graph term): an unordered set of statements, written\n * `{ ... }`. Duplicate statements are removed (when the statements are first\n * read), and equality is set equality of the statements (blank node labels are compared\n * literally; use `Isomorphism.isomorphic` for a blank-node-aware comparison).\n *\n * @since 0.1.0\n * @category models\n */\nexport class Formula extends N3Base {\n  readonly _tag = 'Formula' as const;\n  /** The statements as given (copied), then without duplicates once first read. */\n  #statements: ReadonlyArray<Statement>;\n  #deduplicated = false;\n  constructor(statements: Iterable<Statement>) {\n    super();\n    this.#statements = Array.from(statements);\n  }\n  /**\n   * The statements, without duplicates, in the order first given. They are\n   * deduplicated the first time they are read, not when the formula is\n   * made, so a formula that is never read (a parse whose result is only\n   * checked for errors, a formula a rule discards) costs nothing to dedupe.\n   */\n  get statements(): ReadonlyArray<Statement> {\n    if (!this.#deduplicated) {\n      this.#statements = deduplicate(this.#statements);\n      this.#deduplicated = true;\n    }\n    return this.#statements;\n  }\n  /** The sum of the statements' hashes: the same for the same set, whatever the order. */\n  protected override computeHash(): number {\n    return Hash.optimize(this.statements.reduce((h, st) => (h + st[Hash.symbol]()) | 0, 0x7b7d));\n  }\n  /** The number of statements in the formula. */\n  get size(): number {\n    // Fewer than two statements cannot hold a duplicate\n    return this.#statements.length < 2 ? this.#statements.length : this.statements.length;\n  }\n  protected computeKey(): string {\n    if (Arr.isReadonlyArrayEmpty(this.statements)) return '{}';\n    const keys = Arr.sort(\n      this.statements.map((s) => s.key),\n      Order.String,\n    );\n    return `{ ${keys.join(' . ')} }`;\n  }\n  [Symbol.iterator](): Iterator<Statement> {\n    return this.statements[Symbol.iterator]();\n  }\n}\n\n/**\n * Any term that may appear in an N3 statement.\n *\n * @since 0.1.0\n * @category models\n */\nexport type N3Term =\n  | Term.NamedNode\n  | Term.BlankNode\n  | Term.Literal\n  | Term.Variable\n  | Collection\n  | Formula;\n\n/**\n * A parsed N3 document.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Document {\n  /** The top-level formula: every statement asserted by the document. */\n  readonly formula: Formula;\n  /** The prefixes declared by the document (in declaration order). */\n  readonly prefixes: PrefixMap.PrefixMap;\n  /** The final in-scope base IRI of the document, if any. */\n  readonly baseIri: string | undefined;\n}\n\n// -----------------------------------------------------------------------------\n// Constructors\n// -----------------------------------------------------------------------------\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const statement = <S extends N3Term, P extends N3Term, O extends N3Term>(\n  subject: S,\n  predicate: P,\n  object: O,\n): Statement<S, P, O> => new Statement(subject, predicate, object);\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const formula = (statements: Iterable<Statement> = []): Formula => new Formula(statements);\n\n/**\n * The empty formula `{}`.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const emptyFormula: Formula = new Formula([]);\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const collection = (items: Iterable<N3Term> = []): Collection =>\n  new Collection(Array.from(items));\n\n/**\n * Creates a document from a formula.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const document = (\n  formula: Formula,\n  options?: { readonly prefixes?: PrefixMap.PrefixMap; readonly baseIri?: string | undefined },\n): Document => ({\n  formula,\n  prefixes: options?.prefixes ?? PrefixMap.empty,\n  baseIri: options?.baseIri,\n});\n\n// -----------------------------------------------------------------------------\n// Guards\n// -----------------------------------------------------------------------------\n\n/**\n * @since 0.1.0\n * @category guards\n */\nexport const isFormula = (u: unknown): u is Formula => u instanceof Formula;\n\n/**\n * @since 0.1.0\n * @category guards\n */\nexport const isCollection = (u: unknown): u is Collection => u instanceof Collection;\n\n/**\n * @since 0.1.0\n * @category guards\n */\nexport const isStatement = (u: unknown): u is Statement => u instanceof Statement;\n\n/**\n * Whether a value is an `N3Term` (a core IRI, blank node, literal or\n * variable, or an N3 collection or formula).\n *\n * @since 0.1.0\n * @category guards\n */\nexport const isN3Term = (u: unknown): u is N3Term =>\n  isFormula(u) ||\n  isCollection(u) ||\n  Term.isNamedNode(u) ||\n  Term.isBlankNode(u) ||\n  Term.isLiteral(u) ||\n  Term.isVariable(u);\n\n// -----------------------------------------------------------------------------\n// Inspection\n// -----------------------------------------------------------------------------\n\n/**\n * Whether a term, statement or formula is free of variables (recursively).\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isGround = (self: N3Term | Statement): boolean => groundness(self);\n\n// Plain refinements rather than `Match`: `isGround` runs for every term it visits.\nconst groundness = (self: N3Term | Statement): boolean =>\n  self instanceof Statement\n    ? groundness(self.subject) && groundness(self.predicate) && groundness(self.object)\n    : self instanceof Formula\n      ? self.statements.every(groundness)\n      : self instanceof Collection\n        ? self.items.every(groundness)\n        : !Guards.isVariable(self);\n\n/** Adds the atoms of `self` that pass `test` to `out`, by key, in order of first occurrence. */\nconst collect = <A extends N3Term>(\n  self: N3Term | Statement,\n  test: (t: N3Term) => t is A,\n  out: MutableHashMap.MutableHashMap<string, A>,\n): void => {\n  if (self instanceof Statement) {\n    collect(self.subject, test, out);\n    collect(self.predicate, test, out);\n    collect(self.object, test, out);\n  } else if (self instanceof Formula) {\n    self.statements.forEach((s) => collect(s, test, out));\n  } else if (self instanceof Collection) {\n    self.items.forEach((i) => collect(i, test, out));\n  } else if (test(self)) {\n    MutableHashMap.set(out, self.key, self);\n  }\n};\n\n/**\n * All distinct variables occurring in a term, statement or formula\n * (including inside nested formulas and collections), in order of first\n * occurrence.\n *\n * @since 0.1.0\n * @category getters\n */\nexport const variables = (self: N3Term | Statement): ReadonlyArray<Term.Variable> => {\n  const out = MutableHashMap.empty<string, Term.Variable>();\n  collect(self, Guards.isVariable, out);\n  return Arr.fromIterable(MutableHashMap.values(out));\n};\n\n/**\n * All distinct blank nodes occurring in a term, statement or formula\n * (including inside nested formulas and collections).\n *\n * @since 0.1.0\n * @category getters\n */\nexport const blankNodes = (self: N3Term | Statement): ReadonlyArray<Term.BlankNode> => {\n  const out = MutableHashMap.empty<string, Term.BlankNode>();\n  collect(self, Guards.isBlankNode, out);\n  return Arr.fromIterable(MutableHashMap.values(out));\n};\n\n// -----------------------------------------------------------------------------\n// Combinators\n// -----------------------------------------------------------------------------\n\n/**\n * Applies `f` to every atomic term (IRI, blank node, literal, variable),\n * recursing into collections, statements and nested formulas.\n *\n * @since 0.1.0\n * @category combinators\n */\nexport function mapTerms<T extends N3Term | Statement>(\n  self: T,\n  f: (term: Term.NamedNode | Term.BlankNode | Term.Literal | Term.Variable) => N3Term,\n): T extends Statement ? Statement : T extends Formula ? Formula : N3Term;\nexport function mapTerms(\n  self: N3Term | Statement,\n  f: (term: Term.NamedNode | Term.BlankNode | Term.Literal | Term.Variable) => N3Term,\n): N3Term | Statement {\n  return self instanceof Statement ? mapStatement(self, f) : mapTerm(self, f);\n}\n\ntype Atom = Term.NamedNode | Term.BlankNode | Term.Literal | Term.Variable;\n\n// Plain refinements rather than `Match`: `mapTerms` runs for every term it visits.\nconst mapTerm = (t: N3Term, f: (term: Atom) => N3Term): N3Term =>\n  t instanceof Formula\n    ? new Formula(t.statements.map((s) => mapStatement(s, f)))\n    : t instanceof Collection\n      ? new Collection(t.items.map((i) => mapTerm(i, f)))\n      : f(t);\n\nconst mapStatement = (s: Statement, f: (term: Atom) => N3Term): Statement =>\n  new Statement(mapTerm(s.subject, f), mapTerm(s.predicate, f), mapTerm(s.object, f));\n\n/**\n * Replaces variables by the terms bound to them (by variable name); unbound\n * variables are kept.\n *\n * @since 0.1.0\n * @category combinators\n */\nexport function substitute<T extends N3Term | Statement>(\n  self: T,\n  bindings: ReadonlyMap<string, N3Term>,\n): T extends Statement ? Statement : T extends Formula ? Formula : N3Term;\nexport function substitute(\n  self: N3Term | Statement,\n  bindings: ReadonlyMap<string, N3Term>,\n): N3Term | Statement {\n  return mapTerms(self, (t) => (Guards.isVariable(t) ? (bindings.get(t.value) ?? t) : t));\n}\n\n/**\n * Adds statements to a formula.\n *\n * @since 0.1.0\n * @category combinators\n */\nexport const addStatements = (self: Formula, statements: Iterable<Statement>): Formula =>\n  new Formula([...self.statements, ...statements]);\n\n/**\n * Whether a formula contains a statement.\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const hasStatement = (self: Formula, statement: Statement): boolean =>\n  self.statements.some((s) => s.key === statement.key);\n\n// -----------------------------------------------------------------------------\n// Schemas\n// -----------------------------------------------------------------------------\n\n/**\n * Schema of a formula; its JSON codec is\n * `{ \"type\": \"formula\", \"statements\": [{ subject, predicate, object }, …] }`\n * over JSON N3 terms.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const FormulaSchema: Schema.declare<Formula> = Schema.declare(isFormula, {\n  identifier: 'Formula',\n  toCodecJson: () =>\n    Schema.link<Formula>()(\n      Schema.Struct({\n        type: Schema.tag('formula'),\n        statements: Schema.Array(Schema.suspend(() => StatementSchema)),\n      }),\n      SchemaTransformation.transform({\n        decode: (j) => new Formula(j.statements),\n        encode: (f) => ({ type: 'formula' as const, statements: f.statements }),\n      }),\n    ),\n});\n\n/**\n * The value a `FormulaSchema` decodes to.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport type FormulaSchema = typeof FormulaSchema.Type;\n\n/**\n * Schema of a collection; its JSON codec is\n * `{ \"type\": \"collection\", \"items\": [ … ] }` over JSON N3 terms.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const CollectionSchema: Schema.declare<Collection> = Schema.declare(isCollection, {\n  identifier: 'Collection',\n  toCodecJson: () =>\n    Schema.link<Collection>()(\n      Schema.Struct({\n        type: Schema.tag('collection'),\n        items: Schema.Array(Schema.suspend(() => N3TermSchema)),\n      }),\n      SchemaTransformation.transform({\n        decode: (j) => new Collection(j.items),\n        encode: (c) => ({ type: 'collection' as const, items: c.items }),\n      }),\n    ),\n});\n\n/**\n * The value a `CollectionSchema` decodes to.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport type CollectionSchema = typeof CollectionSchema.Type;\n\n/**\n * Schema of a statement; its JSON codec is `{ subject, predicate, object }`\n * over JSON N3 terms.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const StatementSchema: Schema.declare<Statement> = Schema.declare(isStatement, {\n  identifier: 'Statement',\n  toCodecJson: () =>\n    Schema.link<Statement>()(\n      Schema.Struct({\n        subject: Schema.suspend(() => N3TermSchema),\n        predicate: Schema.suspend(() => N3TermSchema),\n        object: Schema.suspend(() => N3TermSchema),\n      }),\n      SchemaTransformation.transform({\n        decode: (j) => new Statement(j.subject, j.predicate, j.object),\n        encode: (st) => ({ subject: st.subject, predicate: st.predicate, object: st.object }),\n      }),\n    ),\n});\n\n/**\n * The value a `StatementSchema` decodes to.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport type StatementSchema = typeof StatementSchema.Type;\n\n/**\n * Schema of any N3 term; its JSON codec is core's `TermJson` term (IRIs,\n * blank nodes, literals, variables) or a JSON collection or formula.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const N3TermSchema: Schema.declare<N3Term> = Schema.declare(isN3Term, {\n  identifier: 'N3Term',\n  toCodecJson: () =>\n    Schema.link<N3Term>()(\n      Schema.Union([\n        Term.NamedNodeSchema,\n        Term.BlankNodeSchema,\n        Term.LiteralSchema,\n        Term.VariableSchema,\n        CollectionSchema,\n        FormulaSchema,\n      ]),\n      SchemaTransformation.passthrough(),\n    ),\n});\n\n/**\n * The value a `N3TermSchema` decodes to.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport type N3TermSchema = typeof N3TermSchema.Type;\n"],"mappings":"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"}