@thomasfosterau/effect-rdf 0.0.0 → 0.1.0

package/dist/Path-B20Yp8KE.mjs

@@ -0,0 +1,284 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { B as isNamedNode, N as isBlankNode, O as defaultGraph, Q as quad, T as blankNode, V as isObject, z as isLiteral } from "./Term-CFLG1qu4.mjs";
+import { A as objectsOf, C as list, E as match } from "./Dataset-BlmlcI7J.mjs";
+import { t as Vocab_exports } from "./Vocab-DceKywpq.mjs";
+import { r as sh } from "./Vocabulary-CnQl-_Z4.mjs";
+import * as Arr from "effect/Array";
+import { constVoid, pipe } from "effect/Function";
+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 * as Predicate from "effect/Predicate";
+import * as Match from "effect/Match";
+import * as Result from "effect/Result";
+// src/shacl/Path.ts
+/**
+* SHACL property paths (§2.3.1): a typed model, evaluation against a data
+* graph, and conversion to and from their RDF encoding.
+*
+* @since 0.1.0
+*/
+var Path_exports = /* @__PURE__ */ __exportAll({
+	PathSyntaxError: () => PathSyntaxError,
+	alternative: () => alternative,
+	equals: () => equals,
+	evaluate: () => evaluate,
+	fromRdf: () => fromRdf,
+	inverse: () => inverse,
+	oneOrMore: () => oneOrMore,
+	predicate: () => predicate,
+	sequence: () => sequence,
+	toRdf: () => toRdf,
+	toSparql: () => toSparql,
+	zeroOrMore: () => zeroOrMore,
+	zeroOrOne: () => zeroOrOne
+});
+const { rdf } = Vocab_exports;
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const predicate = (iri) => ({
+	_tag: "PredicatePath",
+	predicate: iri
+});
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const sequence = (...paths) => ({
+	_tag: "SequencePath",
+	paths
+});
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const alternative = (...paths) => ({
+	_tag: "AlternativePath",
+	paths
+});
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const inverse = (path) => ({
+	_tag: "InversePath",
+	path
+});
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const zeroOrMore = (path) => ({
+	_tag: "ZeroOrMorePath",
+	path
+});
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const oneOrMore = (path) => ({
+	_tag: "OneOrMorePath",
+	path
+});
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const zeroOrOne = (path) => ({
+	_tag: "ZeroOrOnePath",
+	path
+});
+const isPredicatePath = (p) => Predicate.isTagged(p, "PredicatePath");
+const isSequencePath = (p) => Predicate.isTagged(p, "SequencePath");
+const isAlternativePath = (p) => Predicate.isTagged(p, "AlternativePath");
+const equalsMatch = Match.fn((a, _b) => a).pipe(Match.tag("PredicatePath", (first, _a, b) => isPredicatePath(b) && first.predicate.value === b.predicate.value), Match.tag("SequencePath", (first, _a, b) => isSequencePath(b) && pathsEqual(first.paths, b.paths)), Match.tag("AlternativePath", (first, _a, b) => isAlternativePath(b) && pathsEqual(first.paths, b.paths)), Match.orElse((first, _a, b) => "path" in b && first._tag === b._tag && equals(first.path, b.path)));
+const pathsEqual = Arr.makeEquivalence((a, b) => equals(a, b));
+/**
+* Structural equality of paths.
+*
+* @since 0.1.0
+* @category equivalence
+*/
+const equals = (a, b) => equalsMatch(a, b);
+/**
+* Renders a path in SPARQL property path syntax, e.g. `^<p>/<q>*`.
+*
+* @since 0.1.0
+* @category formatting
+*/
+const toSparql = (self) => {
+	const wrap = (p) => "paths" in p ? `(${toSparql(p)})` : toSparql(p);
+	return Match.value(self).pipe(Match.tag("PredicatePath", (node) => node.predicate.key), Match.tag("SequencePath", (node) => node.paths.map(wrap).join("/")), Match.tag("AlternativePath", (node) => node.paths.map(wrap).join("|")), Match.tag("InversePath", (node) => `^${wrap(node.path)}`), Match.tag("ZeroOrMorePath", (node) => `${wrap(node.path)}*`), Match.tag("OneOrMorePath", (node) => `${wrap(node.path)}+`), Match.tag("ZeroOrOnePath", (node) => `${wrap(node.path)}?`), Match.exhaustive);
+};
+const addNode = (out, node) => {
+	MutableHashMap.set(out, node.key, node);
+};
+const addAll = (out, from) => MutableHashMap.forEach(from, (node, key) => {
+	MutableHashMap.set(out, key, node);
+});
+/**
+* The breadth-first closure of `path` from the one-step successors in
+* `first`, added to `out`.
+*/
+const closure = (data, path, first, isInverse, out) => {
+	const advance = (frontier) => {
+		if (MutableHashMap.isEmpty(frontier)) return Option.none();
+		const next = MutableHashMap.empty();
+		MutableHashMap.forEach(frontier, (node, key) => {
+			if (MutableHashMap.has(out, key)) return;
+			MutableHashMap.set(out, key, node);
+			MutableHashMap.set(next, key, node);
+		});
+		return Option.some([void 0, MutableHashMap.isEmpty(next) ? next : step(path, data, next, isInverse)]);
+	};
+	Iterable.forEach(Iterable.unfold(first, advance), constVoid);
+};
+const isInversePath = (p) => Predicate.isTagged(p, "InversePath");
+const isZeroOrOnePath = (p) => Predicate.isTagged(p, "ZeroOrOnePath");
+const stepPredicate = (path, data, nodes, isInverse) => {
+	const out = MutableHashMap.empty();
+	MutableHashMap.forEach(nodes, (node) => {
+		if (isInverse) Arr.forEach(match(data, {
+			predicate: path.predicate,
+			object: node
+		}), (q) => addNode(out, q.subject));
+		else if (!isLiteral(node)) Arr.forEach(match(data, {
+			subject: node,
+			predicate: path.predicate
+		}), (q) => addNode(out, q.object));
+	});
+	return out;
+};
+const stepAlternative = (path, data, nodes, isInverse) => {
+	const out = MutableHashMap.empty();
+	Arr.forEach(path.paths, (p) => addAll(out, step(p, data, nodes, isInverse)));
+	return out;
+};
+/** `sh:zeroOrOnePath`, `sh:zeroOrMorePath` and `sh:oneOrMorePath`. */
+const stepRepeat = (path, data, nodes, isInverse) => {
+	const out = MutableHashMap.empty();
+	if (!Predicate.isTagged(path, "OneOrMorePath")) addAll(out, nodes);
+	const first = step(path.path, data, nodes, isInverse);
+	if (isZeroOrOnePath(path)) addAll(out, first);
+	else closure(data, path.path, first, isInverse, out);
+	return out;
+};
+const step = (segment, data, nodes, isInverse) => {
+	if (isPredicatePath(segment)) return stepPredicate(segment, data, nodes, isInverse);
+	if (isSequencePath(segment)) return Arr.reduce(isInverse ? segment.paths.toReversed() : segment.paths, nodes, (current, p) => step(p, data, current, isInverse));
+	if (isAlternativePath(segment)) return stepAlternative(segment, data, nodes, isInverse);
+	if (isInversePath(segment)) return step(segment.path, data, nodes, !isInverse);
+	return stepRepeat(segment, data, nodes, isInverse);
+};
+/**
+* The value nodes reachable from `focus` by following `path` in `data`
+* (duplicates removed, in discovery order).
+*
+* @since 0.1.0
+* @category evaluation
+*/
+const evaluate = (data, focus, path) => Arr.fromIterable(MutableHashMap.values(step(path, data, MutableHashMap.make([focus.key, focus]), false)));
+/**
+* Why a path node could not be read.
+*
+* @since 0.1.0
+* @category models
+*/
+var PathSyntaxError = class {
+	_tag = "PathSyntaxError";
+	node;
+	message;
+	constructor(node, message) {
+		this.node = node;
+		this.message = message;
+	}
+};
+/**
+* Reads the SHACL path rooted at `node` from a shapes graph, failing with a
+* `PathSyntaxError` when the node is not a well-formed path.
+*
+* @since 0.1.0
+* @category decoding
+*/
+const fromRdf = (graph, node) => {
+	const visiting = MutableHashSet.empty();
+	const bad = (n, message) => {
+		throw new PathSyntaxError(n, message);
+	};
+	const readList = (owner, head, kind) => {
+		const items = isObject(head) ? list(graph, head) : Option.none();
+		if (Option.isNone(items)) return bad(owner, `${head.key} is not a well-formed list`);
+		if (items.value.length < 2) return bad(owner, `${kind} path ${owner.key} must have at least two members`);
+		return items.value.map(go);
+	};
+	const go = (n) => {
+		if (isNamedNode(n)) return predicate(n);
+		if (!isBlankNode(n)) return bad(n, `${n.key} is not a valid SHACL path`);
+		if (MutableHashSet.has(visiting, n.key)) return bad(n, `${n.key} is a recursive path`);
+		MutableHashSet.add(visiting, n.key);
+		const read = Result.try(() => readNode(n));
+		MutableHashSet.remove(visiting, n.key);
+		if (Result.isFailure(read)) throw read.failure;
+		return read.success;
+	};
+	const readNode = (n) => {
+		if (Arr.isReadonlyArrayNonEmpty(match(graph, {
+			subject: n,
+			predicate: rdf.first
+		}))) return sequence(...readList(n, n, "sequence"));
+		const single = (p) => {
+			const values = objectsOf(graph, n, p);
+			if (values.length > 1) bad(n, `${n.key} has multiple values for ${p.key}`);
+			return Arr.head(values);
+		};
+		const unary = (p, make) => () => Option.map(single(p), (inner) => make(go(inner)));
+		return pipe(Option.map(single(sh.alternativePath), (alt) => alternative(...readList(n, alt, "alternative"))), Option.orElse(unary(sh.inversePath, inverse)), Option.orElse(unary(sh.zeroOrMorePath, zeroOrMore)), Option.orElse(unary(sh.oneOrMorePath, oneOrMore)), Option.orElse(unary(sh.zeroOrOnePath, zeroOrOne)), Option.getOrElse(() => bad(n, `${n.key} is not a valid SHACL path`)));
+	};
+	return Result.try({
+		try: () => go(node),
+		catch: (e) => {
+			if (e instanceof PathSyntaxError) return e;
+			throw e;
+		}
+	});
+};
+/**
+* Encodes a path as RDF, returning the path's root term and the triples
+* describing it (using fresh blank nodes for non-predicate paths).
+*
+* @since 0.1.0
+* @category encoding
+*/
+const toRdf = (self, graph = defaultGraph) => {
+	const quads = [];
+	const list = (items) => {
+		const nodes = items.map(() => blankNode());
+		Arr.forEach(Arr.zip(nodes, items), ([node, item], i) => {
+			quads.push(quad(node, rdf.first, go(item), graph));
+			quads.push(quad(node, rdf.rest, nodes[i + 1] ?? rdf.nil, graph));
+		});
+		return nodes[0] ?? rdf.nil;
+	};
+	const unary = (p, inner) => {
+		const b = blankNode();
+		quads.push(quad(b, p, go(inner), graph));
+		return b;
+	};
+	const go = (node) => {
+		return Match.value(node).pipe(Match.tag("PredicatePath", (p) => p.predicate), Match.tag("SequencePath", (p) => list(p.paths)), Match.tag("AlternativePath", (p) => {
+			const b = blankNode();
+			quads.push(quad(b, sh.alternativePath, list(p.paths), graph));
+			return b;
+		}), Match.tag("InversePath", (p) => unary(sh.inversePath, p.path)), Match.tag("ZeroOrMorePath", (p) => unary(sh.zeroOrMorePath, p.path)), Match.tag("OneOrMorePath", (p) => unary(sh.oneOrMorePath, p.path)), Match.tag("ZeroOrOnePath", (p) => unary(sh.zeroOrOnePath, p.path)), Match.exhaustive);
+	};
+	return {
+		node: go(self),
+		quads
+	};
+};
+export { evaluate as a, oneOrMore as c, toRdf as d, toSparql as f, equals as i, predicate as l, zeroOrOne as m, Path_exports as n, fromRdf as o, zeroOrMore as p, alternative as r, inverse as s, PathSyntaxError as t, sequence as u };
+
+//# sourceMappingURL=Path-B20Yp8KE.mjs.map

