@thomasfosterau/effect-rdf 0.0.0-stage → 0.1.0

package/dist/Dataset-BlmlcI7J.mjs

@@ -0,0 +1,782 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { B as isNamedNode, D as compareQuads, O as defaultGraph, Q as quad, W as isSubject, d as Quad, m as QuadSchema, q as isVariable, y as Triple, z as isLiteral } from "./Term-CFLG1qu4.mjs";
+import { t as loop } from "./loop-DZ2hXlr_.mjs";
+import { i as rdf } from "./Vocab-DceKywpq.mjs";
+import * as Arr from "effect/Array";
+import { dual } from "effect/Function";
+import * as Equal from "effect/Equal";
+import * as Graph from "effect/Graph";
+import * as Hash from "effect/Hash";
+import * as HashMap from "effect/HashMap";
+import * as HashSet from "effect/HashSet";
+import { NodeInspectSymbol } from "effect/Inspectable";
+import * as Iterable from "effect/Iterable";
+import * as MutableHashMap from "effect/MutableHashMap";
+import * as MutableHashSet from "effect/MutableHashSet";
+import * as Option from "effect/Option";
+import { pipeArguments } from "effect/Pipeable";
+import { hasProperty } from "effect/Predicate";
+import * as Schema from "effect/Schema";
+import * as SchemaTransformation from "effect/SchemaTransformation";
+// src/internal/pending.ts
+/** @internal */
+const pendingQuads = /* @__PURE__ */ new WeakMap();
+/**
+* How many statements a dataset was made from: its size, or for one not yet
+* built, the number of quads given (counting any duplicates).
+*
+* @internal
+*/
+const statementCount = (dataset) => pendingQuads.get(dataset)?.length ?? dataset.size;
+// src/Dataset.ts
+/**
+* Immutable, indexed RDF datasets.
+*
+* A `Dataset` is a persistent set of quads backed by Effect `HashMap`s, with
+* per-position indexes so that pattern matching only scans the most
+* selective index. Datasets implement `Equal` (set equality — use
+* `Isomorphism.isomorphic` for blank-node-aware comparison), `Hash`,
+* `Iterable<Quad>` and `Pipeable`.
+*
+* @since 0.1.0
+*/
+var Dataset_exports = /* @__PURE__ */ __exportAll({
+	DatasetSchema: () => DatasetSchema,
+	TypeId: () => TypeId,
+	add: () => add,
+	addAll: () => addAll,
+	count: () => count,
+	difference: () => difference,
+	empty: () => empty,
+	every: () => every,
+	filter: () => filter,
+	filterMatches: () => filterMatches,
+	flatMap: () => flatMap,
+	fromGraph: () => fromGraph,
+	fromIterable: () => fromIterable,
+	fromTriples: () => fromTriples,
+	graph: () => graph,
+	graphs: () => graphs,
+	has: () => has,
+	intersection: () => intersection,
+	isDataset: () => isDataset,
+	isEmpty: () => isEmpty,
+	isSubset: () => isSubset,
+	list: () => list,
+	make: () => make,
+	map: () => map,
+	match: () => match,
+	mutate: () => mutate,
+	objectOf: () => objectOf,
+	objects: () => objects,
+	objectsOf: () => objectsOf,
+	predicates: () => predicates,
+	reduce: () => reduce,
+	remove: () => remove,
+	removeMatches: () => removeMatches,
+	some: () => some,
+	subjects: () => subjects,
+	subjectsOf: () => subjectsOf,
+	toArray: () => toArray,
+	toGraph: () => toGraph,
+	toNQuads: () => toNQuads,
+	toSortedArray: () => toSortedArray,
+	triples: () => triples,
+	union: () => union,
+	withGraph: () => withGraph
+});
+/**
+* @since 0.1.0
+* @category symbols
+*/
+const TypeId = Symbol.for("@thomasfosterau/effect-rdf/Dataset");
+/** `isDataset` for a value already known to be an object. */
+const hasDatasetTypeId = (u) => TypeId in u;
+/**
+* The indexes of the datasets that have been matched against, built on
+* first use: parsing a document and serializing it never pays for them. A
+* `WeakMap` rather than a field, so a dataset's own properties do not depend
+* on whether it has been matched.
+*/
+const indexes = /* @__PURE__ */ new WeakMap();
+/**
+* A parser's dataset is often only iterated or serialized once, or not at
+* all, so `fromIterable` keeps its quads (`pendingQuads`) and the persistent
+* map is built the first time it is needed (a lookup, a match or an update),
+* with the same contents.
+*/
+const pending = pendingQuads;
+/**
+* The distinct quads of the datasets made by `fromIterable`, in the order
+* first given: what such a dataset iterates (before and after its quad set
+* is built), so that iterating, counting or serializing it never builds the
+* persistent map.
+*/
+const ordered = /* @__PURE__ */ new WeakMap();
+/** Combines two hashes (a multiply-rotate step); `distinct` finishes them with `avalanche`. */
+const mix = (a, b) => Math.imul(a << 5 | a >>> 27, 2654435761) ^ b;
+/** The final mixing of a hash (MurmurHash3's), so that its low bits pick table slots well. */
+const avalanche = (h) => {
+	let x = Math.imul(h ^ h >>> 16, 2246822507);
+	x = Math.imul(x ^ x >>> 13, 3266489909);
+	return x ^ x >>> 16;
+};
+/**
+* A hash of a subject or object (equal terms hash equally) that builds no
+* key: a term's own hash, which IRIs, blank nodes and literals compute from
+* their values and cache, and for a triple term, its parts'.
+*/
+const termHash = (t) => t instanceof Triple ? mix(mix(termHash(t.subject), t.predicate[Hash.symbol]()), termHash(t.object)) : t[Hash.symbol]();
+/**
+* A quad's hash for `distinct`: its predicate and graph, usually shared
+* nodes, by their own cached hashes; its subject and object by `termHash`.
+* Each position is hashed the same way for every quad, so equal quads hash
+* equally.
+*/
+const quadHash = (q) => mix(mix(mix(termHash(q.subject), q.predicate[Hash.symbol]()), termHash(q.object)), q.graph[Hash.symbol]());
+/**
+* The distinct quads of `quads` (equal keys), keeping the first of each in
+* order: open addressing over their structural hashes, comparing keys only
+* when two hashes are equal, so that no key is built for quads that differ.
+*/
+const distinct = (quads) => {
+	const n = quads.length;
+	if (n < 2) return quads;
+	const mask = 2 ** Math.ceil(Math.log2(n * 2)) - 1;
+	const hashes = new Int32Array(mask + 1);
+	const slots = new Int32Array(mask + 1);
+	const out = [];
+	quads.forEach((q, k) => {
+		const hash = avalanche(quadHash(q));
+		let i = hash & mask;
+		let duplicate = false;
+		loop(() => {
+			const slot = slots[i] ?? 0;
+			if (slot === 0) return false;
+			if (hashes[i] === hash && (quads[slot - 1] ?? q).key === q.key) {
+				duplicate = true;
+				return false;
+			}
+			i = i + 1 & mask;
+			return true;
+		});
+		if (duplicate) return;
+		hashes[i] = hash;
+		slots[i] = k + 1;
+		out.push(q);
+	});
+	return out.length === n ? quads : out;
+};
+/** The distinct quads, in order, of a dataset made by `fromIterable` (none for any other). */
+const orderedOf = (self) => {
+	const known = ordered.get(self);
+	if (known !== void 0) return Option.some(known);
+	const given = pending.get(self);
+	if (given === void 0) return Option.none();
+	const quads = distinct(given);
+	ordered.set(self, quads);
+	return Option.some(quads);
+};
+/** Builds a pending dataset's quad set, making it like any other dataset. */
+const materialize = (self) => {
+	const quads = buildQuads(Option.getOrElse(orderedOf(self), () => []));
+	pending.delete(self);
+	Object.defineProperty(self, "quads", {
+		value: quads,
+		enumerable: true
+	});
+	return quads;
+};
+const Proto = {
+	[TypeId]: TypeId,
+	get quads() {
+		return materialize(this);
+	},
+	get size() {
+		const size = Option.getOrElse(orderedOf(this), () => []).length;
+		Object.defineProperty(this, "size", {
+			value: size,
+			enumerable: true
+		});
+		return size;
+	},
+	[Symbol.iterator]() {
+		return Option.getOrElse(orderedOf(this), () => HashMap.values(this.quads))[Symbol.iterator]();
+	},
+	[Equal.symbol](that) {
+		if (!hasDatasetTypeId(that) || that.size !== this.size) return false;
+		const theirs = that.quads;
+		return HashMap.every(this.quads, (_quad, key) => HashMap.has(theirs, key));
+	},
+	[Hash.symbol]() {
+		return Hash.optimize(Iterable.reduce(this, 0, (h, q) => h + Hash.hash(q) | 0));
+	},
+	pipe() {
+		return pipeArguments(this, arguments);
+	},
+	toString() {
+		return toNQuads(this);
+	},
+	toJSON() {
+		return {
+			_id: "Dataset",
+			size: this.size,
+			quads: Array.from(this, (q) => q.toString())
+		};
+	},
+	[NodeInspectSymbol]() {
+		return this.toJSON();
+	}
+};
+const makeDataset = (quads) => {
+	return Object.create(Proto, {
+		quads: {
+			value: quads,
+			enumerable: true
+		},
+		size: {
+			value: HashMap.size(quads),
+			enumerable: true
+		}
+	});
+};
+const emptyIndex = HashMap.empty();
+const emptySpog = [
+	emptyIndex,
+	emptyIndex,
+	emptyIndex,
+	emptyIndex
+];
+/**
+* @since 0.1.0
+* @category guards
+*/
+const isDataset = (u) => hasProperty(u, TypeId);
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const empty = makeDataset(HashMap.empty());
+const transients = () => MutableHashMap.empty();
+const positions = (q) => [
+	q.subject.key,
+	q.predicate.key,
+	q.object.key,
+	q.graph.key
+];
+const indexBatch = (spog) => {
+	const idx = [
+		HashMap.beginMutation(spog[0]),
+		HashMap.beginMutation(spog[1]),
+		HashMap.beginMutation(spog[2]),
+		HashMap.beginMutation(spog[3])
+	];
+	const open = [
+		transients(),
+		transients(),
+		transients(),
+		transients()
+	];
+	const inner = (i, termKey) => {
+		const opened = open[i];
+		const known = MutableHashMap.get(opened, termKey);
+		if (Option.isSome(known)) return known.value;
+		const map = HashMap.beginMutation(Option.getOrElse(HashMap.get(idx[i], termKey), () => HashMap.empty()));
+		MutableHashMap.set(opened, termKey, map);
+		return map;
+	};
+	const addAt = (i, termKey, key, quad) => {
+		HashMap.set(inner(i, termKey), key, quad);
+	};
+	const removeAt = (i, termKey, key) => {
+		if (MutableHashMap.has(open[i], termKey) || HashMap.has(idx[i], termKey)) HashMap.remove(inner(i, termKey), key);
+	};
+	const close = (i) => {
+		MutableHashMap.forEach(open[i], (map, termKey) => {
+			HashMap.endMutation(map);
+			idx[i] = HashMap.size(map) === 0 ? HashMap.remove(idx[i], termKey) : HashMap.set(idx[i], termKey, map);
+		});
+	};
+	return {
+		add(quad, key) {
+			addAt(0, quad.subject.key, key, quad);
+			addAt(1, quad.predicate.key, key, quad);
+			addAt(2, quad.object.key, key, quad);
+			addAt(3, quad.graph.key, key, quad);
+		},
+		remove(quad, key) {
+			removeAt(0, quad.subject.key, key);
+			removeAt(1, quad.predicate.key, key);
+			removeAt(2, quad.object.key, key);
+			removeAt(3, quad.graph.key, key);
+		},
+		finish() {
+			close(0);
+			close(1);
+			close(2);
+			close(3);
+			return [
+				HashMap.endMutation(idx[0]),
+				HashMap.endMutation(idx[1]),
+				HashMap.endMutation(idx[2]),
+				HashMap.endMutation(idx[3])
+			];
+		}
+	};
+};
+/** The indexes of a dataset, built the first time they are needed. */
+const indexesOf = (self) => {
+	const built = indexes.get(self);
+	if (built !== void 0) return built;
+	const batch = indexBatch(emptySpog);
+	HashMap.forEach(self.quads, (quad, key) => batch.add(quad, key));
+	const spog = batch.finish();
+	indexes.set(self, spog);
+	return spog;
+};
+/**
+* Applies a batch of updates to a dataset using a transient builder.
+*
+* @since 0.1.0
+* @category combinators
+*/
+const mutate = dual(2, (self, f) => {
+	let quads = HashMap.beginMutation(self.quads);
+	const spog = indexes.get(self);
+	const batch = spog === void 0 ? void 0 : indexBatch(spog);
+	const builder = {
+		add(quad) {
+			const key = quad.key;
+			const before = HashMap.size(quads);
+			quads = HashMap.set(quads, key, quad);
+			if (HashMap.size(quads) !== before) batch?.add(quad, key);
+			return builder;
+		},
+		addAll(iterable) {
+			Iterable.forEach(iterable, (q) => {
+				builder.add(q);
+			});
+			return builder;
+		},
+		remove(quad) {
+			const key = quad.key;
+			if (!HashMap.has(quads, key)) return builder;
+			quads = HashMap.remove(quads, key);
+			batch?.remove(quad, key);
+			return builder;
+		},
+		has: (quad) => HashMap.has(quads, quad.key),
+		size: () => HashMap.size(quads)
+	};
+	f(builder);
+	const result = makeDataset(HashMap.endMutation(quads));
+	if (batch !== void 0) indexes.set(result, batch.finish());
+	return result;
+});
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const fromIterable = (quads) => {
+	if (hasDatasetTypeId(quads)) return quads;
+	const self = Object.create(Proto);
+	pending.set(self, Array.from(quads));
+	return self;
+};
+/** The quad set of `quads`, deduplicated by key (the first of equal quads is kept). */
+const buildQuads = (quads) => mutate(empty, (b) => b.addAll(quads)).quads;
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const make = (...quads) => fromIterable(quads);
+/**
+* Creates a dataset from triples, placing them in the given graph (the
+* default graph when omitted).
+*
+* @since 0.1.0
+* @category constructors
+*/
+const fromTriples = (triples, graph = defaultGraph) => mutate(empty, (b) => {
+	Iterable.forEach(triples, (t) => {
+		b.add(new Quad(t.subject, t.predicate, t.object, graph));
+	});
+});
+/**
+* @since 0.1.0
+* @category combinators
+*/
+const add = dual(2, (self, quad) => HashMap.has(self.quads, quad.key) ? self : mutate(self, (b) => b.add(quad)));
+/**
+* @since 0.1.0
+* @category combinators
+*/
+const addAll = dual(2, (self, quads) => mutate(self, (b) => b.addAll(quads)));
+/**
+* @since 0.1.0
+* @category combinators
+*/
+const remove = dual(2, (self, quad) => HashMap.has(self.quads, quad.key) ? mutate(self, (b) => b.remove(quad)) : self);
+/**
+* Removes every quad matching a pattern.
+*
+* @since 0.1.0
+* @category combinators
+*/
+const removeMatches = dual(2, (self, pattern) => {
+	const matches = match(self, pattern);
+	return Arr.isReadonlyArrayEmpty(matches) ? self : mutate(self, (b) => matches.forEach(b.remove));
+});
+/**
+* @since 0.1.0
+* @category predicates
+*/
+const has = dual(2, (self, quad) => HashMap.has(self.quads, quad.key));
+/**
+* @since 0.1.0
+* @category predicates
+*/
+const isEmpty = (self) => self.size === 0;
+/** The bound positions of a pattern (omitted positions and variables match any term). */
+const checksOf = (pattern) => {
+	const checks = [];
+	const at = (position, t) => {
+		if (t !== void 0 && !isVariable(t)) checks.push({
+			position,
+			key: t.key
+		});
+	};
+	at(0, pattern.subject);
+	at(1, pattern.predicate);
+	at(2, pattern.object);
+	at(3, pattern.graph);
+	return checks;
+};
+/**
+* Returns all quads matching a pattern, using the most selective index.
+*
+* @since 0.1.0
+* @category queries
+*/
+const match = dual(2, (self, pattern) => {
+	const checks = checksOf(pattern);
+	let candidates = Option.none();
+	let candidateSize = Infinity;
+	if (checks.some(({ position, key }) => {
+		const inner = HashMap.get(indexesOf(self)[position], key);
+		if (Option.isNone(inner)) return true;
+		const size = HashMap.size(inner.value);
+		if (size < candidateSize) {
+			candidates = inner;
+			candidateSize = size;
+		}
+		return false;
+	})) return [];
+	const source = Option.getOrElse(candidates, () => self.quads);
+	const out = [];
+	if (checks.length > 1) HashMap.forEach(source, (q) => {
+		const ks = positions(q);
+		if (checks.every(({ position, key }) => ks[position] === key)) out.push(q);
+	});
+	else HashMap.forEach(source, (q) => {
+		out.push(q);
+	});
+	return out;
+});
+/**
+* Counts the quads matching a pattern.
+*
+* @since 0.1.0
+* @category queries
+*/
+const count = dual(2, (self, pattern) => match(self, pattern).length);
+/**
+* Returns a dataset containing only the quads matching a pattern.
+*
+* @since 0.1.0
+* @category queries
+*/
+const filterMatches = dual(2, (self, pattern) => fromIterable(match(self, pattern)));
+/**
+* The objects of all quads with the given subject and predicate (in any
+* graph unless one is specified).
+*
+* @since 0.1.0
+* @category queries
+*/
+const objectsOf = (self, subject, predicate, graph) => uniqueTerms(match(self, {
+	subject,
+	predicate,
+	graph
+}).map((q) => q.object));
+/**
+* The first object of a subject/predicate pair, if any.
+*
+* @since 0.1.0
+* @category queries
+*/
+const objectOf = (self, subject, predicate, graph) => Option.fromNullishOr(match(self, {
+	subject,
+	predicate,
+	graph
+})[0]?.object);
+/**
+* The subjects of all quads with the given predicate and object.
+*
+* @since 0.1.0
+* @category queries
+*/
+const subjectsOf = (self, predicate, object, graph) => uniqueTerms(match(self, {
+	predicate,
+	object,
+	graph
+}).map((q) => q.subject));
+const uniqueTerms = (terms) => {
+	if (terms.length < 2) return terms;
+	return uniqueByKey(terms);
+};
+/** The first of each group of values with equal keys, in order. */
+const uniqueByKey = (values) => {
+	const seen = MutableHashMap.empty();
+	Iterable.forEach(values, (t) => {
+		if (!MutableHashMap.has(seen, t.key)) MutableHashMap.set(seen, t.key, t);
+	});
+	return Arr.fromIterable(MutableHashMap.values(seen));
+};
+const termsAt = (self, position, pick) => Arr.flatMap(Arr.fromIterable(HashMap.values(indexesOf(self)[position])), (inner) => Arr.fromOption(Option.map(Iterable.head(HashMap.values(inner)), pick)));
+/**
+* All distinct subjects.
+*
+* @since 0.1.0
+* @category queries
+*/
+const subjects = (self) => termsAt(self, 0, (q) => q.subject);
+/**
+* All distinct predicates.
+*
+* @since 0.1.0
+* @category queries
+*/
+const predicates = (self) => termsAt(self, 1, (q) => q.predicate);
+/**
+* All distinct objects.
+*
+* @since 0.1.0
+* @category queries
+*/
+const objects = (self) => termsAt(self, 2, (q) => q.object);
+/**
+* All distinct graph names (including the default graph if it is non-empty).
+*
+* @since 0.1.0
+* @category queries
+*/
+const graphs = (self) => termsAt(self, 3, (q) => q.graph);
+/**
+* The quads of one graph.
+*
+* @since 0.1.0
+* @category queries
+*/
+const graph = dual(2, (self, graphName) => filterMatches(self, { graph: graphName }));
+/**
+* The triples of the dataset, ignoring graph names (duplicates across graphs
+* are merged).
+*
+* @since 0.1.0
+* @category conversions
+*/
+const triples = (self) => {
+	return uniqueByKey(Iterable.map(self, (q) => q.triple));
+};
+/**
+* Moves every quad into a single graph.
+*
+* @since 0.1.0
+* @category combinators
+*/
+const withGraph = dual(2, (self, graphName) => fromIterable(Array.from(self, (q) => new Quad(q.subject, q.predicate, q.object, graphName))));
+/**
+* Reads an RDF collection (`rdf:first`/`rdf:rest` list) starting at `head`.
+* Returns `None` if the list is malformed (missing or multiple `first`/`rest`
+* values, or cyclic).
+*
+* @since 0.1.0
+* @category queries
+*/
+const list = (self, head, graphName) => {
+	const items = [];
+	const seen = MutableHashSet.empty();
+	let node = head;
+	let wellFormed = true;
+	loop(() => {
+		const current = node;
+		if (isNamedNode(current) && current.value === rdf.nil.value) return false;
+		if (isLiteral(current) || MutableHashSet.has(seen, current.key)) {
+			wellFormed = false;
+			return false;
+		}
+		MutableHashSet.add(seen, current.key);
+		const first = objectsOf(self, current, rdf.first, graphName);
+		const rest = objectsOf(self, current, rdf.rest, graphName);
+		if (!Arr.isReadonlyArrayNonEmpty(first) || !Arr.isReadonlyArrayNonEmpty(rest) || first.length !== 1 || rest.length !== 1) {
+			wellFormed = false;
+			return false;
+		}
+		items.push(first[0]);
+		node = rest[0];
+		return true;
+	});
+	return wellFormed ? Option.some(items) : Option.none();
+};
+/**
+* @since 0.1.0
+* @category combinators
+*/
+const union = dual(2, (self, that) => self.size >= that.size ? addAll(self, that) : addAll(that, self));
+/**
+* @since 0.1.0
+* @category combinators
+*/
+const intersection = dual(2, (self, that) => filter(self, (q) => has(that, q)));
+/**
+* @since 0.1.0
+* @category combinators
+*/
+const difference = dual(2, (self, that) => mutate(self, (b) => {
+	Iterable.forEach(that, (q) => {
+		b.remove(q);
+	});
+}));
+/**
+* @since 0.1.0
+* @category combinators
+*/
+const filter = dual(2, (self, predicate) => mutate(empty, (b) => {
+	Iterable.forEach(self, (q) => {
+		if (predicate(q)) b.add(q);
+	});
+}));
+/**
+* @since 0.1.0
+* @category combinators
+*/
+const map = dual(2, (self, f) => mutate(empty, (b) => {
+	Iterable.forEach(self, (q) => {
+		b.add(f(q));
+	});
+}));
+/**
+* @since 0.1.0
+* @category combinators
+*/
+const flatMap = dual(2, (self, f) => mutate(empty, (b) => {
+	Iterable.forEach(self, (q) => {
+		b.addAll(f(q));
+	});
+}));
+/**
+* @since 0.1.0
+* @category folding
+*/
+const reduce = dual(3, (self, initial, f) => Iterable.reduce(self, initial, (acc, q) => f(acc, q)));
+/**
+* @since 0.1.0
+* @category predicates
+*/
+const some = dual(2, (self, predicate) => Iterable.some(self, (q) => predicate(q)));
+/**
+* @since 0.1.0
+* @category predicates
+*/
+const every = dual(2, (self, predicate) => !Iterable.some(self, (q) => !predicate(q)));
+/**
+* Whether every quad of `self` is in `that`.
+*
+* @since 0.1.0
+* @category predicates
+*/
+const isSubset = dual(2, (self, that) => every(self, (q) => has(that, q)));
+/**
+* @since 0.1.0
+* @category conversions
+*/
+const toArray = (self) => Array.from(self);
+/**
+* The quads in a deterministic order (graph, subject, predicate, object).
+*
+* @since 0.1.0
+* @category conversions
+*/
+const toSortedArray = (self) => Arr.sort(self, compareQuads);
+/**
+* Serialises to canonical, sorted N-Quads (one statement per line).
+*
+* @since 0.1.0
+* @category conversions
+*/
+const toNQuads = (self) => toSortedArray(self).map((q) => `${q.toString()}\n`).join("");
+/**
+* Schema of a dataset; its JSON codec is an array of `TermJson.Quad`s in
+* `toSortedArray` order, so encoding is deterministic.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const DatasetSchema = Schema.declare(isDataset, {
+	identifier: "Dataset",
+	toCodecJson: () => Schema.link()(Schema.Array(QuadSchema), SchemaTransformation.transform({
+		decode: fromIterable,
+		encode: toSortedArray
+	})),
+	toCodecArbitrary: () => Schema.link()(Schema.Array(QuadSchema).check(Schema.isMaxLength(12)), SchemaTransformation.transform({
+		decode: fromIterable,
+		encode: toSortedArray
+	}))
+});
+/**
+* Converts a dataset to an `effect/Graph` directed graph for graph
+* algorithms — topological order of a class hierarchy, cycle detection,
+* shortest paths, reachability, connected components. Every subject and
+* object becomes one node (equal terms share it) and every quad an edge
+* from its subject to its object, labelled with its predicate; triple terms
+* are nodes, not expanded.
+*
+* @since 0.1.0
+* @category graphs
+*/
+const toGraph = (self, options = {}) => {
+	const keep = options.predicates === void 0 ? void 0 : HashSet.fromIterable(options.predicates);
+	const edges = Arr.filter(options.graph === void 0 ? Arr.fromIterable(self) : match(self, { graph: options.graph }), (q) => (keep === void 0 || HashSet.has(keep, q.predicate)) && (options.literals === true || !isLiteral(q.object)));
+	let nodes = HashMap.empty();
+	return {
+		graph: Graph.directed((mutable) => {
+			const nodeOf = (term) => Option.getOrElse(HashMap.get(nodes, term), () => {
+				const added = Graph.addNode(mutable, term);
+				nodes = HashMap.set(nodes, term, added);
+				return added;
+			});
+			Arr.forEach(edges, (q) => {
+				Graph.addEdge(mutable, nodeOf(q.subject), nodeOf(q.object), q.predicate);
+			});
+		}),
+		nodes
+	};
+};
+/**
+* Converts a directed graph whose nodes are terms and whose edges are
+* predicates back to a dataset: each edge becomes a quad in `graphName` (the
+* default graph when omitted). Edges from a node that cannot be a subject
+* (a literal) are left out.
+*
+* @since 0.1.0
+* @category graphs
+*/
+const fromGraph = (source, graphName = defaultGraph) => fromIterable(Arr.flatMap(Arr.fromIterable(Graph.edges(source)), ([, edge]) => {
+	const subject = Graph.getNode(source, edge.source);
+	const object = Graph.getNode(source, edge.target);
+	return Option.isSome(subject) && Option.isSome(object) && isSubject(subject.value) ? [quad(subject.value, edge.data, object.value, graphName)] : [];
+}));
+export { objectsOf as A, toNQuads as B, list as C, mutate as D, match as E, some as F, statementCount as G, triples as H, subjects as I, subjectsOf as L, reduce as M, remove as N, objectOf as O, removeMatches as P, toArray as R, isSubset as S, map as T, union as U, toSortedArray as V, withGraph as W, graphs as _, addAll as a, isDataset as b, empty as c, filterMatches as d, flatMap as f, graph as g, fromTriples as h, add as i, predicates as j, objects as k, every as l, fromIterable as m, Dataset_exports as n, count as o, fromGraph as p, TypeId as r, difference as s, DatasetSchema as t, filter as u, has as v, make as w, isEmpty as x, intersection as y, toGraph as z };
+
+//# sourceMappingURL=Dataset-BlmlcI7J.mjs.map