package/dist/Path-B20Yp8KE.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Path-B20Yp8KE.mjs","names":["Vocab","Dataset.match","Term.isLiteral","Term.isObject","Dataset.list","Term.isNamedNode","Term.isBlankNode","Dataset.objectsOf","Term.defaultGraph","Term.blankNode","Term.quad"],"sources":["../src/shacl/Path.ts"],"sourcesContent":["/**\n * SHACL property paths (§2.3.1): a typed model, evaluation against a data\n * graph, and conversion to and from their RDF encoding.\n *\n * @since 0.1.0\n */\nimport { Dataset, Term, Vocab } from '../index.ts';\nimport * as Arr from 'effect/Array';\nimport { constVoid, pipe } from 'effect/Function';\nimport * as Iterable from 'effect/Iterable';\nimport * as Match from 'effect/Match';\nimport * as MutableHashMap from 'effect/MutableHashMap';\nimport * as MutableHashSet from 'effect/MutableHashSet';\nimport * as Option from 'effect/Option';\nimport * as Predicate from 'effect/Predicate';\nimport * as Result from 'effect/Result';\nimport { sh } from './Vocabulary.ts';\n\nconst { rdf } = Vocab;\n\n/**\n * A SHACL property path.\n *\n * @since 0.1.0\n * @category models\n */\nexport type Path =\n  | PredicatePath\n  | SequencePath\n  | AlternativePath\n  | InversePath\n  | ZeroOrMorePath\n  | OneOrMorePath\n  | ZeroOrOnePath;\n\n/**\n * A predicate path: a single IRI.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface PredicatePath {\n  readonly _tag: 'PredicatePath';\n  readonly predicate: Term.NamedNode;\n}\n\n/**\n * A sequence path: an RDF list of at least two paths.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface SequencePath {\n  readonly _tag: 'SequencePath';\n  readonly paths: ReadonlyArray<Path>;\n}\n\n/**\n * An alternative path (`sh:alternativePath`).\n *\n * @since 0.1.0\n * @category models\n */\nexport interface AlternativePath {\n  readonly _tag: 'AlternativePath';\n  readonly paths: ReadonlyArray<Path>;\n}\n\n/**\n * An inverse path (`sh:inversePath`).\n *\n * @since 0.1.0\n * @category models\n */\nexport interface InversePath {\n  readonly _tag: 'InversePath';\n  readonly path: Path;\n}\n\n/**\n * A zero-or-more path (`sh:zeroOrMorePath`).\n *\n * @since 0.1.0\n * @category models\n */\nexport interface ZeroOrMorePath {\n  readonly _tag: 'ZeroOrMorePath';\n  readonly path: Path;\n}\n\n/**\n * A one-or-more path (`sh:oneOrMorePath`).\n *\n * @since 0.1.0\n * @category models\n */\nexport interface OneOrMorePath {\n  readonly _tag: 'OneOrMorePath';\n  readonly path: Path;\n}\n\n/**\n * A zero-or-one path (`sh:zeroOrOnePath`).\n *\n * @since 0.1.0\n * @category models\n */\nexport interface ZeroOrOnePath {\n  readonly _tag: 'ZeroOrOnePath';\n  readonly path: Path;\n}\n\n// -----------------------------------------------------------------------------\n// Constructors\n// -----------------------------------------------------------------------------\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const predicate = (iri: Term.NamedNode): PredicatePath => ({\n  _tag: 'PredicatePath',\n  predicate: iri,\n});\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const sequence = (...paths: ReadonlyArray<Path>): SequencePath => ({\n  _tag: 'SequencePath',\n  paths,\n});\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const alternative = (...paths: ReadonlyArray<Path>): AlternativePath => ({\n  _tag: 'AlternativePath',\n  paths,\n});\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const inverse = (path: Path): InversePath => ({ _tag: 'InversePath', path });\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const zeroOrMore = (path: Path): ZeroOrMorePath => ({ _tag: 'ZeroOrMorePath', path });\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const oneOrMore = (path: Path): OneOrMorePath => ({ _tag: 'OneOrMorePath', path });\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const zeroOrOne = (path: Path): ZeroOrOnePath => ({ _tag: 'ZeroOrOnePath', path });\n\n// -----------------------------------------------------------------------------\n// Utilities\n// -----------------------------------------------------------------------------\n\nconst isPredicatePath = (p: Path): p is PredicatePath => Predicate.isTagged(p, 'PredicatePath');\nconst isSequencePath = (p: Path): p is SequencePath => Predicate.isTagged(p, 'SequencePath');\nconst isAlternativePath = (p: Path): p is AlternativePath =>\n  Predicate.isTagged(p, 'AlternativePath');\n\n// Built once: `equals` recurses through every sub-path.\nconst equalsMatch: (a: Path, b: Path) => boolean = Match.fn((a: Path, _b: Path) => a).pipe(\n  Match.tag(\n    'PredicatePath',\n    (first, _a, b) => isPredicatePath(b) && first.predicate.value === b.predicate.value,\n  ),\n  Match.tag(\n    'SequencePath',\n    (first, _a, b) => isSequencePath(b) && pathsEqual(first.paths, b.paths),\n  ),\n  Match.tag(\n    'AlternativePath',\n    (first, _a, b) => isAlternativePath(b) && pathsEqual(first.paths, b.paths),\n  ),\n  Match.orElse(\n    (first, _a, b) => 'path' in b && first._tag === b._tag && equals(first.path, b.path),\n  ),\n);\n\nconst pathsEqual = Arr.makeEquivalence<Path>((a, b) => equals(a, b));\n\n/**\n * Structural equality of paths.\n *\n * @since 0.1.0\n * @category equivalence\n */\nexport const equals = (a: Path, b: Path): boolean => equalsMatch(a, b);\n\n/**\n * Renders a path in SPARQL property path syntax, e.g. `^<p>/<q>*`.\n *\n * @since 0.1.0\n * @category formatting\n */\nexport const toSparql = (self: Path): string => {\n  const wrap = (p: Path) => ('paths' in p ? `(${toSparql(p)})` : toSparql(p));\n  return Match.value(self).pipe(\n    Match.tag('PredicatePath', (node) => node.predicate.key),\n    Match.tag('SequencePath', (node) => node.paths.map(wrap).join('/')),\n    Match.tag('AlternativePath', (node) => node.paths.map(wrap).join('|')),\n    Match.tag('InversePath', (node) => `^${wrap(node.path)}`),\n    Match.tag('ZeroOrMorePath', (node) => `${wrap(node.path)}*`),\n    Match.tag('OneOrMorePath', (node) => `${wrap(node.path)}+`),\n    Match.tag('ZeroOrOnePath', (node) => `${wrap(node.path)}?`),\n    Match.exhaustive,\n  );\n};\n\n// -----------------------------------------------------------------------------\n// Evaluation\n// -----------------------------------------------------------------------------\n\ntype Node = Term.GroundTerm;\n\n/** Nodes keyed by their N-Triples form, in discovery order. */\ntype Nodes = MutableHashMap.MutableHashMap<string, Node>;\n\nconst addNode = (out: Nodes, node: Node): void => {\n  MutableHashMap.set(out, node.key, node);\n};\n\nconst addAll = (out: Nodes, from: Nodes): void =>\n  MutableHashMap.forEach(from, (node, key) => {\n    MutableHashMap.set(out, key, node);\n  });\n\n/**\n * The breadth-first closure of `path` from the one-step successors in\n * `first`, added to `out`.\n */\nconst closure = (\n  data: Dataset.Dataset,\n  path: Path,\n  first: Nodes,\n  isInverse: boolean,\n  out: Nodes,\n): void => {\n  const advance = (frontier: Nodes): Option.Option<readonly [void, Nodes]> => {\n    if (MutableHashMap.isEmpty(frontier)) return Option.none();\n    const next: Nodes = MutableHashMap.empty();\n    MutableHashMap.forEach(frontier, (node, key) => {\n      if (MutableHashMap.has(out, key)) return;\n      MutableHashMap.set(out, key, node);\n      MutableHashMap.set(next, key, node);\n    });\n    return Option.some([\n      undefined,\n      MutableHashMap.isEmpty(next) ? next : step(path, data, next, isInverse),\n    ]);\n  };\n  Iterable.forEach(Iterable.unfold(first, advance), constVoid);\n};\n\nconst isInversePath = (p: Path): p is InversePath => Predicate.isTagged(p, 'InversePath');\nconst isZeroOrOnePath = (p: Path): p is ZeroOrOnePath => Predicate.isTagged(p, 'ZeroOrOnePath');\n\nconst stepPredicate = (\n  path: PredicatePath,\n  data: Dataset.Dataset,\n  nodes: Nodes,\n  isInverse: boolean,\n): Nodes => {\n  const out: Nodes = MutableHashMap.empty();\n  MutableHashMap.forEach(nodes, (node) => {\n    if (isInverse)\n      Arr.forEach(Dataset.match(data, { predicate: path.predicate, object: node }), (q) =>\n        addNode(out, q.subject),\n      );\n    else if (!Term.isLiteral(node))\n      Arr.forEach(Dataset.match(data, { subject: node, predicate: path.predicate }), (q) =>\n        addNode(out, q.object),\n      );\n  });\n  return out;\n};\n\nconst stepAlternative = (\n  path: AlternativePath,\n  data: Dataset.Dataset,\n  nodes: Nodes,\n  isInverse: boolean,\n): Nodes => {\n  const out: Nodes = MutableHashMap.empty();\n  Arr.forEach(path.paths, (p) => addAll(out, step(p, data, nodes, isInverse)));\n  return out;\n};\n\n/** `sh:zeroOrOnePath`, `sh:zeroOrMorePath` and `sh:oneOrMorePath`. */\nconst stepRepeat = (\n  path: ZeroOrOnePath | ZeroOrMorePath | OneOrMorePath,\n  data: Dataset.Dataset,\n  nodes: Nodes,\n  isInverse: boolean,\n): Nodes => {\n  const out: Nodes = MutableHashMap.empty();\n  if (!Predicate.isTagged(path, 'OneOrMorePath')) addAll(out, nodes);\n  const first = step(path.path, data, nodes, isInverse);\n  if (isZeroOrOnePath(path)) addAll(out, first);\n  else closure(data, path.path, first, isInverse, out);\n  return out;\n};\n\n// Plain guards rather than a `Match`: `step` runs for every path segment of\n// every focus node.\nconst step = (segment: Path, data: Dataset.Dataset, nodes: Nodes, isInverse: boolean): Nodes => {\n  if (isPredicatePath(segment)) return stepPredicate(segment, data, nodes, isInverse);\n  if (isSequencePath(segment))\n    return Arr.reduce(isInverse ? segment.paths.toReversed() : segment.paths, nodes, (current, p) =>\n      step(p, data, current, isInverse),\n    );\n  if (isAlternativePath(segment)) return stepAlternative(segment, data, nodes, isInverse);\n  if (isInversePath(segment)) return step(segment.path, data, nodes, !isInverse);\n  return stepRepeat(segment, data, nodes, isInverse);\n};\n\n/**\n * The value nodes reachable from `focus` by following `path` in `data`\n * (duplicates removed, in discovery order).\n *\n * @since 0.1.0\n * @category evaluation\n */\nexport const evaluate = (\n  data: Dataset.Dataset,\n  focus: Term.GroundTerm,\n  path: Path,\n): ReadonlyArray<Term.GroundTerm> =>\n  Arr.fromIterable(\n    MutableHashMap.values(step(path, data, MutableHashMap.make([focus.key, focus]), false)),\n  );\n\n// -----------------------------------------------------------------------------\n// RDF encoding\n// -----------------------------------------------------------------------------\n\n/**\n * Why a path node could not be read.\n *\n * @since 0.1.0\n * @category models\n */\nexport class PathSyntaxError {\n  readonly _tag = 'PathSyntaxError';\n  readonly node: Term.Term;\n  readonly message: string;\n  constructor(node: Term.Term, message: string) {\n    this.node = node;\n    this.message = message;\n  }\n}\n\n/**\n * Reads the SHACL path rooted at `node` from a shapes graph, failing with a\n * `PathSyntaxError` when the node is not a well-formed path.\n *\n * @since 0.1.0\n * @category decoding\n */\nexport const fromRdf = (\n  graph: Dataset.Dataset,\n  node: Term.Term,\n): Result.Result<Path, PathSyntaxError> => {\n  const visiting = MutableHashSet.empty<string>();\n  const bad = (n: Term.Term, message: string): never => {\n    throw new PathSyntaxError(n, message);\n  };\n  const readList = (owner: Term.Term, head: Term.Term, kind: string): ReadonlyArray<Path> => {\n    const items = Term.isObject(head) ? Dataset.list(graph, head) : Option.none();\n    if (Option.isNone(items)) return bad(owner, `${head.key} is not a well-formed list`);\n    if (items.value.length < 2)\n      return bad(owner, `${kind} path ${owner.key} must have at least two members`);\n    return items.value.map(go);\n  };\n  const go = (n: Term.Term): Path => {\n    if (Term.isNamedNode(n)) return predicate(n);\n    if (!Term.isBlankNode(n)) return bad(n, `${n.key} is not a valid SHACL path`);\n    if (MutableHashSet.has(visiting, n.key)) return bad(n, `${n.key} is a recursive path`);\n    MutableHashSet.add(visiting, n.key);\n    const read = Result.try(() => readNode(n));\n    MutableHashSet.remove(visiting, n.key);\n    if (Result.isFailure(read)) throw read.failure;\n    return read.success;\n  };\n  const readNode = (n: Term.BlankNode): Path => {\n    if (Arr.isReadonlyArrayNonEmpty(Dataset.match(graph, { subject: n, predicate: rdf.first }))) {\n      return sequence(...readList(n, n, 'sequence'));\n    }\n    const single = (p: Term.NamedNode): Option.Option<Term.Term> => {\n      const values = Dataset.objectsOf(graph, n, p);\n      if (values.length > 1) bad(n, `${n.key} has multiple values for ${p.key}`);\n      return Arr.head(values);\n    };\n    const unary = (p: Term.NamedNode, make: (inner: Path) => Path) => (): Option.Option<Path> =>\n      Option.map(single(p), (inner) => make(go(inner)));\n    return pipe(\n      Option.map(single(sh.alternativePath), (alt) =>\n        alternative(...readList(n, alt, 'alternative')),\n      ),\n      Option.orElse(unary(sh.inversePath, inverse)),\n      Option.orElse(unary(sh.zeroOrMorePath, zeroOrMore)),\n      Option.orElse(unary(sh.oneOrMorePath, oneOrMore)),\n      Option.orElse(unary(sh.zeroOrOnePath, zeroOrOne)),\n      Option.getOrElse(() => bad(n, `${n.key} is not a valid SHACL path`)),\n    );\n  };\n  return Result.try({\n    try: () => go(node),\n    catch: (e) => {\n      if (e instanceof PathSyntaxError) return e;\n      throw e;\n    },\n  });\n};\n\n/**\n * A path encoded as RDF: its root term and the quads describing it.\n *\n * @since 0.1.0\n * @category encoding\n */\nexport interface PathRdf {\n  readonly node: Term.NamedNode | Term.BlankNode;\n  readonly quads: ReadonlyArray<Term.Quad>;\n}\n\n/**\n * Encodes a path as RDF, returning the path's root term and the triples\n * describing it (using fresh blank nodes for non-predicate paths).\n *\n * @since 0.1.0\n * @category encoding\n */\nexport const toRdf = (self: Path, graph: Term.Graph = Term.defaultGraph): PathRdf => {\n  const quads: Array<Term.Quad> = [];\n  const list = (items: ReadonlyArray<Path>): Term.NamedNode | Term.BlankNode => {\n    const nodes = items.map(() => Term.blankNode());\n    Arr.forEach(Arr.zip(nodes, items), ([node, item], i) => {\n      quads.push(Term.quad(node, rdf.first, go(item), graph));\n      quads.push(Term.quad(node, rdf.rest, nodes[i + 1] ?? rdf.nil, graph));\n    });\n    return nodes[0] ?? rdf.nil;\n  };\n  const unary = (p: Term.NamedNode, inner: Path) => {\n    const b = Term.blankNode();\n    quads.push(Term.quad(b, p, go(inner), graph));\n    return b;\n  };\n  const go = (node: Path): Term.NamedNode | Term.BlankNode => {\n    return Match.value(node).pipe(\n      Match.tag('PredicatePath', (p) => p.predicate),\n      Match.tag('SequencePath', (p) => list(p.paths)),\n      Match.tag('AlternativePath', (p) => {\n        const b = Term.blankNode();\n        quads.push(Term.quad(b, sh.alternativePath, list(p.paths), graph));\n        return b;\n      }),\n      Match.tag('InversePath', (p) => unary(sh.inversePath, p.path)),\n      Match.tag('ZeroOrMorePath', (p) => unary(sh.zeroOrMorePath, p.path)),\n      Match.tag('OneOrMorePath', (p) => unary(sh.oneOrMorePath, p.path)),\n      Match.tag('ZeroOrOnePath', (p) => unary(sh.zeroOrOnePath, p.path)),\n      Match.exhaustive,\n    );\n  };\n  const node = go(self);\n  return { node, quads };\n};\n"],"mappings":"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"}

package/dist/Path-DRB8e-Zn.d.mts

@@ -0,0 +1,181 @@
+import { T as Term, _ as Quad, d as NamedNode, o as Graph, s as GroundTerm, t as BlankNode } from "./Term-B_4ezyXq.mjs";
+import { n as Dataset } from "./Dataset-DS3ESOcO.mjs";
+import "./index-Cms2TYfC.mjs";
+import * as Result from "effect/Result";
+declare namespace Path_d_exports {
+  export { AlternativePath, InversePath, OneOrMorePath, Path, PathRdf, PathSyntaxError, PredicatePath, SequencePath, ZeroOrMorePath, ZeroOrOnePath, alternative, equals, evaluate, fromRdf, inverse, oneOrMore, predicate, sequence, toRdf, toSparql, zeroOrMore, zeroOrOne };
+}
+/**
+ * A SHACL property path.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type Path = PredicatePath | SequencePath | AlternativePath | InversePath | ZeroOrMorePath | OneOrMorePath | ZeroOrOnePath;
+/**
+ * A predicate path: a single IRI.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface PredicatePath {
+  readonly _tag: 'PredicatePath';
+  readonly predicate: NamedNode;
+}
+/**
+ * A sequence path: an RDF list of at least two paths.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface SequencePath {
+  readonly _tag: 'SequencePath';
+  readonly paths: ReadonlyArray<Path>;
+}
+/**
+ * An alternative path (`sh:alternativePath`).
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface AlternativePath {
+  readonly _tag: 'AlternativePath';
+  readonly paths: ReadonlyArray<Path>;
+}
+/**
+ * An inverse path (`sh:inversePath`).
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface InversePath {
+  readonly _tag: 'InversePath';
+  readonly path: Path;
+}
+/**
+ * A zero-or-more path (`sh:zeroOrMorePath`).
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface ZeroOrMorePath {
+  readonly _tag: 'ZeroOrMorePath';
+  readonly path: Path;
+}
+/**
+ * A one-or-more path (`sh:oneOrMorePath`).
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface OneOrMorePath {
+  readonly _tag: 'OneOrMorePath';
+  readonly path: Path;
+}
+/**
+ * A zero-or-one path (`sh:zeroOrOnePath`).
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface ZeroOrOnePath {
+  readonly _tag: 'ZeroOrOnePath';
+  readonly path: Path;
+}
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const predicate: (iri: NamedNode) => PredicatePath;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const sequence: (...paths: ReadonlyArray<Path>) => SequencePath;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const alternative: (...paths: ReadonlyArray<Path>) => AlternativePath;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const inverse: (path: Path) => InversePath;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const zeroOrMore: (path: Path) => ZeroOrMorePath;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const oneOrMore: (path: Path) => OneOrMorePath;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const zeroOrOne: (path: Path) => ZeroOrOnePath;
+/**
+ * Structural equality of paths.
+ *
+ * @since 0.1.0
+ * @category equivalence
+ */
+declare const equals: (a: Path, b: Path) => boolean;
+/**
+ * Renders a path in SPARQL property path syntax, e.g. `^<p>/<q>*`.
+ *
+ * @since 0.1.0
+ * @category formatting
+ */
+declare const toSparql: (self: Path) => string;
+/**
+ * The value nodes reachable from `focus` by following `path` in `data`
+ * (duplicates removed, in discovery order).
+ *
+ * @since 0.1.0
+ * @category evaluation
+ */
+declare const evaluate: (data: Dataset, focus: GroundTerm, path: Path) => ReadonlyArray<GroundTerm>;
+/**
+ * Why a path node could not be read.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+declare class PathSyntaxError {
+  readonly _tag = "PathSyntaxError";
+  readonly node: Term;
+  readonly message: string;
+  constructor(node: Term, message: string);
+}
+/**
+ * Reads the SHACL path rooted at `node` from a shapes graph, failing with a
+ * `PathSyntaxError` when the node is not a well-formed path.
+ *
+ * @since 0.1.0
+ * @category decoding
+ */
+declare const fromRdf: (graph: Dataset, node: Term) => Result.Result<Path, PathSyntaxError>;
+/**
+ * A path encoded as RDF: its root term and the quads describing it.
+ *
+ * @since 0.1.0
+ * @category encoding
+ */
+interface PathRdf {
+  readonly node: NamedNode | BlankNode;
+  readonly quads: ReadonlyArray<Quad>;
+}
+/**
+ * Encodes a path as RDF, returning the path's root term and the triples
+ * describing it (using fresh blank nodes for non-predicate paths).
+ *
+ * @since 0.1.0
+ * @category encoding
+ */
+declare const toRdf: (self: Path, graph?: Graph) => PathRdf;
+export { zeroOrOne as C, zeroOrMore as S, oneOrMore as _, PathRdf as a, toRdf as b, PredicatePath as c, ZeroOrOnePath as d, alternative as f, inverse as g, fromRdf as h, Path as i, SequencePath as l, evaluate as m, InversePath as n, PathSyntaxError as o, equals as p, OneOrMorePath as r, Path_d_exports as s, AlternativePath as t, ZeroOrMorePath as u, predicate as v, toSparql as x, sequence as y };
+//# sourceMappingURL=Path-DRB8e-Zn.d.mts.map

package/dist/Pdf-B9RZn--8.d.mts

@@ -0,0 +1,77 @@
+import { c as Setter, o as Metadata } from "./Metadata-nzS7QKRj.mjs";
+import * as Option from "effect/Option";
+declare namespace Pdf_d_exports {
+  export { keywords, pdfVersion, producer, setKeywords, setPdfVersion, setProducer, setTrapped, setUaPart, trapped, uaPart };
+}
+/**
+ * The application that wrote the PDF (`pdf:Producer`).
+ *
+ * @since 0.1.0
+ * @category getters
+ */
+declare const producer: (self: Metadata) => Option.Option<string>;
+/**
+ * Sets the application that wrote the PDF (`pdf:Producer`).
+ *
+ * @since 0.1.0
+ * @category setters
+ */
+declare const setProducer: Setter<string>;
+/**
+ * The keywords (`pdf:Keywords`), one text value.
+ *
+ * @since 0.1.0
+ * @category getters
+ */
+declare const keywords: (self: Metadata) => Option.Option<string>;
+/**
+ * Sets the keywords (`pdf:Keywords`), one text value.
+ *
+ * @since 0.1.0
+ * @category setters
+ */
+declare const setKeywords: Setter<string>;
+/**
+ * The PDF version, such as `"1.7"` (`pdf:PDFVersion`).
+ *
+ * @since 0.1.0
+ * @category getters
+ */
+declare const pdfVersion: (self: Metadata) => Option.Option<string>;
+/**
+ * Sets the PDF version, such as `"1.7"` (`pdf:PDFVersion`).
+ *
+ * @since 0.1.0
+ * @category setters
+ */
+declare const setPdfVersion: Setter<string>;
+/**
+ * Whether the document is trapped (`pdf:Trapped`): `"True"`, `"False"` or `"Unknown"`.
+ *
+ * @since 0.1.0
+ * @category getters
+ */
+declare const trapped: (self: Metadata) => Option.Option<string>;
+/**
+ * Sets whether the document is trapped (`pdf:Trapped`): `"True"`, `"False"` or `"Unknown"`.
+ *
+ * @since 0.1.0
+ * @category setters
+ */
+declare const setTrapped: Setter<string>;
+/**
+ * The PDF/UA part the document conforms to (`pdfuaid:part`), such as `1`.
+ *
+ * @since 0.1.0
+ * @category getters
+ */
+declare const uaPart: (self: Metadata) => Option.Option<number>;
+/**
+ * Sets the PDF/UA part the document conforms to (`pdfuaid:part`).
+ *
+ * @since 0.1.0
+ * @category setters
+ */
+declare const setUaPart: Setter<number>;
+export { setKeywords as a, setTrapped as c, uaPart as d, producer as i, setUaPart as l, keywords as n, setPdfVersion as o, pdfVersion as r, setProducer as s, Pdf_d_exports as t, trapped as u };
+//# sourceMappingURL=Pdf-B9RZn--8.d.mts.map

package/dist/Pdf-CKK6dkZn.mjs

@@ -0,0 +1,89 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { a as PDF, f as PDFUA_ID } from "./Namespaces-Bz85vpjW.mjs";
+import { f as setText, l as setInteger, p as text, r as integer } from "./accessors-CEjaojuQ.mjs";
+// src/xmp/Pdf.ts
+var Pdf_exports = /* @__PURE__ */ __exportAll({
+	keywords: () => keywords,
+	pdfVersion: () => pdfVersion,
+	producer: () => producer,
+	setKeywords: () => setKeywords,
+	setPdfVersion: () => setPdfVersion,
+	setProducer: () => setProducer,
+	setTrapped: () => setTrapped,
+	setUaPart: () => setUaPart,
+	trapped: () => trapped,
+	uaPart: () => uaPart
+});
+/**
+* The application that wrote the PDF (`pdf:Producer`).
+*
+* @since 0.1.0
+* @category getters
+*/
+const producer = text(`${PDF}Producer`);
+/**
+* Sets the application that wrote the PDF (`pdf:Producer`).
+*
+* @since 0.1.0
+* @category setters
+*/
+const setProducer = setText(`${PDF}Producer`);
+/**
+* The keywords (`pdf:Keywords`), one text value.
+*
+* @since 0.1.0
+* @category getters
+*/
+const keywords = text(`${PDF}Keywords`);
+/**
+* Sets the keywords (`pdf:Keywords`), one text value.
+*
+* @since 0.1.0
+* @category setters
+*/
+const setKeywords = setText(`${PDF}Keywords`);
+/**
+* The PDF version, such as `"1.7"` (`pdf:PDFVersion`).
+*
+* @since 0.1.0
+* @category getters
+*/
+const pdfVersion = text(`${PDF}PDFVersion`);
+/**
+* Sets the PDF version, such as `"1.7"` (`pdf:PDFVersion`).
+*
+* @since 0.1.0
+* @category setters
+*/
+const setPdfVersion = setText(`${PDF}PDFVersion`);
+/**
+* Whether the document is trapped (`pdf:Trapped`): `"True"`, `"False"` or `"Unknown"`.
+*
+* @since 0.1.0
+* @category getters
+*/
+const trapped = text(`${PDF}Trapped`);
+/**
+* Sets whether the document is trapped (`pdf:Trapped`): `"True"`, `"False"` or `"Unknown"`.
+*
+* @since 0.1.0
+* @category setters
+*/
+const setTrapped = setText(`${PDF}Trapped`);
+/**
+* The PDF/UA part the document conforms to (`pdfuaid:part`), such as `1`.
+*
+* @since 0.1.0
+* @category getters
+*/
+const uaPart = (self) => integer(`${PDFUA_ID}part`)(self);
+/**
+* Sets the PDF/UA part the document conforms to (`pdfuaid:part`).
+*
+* @since 0.1.0
+* @category setters
+*/
+const setUaPart = setInteger(`${PDFUA_ID}part`);
+export { setKeywords as a, setTrapped as c, uaPart as d, producer as i, setUaPart as l, keywords as n, setPdfVersion as o, pdfVersion as r, setProducer as s, Pdf_exports as t, trapped as u };
+
+//# sourceMappingURL=Pdf-CKK6dkZn.mjs.map