@thomasfosterau/effect-rdf 0.0.0 → 0.1.0

package/dist/Shapes-18GjfyBV.mjs

@@ -0,0 +1,597 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { B as isNamedNode, E as compare, K as isTriple, U as isResource, V as isObject, Y as literal, Z as namedNode, z as isLiteral } from "./Term-CFLG1qu4.mjs";
+import { A as objectsOf, C as list, E as match, L as subjectsOf } from "./Dataset-BlmlcI7J.mjs";
+import { t as Vocab_exports } from "./Vocab-DceKywpq.mjs";
+import { r as instancesOf } from "./Rdfs-CyY2wVHI.mjs";
+import { m as isIntegerDatatype, v as isWellFormed } from "./Xsd-Cdgx5zRB.mjs";
+import { r as sh, t as SH } from "./Vocabulary-CnQl-_Z4.mjs";
+import { o as fromRdf } from "./Path-B20Yp8KE.mjs";
+import * as Arr from "effect/Array";
+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 Schema from "effect/Schema";
+import * as Effect from "effect/Effect";
+import * as Match from "effect/Match";
+import * as Record from "effect/Record";
+import * as Result from "effect/Result";
+// src/shacl/internal/regex.ts
+/**
+* Translation of XPath/XML Schema regular expressions (as used by
+* `sh:pattern` and `sh:flags`) to JavaScript `RegExp`s.
+*
+* @internal
+*/
+/** A string as a JSON string literal, for messages. */
+const quote = Schema.encodeSync(Schema.fromJsonString(Schema.String));
+const escapeAll = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+/** Removes whitespace outside character classes (the XPath `x` flag). */
+const stripWhitespace = (s) => {
+	let inClass = false;
+	return s.replace(/\\[\s\S]?|[[\]]|[\t\n\r ]/g, (token) => {
+		if (token === "[") inClass = true;
+		else if (token === "]") inClass = false;
+		else if (WHITESPACE.test(token)) return inClass ? token : "";
+		return token;
+	});
+};
+const WHITESPACE = /^[\t\n\r ]$/;
+/**
+* Compiles an XPath regular expression with optional XPath flags
+* (`s`, `m`, `i`, `x`, `q`). Fails with an error message for invalid input.
+*
+* @internal
+*/
+const compile = (pattern, flags) => {
+	const chars = Arr.fromIterable(flags);
+	const unsupported = Arr.findFirst(chars, (f) => !"smixq".includes(f));
+	if (Option.isSome(unsupported)) return Result.fail(`unsupported regular expression flag '${unsupported.value}'`);
+	const jsFlags = Arr.join(Arr.dedupe(Arr.filter(chars, (f) => "smi".includes(f))), "");
+	const source = flags.includes("q") ? escapeAll(pattern) : flags.includes("x") ? stripWhitespace(pattern) : pattern;
+	return Result.mapError(Result.orElse(Result.try(() => new RegExp(source, `${jsFlags}u`)), () => Result.try(() => new RegExp(source, jsFlags))), (failure) => `invalid regular expression ${quote(pattern)}: ${String(failure)}`);
+};
+// src/shacl/Shapes.ts
+/**
+* Shapes graphs: parsing an RDF shapes graph into a typed, validated model of
+* node shapes and property shapes with their targets and constraints
+* (SHACL Core §2–§4, plus the SHACL-SPARQL constructs needed to delegate to a
+* `Sparql.SparqlConstraintEvaluator`).
+*
+* ```ts
+* import { Effect } from "effect"
+* import { Shapes } from "@thomasfosterau/effect-rdf/shacl"
+*
+* const program = Effect.gen(function* () {
+*   const shapes = yield* Shapes.parse(shapesDataset)
+*   for (const shape of shapes.shapes) console.log(shape._tag, shape.id.key)
+* })
+* ```
+*
+* @since 0.1.0
+*/
+var Shapes_exports = /* @__PURE__ */ __exportAll({
+	ShapesGraphError: () => ShapesGraphError,
+	componentOf: () => componentOf,
+	get: () => get,
+	isShapesGraph: () => isShapesGraph,
+	parse: () => parse,
+	parseResult: () => parseResult,
+	targetedShapes: () => targetedShapes,
+	usesSparql: () => usesSparql
+});
+const { rdfs, xsd } = Vocab_exports;
+/**
+* The shapes graph is ill-formed (§3.4.1 "ill-formed shapes graph"), so it
+* cannot be used for validation.
+*
+* @since 0.1.0
+* @category errors
+*/
+var ShapesGraphError = class extends Schema.TaggedError()("ShapesGraphError", {
+	message: Schema.String,
+	/** The N-Triples form of the offending node, when known. */
+	node: Schema.optional(Schema.String)
+}) {};
+/**
+* @since 0.1.0
+* @category guards
+*/
+const isShapesGraph = (u) => Predicate.isTagged(u, "ShapesGraph");
+/**
+* Looks up a shape by its identifier.
+*
+* @since 0.1.0
+* @category accessors
+*/
+const get = (self, id) => Option.fromNullishOr(self.index.get(id.key));
+/**
+* The shapes that declare at least one target and are not deactivated.
+*
+* @since 0.1.0
+* @category accessors
+*/
+const targetedShapes = (self) => self.shapes.filter((s) => !s.deactivated && Arr.isReadonlyArrayNonEmpty(s.targets));
+/**
+* Whether the shapes graph uses SHACL-SPARQL features (SPARQL constraints,
+* SPARQL-based constraint components or SPARQL-based targets).
+*
+* @since 0.1.0
+* @category accessors
+*/
+const usesSparql = (self) => self.shapes.some((s) => s.targets.some(Predicate.isTagged("SparqlTarget")) || s.constraints.some((c) => Predicate.isTagged(c, "Sparql") || Predicate.isTagged(c, "Component")));
+const componentNames = {
+	Class: "ClassConstraintComponent",
+	Datatype: "DatatypeConstraintComponent",
+	NodeKind: "NodeKindConstraintComponent",
+	MinCount: "MinCountConstraintComponent",
+	MaxCount: "MaxCountConstraintComponent",
+	MinExclusive: "MinExclusiveConstraintComponent",
+	MinInclusive: "MinInclusiveConstraintComponent",
+	MaxExclusive: "MaxExclusiveConstraintComponent",
+	MaxInclusive: "MaxInclusiveConstraintComponent",
+	MinLength: "MinLengthConstraintComponent",
+	MaxLength: "MaxLengthConstraintComponent",
+	Pattern: "PatternConstraintComponent",
+	LanguageIn: "LanguageInConstraintComponent",
+	UniqueLang: "UniqueLangConstraintComponent",
+	Equals: "EqualsConstraintComponent",
+	Disjoint: "DisjointConstraintComponent",
+	LessThan: "LessThanConstraintComponent",
+	LessThanOrEquals: "LessThanOrEqualsConstraintComponent",
+	Not: "NotConstraintComponent",
+	And: "AndConstraintComponent",
+	Or: "OrConstraintComponent",
+	Xone: "XoneConstraintComponent",
+	Node: "NodeConstraintComponent",
+	Property: "PropertyConstraintComponent",
+	QualifiedMinCount: "QualifiedMinCountConstraintComponent",
+	QualifiedMaxCount: "QualifiedMaxCountConstraintComponent",
+	Closed: "ClosedConstraintComponent",
+	HasValue: "HasValueConstraintComponent",
+	In: "InConstraintComponent"
+};
+/**
+* The constraint component IRI of a constraint (e.g.
+* `sh:MinCountConstraintComponent`).
+*
+* @since 0.1.0
+* @category accessors
+*/
+const componentOf = (constraint) => {
+	return Match.value(constraint).pipe(Match.tag("Sparql", () => sh.SPARQLConstraintComponent), Match.tag("Component", (custom) => custom.component), Match.orElse((core) => namedNode(SH + componentNames[core._tag])));
+};
+var ParseFailure = class {
+	message;
+	node;
+	constructor(message, node) {
+		this.message = message;
+		this.node = node;
+	}
+};
+const TRUE = literal("true", xsd.boolean).key;
+const nodeKinds = Record.fromEntries(Arr.map([
+	"BlankNode",
+	"IRI",
+	"Literal",
+	"BlankNodeOrIRI",
+	"BlankNodeOrLiteral",
+	"IRIOrLiteral"
+], (k) => [SH + k, k]));
+/** Parameters of the core constraint components (§4). */
+const coreParameters = [
+	sh.class,
+	sh.datatype,
+	sh.nodeKind,
+	sh.minCount,
+	sh.maxCount,
+	sh.minExclusive,
+	sh.minInclusive,
+	sh.maxExclusive,
+	sh.maxInclusive,
+	sh.minLength,
+	sh.maxLength,
+	sh.pattern,
+	sh.flags,
+	sh.languageIn,
+	sh.uniqueLang,
+	sh.equals,
+	sh.disjoint,
+	sh.lessThan,
+	sh.lessThanOrEquals,
+	sh.not,
+	sh.and,
+	sh.or,
+	sh.xone,
+	sh.node,
+	sh.property,
+	sh.qualifiedValueShape,
+	sh.qualifiedValueShapesDisjoint,
+	sh.qualifiedMinCount,
+	sh.qualifiedMaxCount,
+	sh.closed,
+	sh.ignoredProperties,
+	sh.hasValue,
+	sh.in,
+	sh.sparql
+];
+const targetPredicates = [
+	sh.targetNode,
+	sh.targetClass,
+	sh.targetSubjectsOf,
+	sh.targetObjectsOf,
+	sh.target
+];
+const rangeParameters = [
+	[sh.minExclusive, "MinExclusive"],
+	[sh.minInclusive, "MinInclusive"],
+	[sh.maxExclusive, "MaxExclusive"],
+	[sh.maxInclusive, "MaxInclusive"]
+];
+const pairParameters = [
+	[sh.equals, "Equals"],
+	[sh.disjoint, "Disjoint"],
+	[sh.lessThan, "LessThan"],
+	[sh.lessThanOrEquals, "LessThanOrEquals"]
+];
+const logicalParameters = [
+	[sh.and, "And"],
+	[sh.or, "Or"],
+	[sh.xone, "Xone"]
+];
+const isShapeId = isResource;
+/**
+* Parses a shapes graph synchronously, returning a `Result`.
+*
+* @since 0.1.0
+* @category parsing
+*/
+const parseResult = (dataset) => Result.try({
+	try: () => parseUnsafe(dataset),
+	catch: (e) => {
+		if (e instanceof ParseFailure) return new ShapesGraphError(Option.match(e.node, {
+			onNone: () => ({ message: e.message }),
+			onSome: (node) => ({
+				message: e.message,
+				node: node.key
+			})
+		}));
+		throw e;
+	}
+});
+/**
+* Parses a shapes graph into a typed model. Fails with a `ShapesGraphError`
+* when the shapes graph is ill-formed (e.g. malformed paths or lists,
+* parameters with values of the wrong kind, or invalid regular expressions).
+*
+* @since 0.1.0
+* @category parsing
+*/
+const parse = (dataset) => Effect.suspend(() => {
+	const result = parseResult(dataset);
+	return Result.isSuccess(result) ? Effect.succeed(result.success) : Effect.fail(result.failure);
+});
+const failShapes = (message, node) => {
+	throw new ParseFailure(message, Option.fromUndefinedOr(node));
+};
+const isTrue = (t) => t.key === TRUE;
+const isTrueOption = (t) => Option.exists(t, isTrue);
+const shapeRef = (owner, p, t) => isShapeId(t) ? t : failShapes(`the value of ${p.key} on ${owner.key} must be an IRI or blank node`, owner);
+const resourceOf = (owner, t, message) => isResource(t) ? t : failShapes(message, owner);
+const iriOf = (owner, p, t) => isNamedNode(t) ? t : failShapes(`the value of ${p.key} on ${owner.key} must be an IRI`, owner);
+const nonNegativeInteger = (owner, p, t) => {
+	if (isLiteral(t) && isIntegerDatatype(t.datatype.value) && isWellFormed(t)) {
+		const n = Number(t.value);
+		if (n >= 0) return n;
+	}
+	return failShapes(`the value of ${p.key} on ${owner.key} must be a non-negative xsd:integer`, owner);
+};
+const makeReader = (g) => {
+	const objects = (s, p) => isShapeId(s) ? objectsOf(g, s, p) : [];
+	const list$1 = (owner, head, p) => {
+		const items = isObject(head) ? list(g, head) : Option.none();
+		if (Option.isNone(items)) return failShapes(`the value of ${p.key} on ${owner.key} must be a well-formed RDF list`, owner);
+		return items.value;
+	};
+	const single = (s, p) => {
+		const vs = objects(s, p);
+		if (vs.length > 1) failShapes(`${s.key} has more than one value for ${p.key}`, s);
+		return Arr.head(vs);
+	};
+	return {
+		g,
+		objects,
+		list: list$1,
+		single
+	};
+};
+const parameterPath = (r, c, param) => Option.getOrElse(Option.filter(r.single(param, sh.path), isNamedNode), () => failShapes(`parameter ${param.key} of ${c.key} must have an IRI sh:path`, param));
+const componentDeclarations = (r) => Arr.flatMap(instancesOf(r.g, sh.ConstraintComponent), (c) => {
+	if (!isShapeId(c) || isNamedNode(c) && c.value.startsWith("http://www.w3.org/ns/shacl#")) return [];
+	const parameters = Arr.map(r.objects(c, sh.parameter), (param) => {
+		return {
+			path: parameterPath(r, c, param),
+			optional: isTrueOption(r.single(param, sh.optional))
+		};
+	});
+	const mandatory = Arr.map(Arr.filter(parameters, (p) => !p.optional), (p) => p.path);
+	const optional = Arr.map(Arr.filter(parameters, (p) => p.optional), (p) => p.path);
+	return Arr.isReadonlyArrayNonEmpty(mandatory) ? [{
+		component: c,
+		mandatory,
+		optional
+	}] : [];
+});
+const collectCandidates = (r, components) => {
+	const candidates = MutableHashMap.empty();
+	const addCandidate = (t, reason) => {
+		if (!isShapeId(t)) failShapes(`${t.key} cannot be a shape (${reason})`, t);
+		else if (!MutableHashMap.has(candidates, t.key)) MutableHashMap.set(candidates, t.key, t);
+	};
+	Arr.forEach([sh.NodeShape, sh.PropertyShape], (cls) => Arr.forEach(instancesOf(r.g, cls), (s) => addCandidate(s, `instance of ${cls.key}`)));
+	const subjectTriggers = [
+		...targetPredicates,
+		...coreParameters,
+		...components.flatMap((c) => c.mandatory)
+	];
+	Arr.forEach(subjectTriggers, (p) => Arr.forEach(match(r.g, { predicate: p }), (q) => {
+		if (!isTriple(q.subject)) addCandidate(q.subject, `subject of ${p.key}`);
+	}));
+	Arr.forEach([
+		sh.node,
+		sh.property,
+		sh.qualifiedValueShape,
+		sh.not
+	], (p) => Arr.forEach(match(r.g, { predicate: p }), (q) => addCandidate(q.object, `value of ${p.key}`)));
+	Arr.forEach([
+		sh.and,
+		sh.or,
+		sh.xone
+	], (p) => Arr.forEach(match(r.g, { predicate: p }), (q) => Arr.forEach(r.list(q.subject, q.object, p), (member) => addCandidate(member, `member of ${p.key}`))));
+	return Arr.sort(MutableHashMap.values(candidates), compare);
+};
+const parseTargets = (r, id, classInstances) => [
+	...Arr.map(objects(r, id, sh.targetNode), (node) => ({
+		_tag: "TargetNode",
+		node
+	})),
+	...Arr.map(objects(r, id, sh.targetClass), (c) => ({
+		_tag: "TargetClass",
+		class: resourceOf(id, c, `the value of sh:targetClass on ${id.key} must be an IRI`),
+		implicit: false
+	})),
+	...isNamedNode(id) && MutableHashSet.has(classInstances, id.key) ? [{
+		_tag: "TargetClass",
+		class: id,
+		implicit: true
+	}] : [],
+	...Arr.map(objects(r, id, sh.targetSubjectsOf), (p) => ({
+		_tag: "TargetSubjectsOf",
+		predicate: iriOf(id, sh.targetSubjectsOf, p)
+	})),
+	...Arr.map(objects(r, id, sh.targetObjectsOf), (p) => ({
+		_tag: "TargetObjectsOf",
+		predicate: iriOf(id, sh.targetObjectsOf, p)
+	})),
+	...Arr.map(objects(r, id, sh.target), (node) => ({
+		_tag: "SparqlTarget",
+		node
+	}))
+];
+const objects = (r, s, p) => r.objects(s, p);
+const valueConstraints = (r, id) => [
+	...Arr.map(objects(r, id, sh.class), (c) => ({
+		_tag: "Class",
+		class: resourceOf(id, c, `the value of sh:class on ${id.key} must be an IRI`)
+	})),
+	...Arr.map(objects(r, id, sh.datatype), (d) => ({
+		_tag: "Datatype",
+		datatype: iriOf(id, sh.datatype, d)
+	})),
+	...Arr.map(objects(r, id, sh.nodeKind), (k) => ({
+		_tag: "NodeKind",
+		nodeKind: Option.getOrElse(Record.get(nodeKinds, isNamedNode(k) ? k.value : ""), () => failShapes(`${k.key} is not a valid sh:nodeKind`, id))
+	})),
+	...Arr.map(objects(r, id, sh.minCount), (n) => ({
+		_tag: "MinCount",
+		minCount: nonNegativeInteger(id, sh.minCount, n)
+	})),
+	...Arr.map(objects(r, id, sh.maxCount), (n) => ({
+		_tag: "MaxCount",
+		maxCount: nonNegativeInteger(id, sh.maxCount, n)
+	})),
+	...Arr.flatMap(rangeParameters, ([p, tag]) => Arr.map(objects(r, id, p), (v) => isLiteral(v) ? {
+		_tag: tag,
+		value: v
+	} : failShapes(`the value of ${p.key} on ${id.key} must be a literal`, id))),
+	...Arr.map(objects(r, id, sh.minLength), (n) => ({
+		_tag: "MinLength",
+		minLength: nonNegativeInteger(id, sh.minLength, n)
+	})),
+	...Arr.map(objects(r, id, sh.maxLength), (n) => ({
+		_tag: "MaxLength",
+		maxLength: nonNegativeInteger(id, sh.maxLength, n)
+	})),
+	...patternConstraints(r, id),
+	...Arr.map(objects(r, id, sh.languageIn), (l) => ({
+		_tag: "LanguageIn",
+		languages: Arr.map(r.list(id, l, sh.languageIn), (t) => isLiteral(t) ? t.value : failShapes(`sh:languageIn members of ${id.key} must be literals`, id))
+	})),
+	...Arr.flatMap(objects(r, id, sh.uniqueLang), (u) => isTrue(u) ? [{ _tag: "UniqueLang" }] : []),
+	...Arr.flatMap(pairParameters, ([p, tag]) => Arr.map(objects(r, id, p), (v) => ({
+		_tag: tag,
+		predicate: iriOf(id, p, v)
+	})))
+];
+const patternConstraints = (r, id) => {
+	const patterns = objects(r, id, sh.pattern);
+	if (Arr.isReadonlyArrayEmpty(patterns)) return [];
+	const flags = Option.match(r.single(id, sh.flags), {
+		onNone: () => "",
+		onSome: (f) => isLiteral(f) ? f.value : failShapes(`the value of sh:flags on ${id.key} must be a literal`, id)
+	});
+	return Arr.map(patterns, (p) => {
+		if (!isLiteral(p)) return failShapes(`the value of sh:pattern on ${id.key} must be a literal`, id);
+		return Result.match(compile(p.value, flags), {
+			onFailure: (error) => failShapes(`${error} (sh:pattern on ${id.key})`, id),
+			onSuccess: (regex) => ({
+				_tag: "Pattern",
+				pattern: p.value,
+				flags,
+				regex
+			})
+		});
+	});
+};
+const shapeConstraints = (r, id) => [
+	...Arr.map(objects(r, id, sh.not), (s) => ({
+		_tag: "Not",
+		shape: shapeRef(id, sh.not, s)
+	})),
+	...Arr.flatMap(logicalParameters, ([p, tag]) => Arr.map(objects(r, id, p), (l) => ({
+		_tag: tag,
+		shapes: r.list(id, l, p).map((m) => shapeRef(id, p, m))
+	}))),
+	...Arr.map(objects(r, id, sh.node), (s) => ({
+		_tag: "Node",
+		shape: shapeRef(id, sh.node, s)
+	})),
+	...Arr.map(objects(r, id, sh.property), (s) => ({
+		_tag: "Property",
+		shape: shapeRef(id, sh.property, s)
+	}))
+];
+/** The other qualified value shapes of the property shapes beside `id`. */
+const siblingShapes = (r, id, q) => {
+	const siblings = MutableHashMap.empty();
+	Arr.forEach(subjectsOf(r.g, sh.property, id), (parent) => Arr.forEach(objects(r, parent, sh.property), (sibling) => Arr.forEach(objects(r, sibling, sh.qualifiedValueShape), (sq) => {
+		if (sq.key !== q.key && isShapeId(sq)) MutableHashMap.set(siblings, sq.key, sq);
+	})));
+	return Arr.fromIterable(MutableHashMap.values(siblings));
+};
+const qualifiedConstraints = (r, id) => {
+	const qualifiedShapes = objects(r, id, sh.qualifiedValueShape);
+	if (Arr.isReadonlyArrayEmpty(qualifiedShapes)) return [];
+	const minNode = r.single(id, sh.qualifiedMinCount);
+	const maxNode = r.single(id, sh.qualifiedMaxCount);
+	const disjoint = isTrueOption(r.single(id, sh.qualifiedValueShapesDisjoint));
+	return Arr.flatMap(qualifiedShapes, (qNode) => {
+		const q = shapeRef(id, sh.qualifiedValueShape, qNode);
+		const common = {
+			shape: q,
+			disjoint,
+			siblings: disjoint ? siblingShapes(r, id, q) : []
+		};
+		return [...Option.toArray(Option.map(minNode, (n) => ({
+			_tag: "QualifiedMinCount",
+			count: nonNegativeInteger(id, sh.qualifiedMinCount, n),
+			...common
+		}))), ...Option.toArray(Option.map(maxNode, (n) => ({
+			_tag: "QualifiedMaxCount",
+			count: nonNegativeInteger(id, sh.qualifiedMaxCount, n),
+			...common
+		})))];
+	});
+};
+const closedConstraints = (r, id) => {
+	if (!isTrueOption(r.single(id, sh.closed))) return [];
+	const ignoredProperties = Option.match(r.single(id, sh.ignoredProperties), {
+		onNone: () => [],
+		onSome: (node) => Arr.map(r.list(id, node, sh.ignoredProperties), (t) => iriOf(id, sh.ignoredProperties, t))
+	});
+	const allowed = MutableHashMap.empty();
+	Arr.forEach(objects(r, id, sh.property), (p) => Arr.forEach(objects(r, p, sh.path), (path) => {
+		if (isNamedNode(path)) MutableHashMap.set(allowed, path.key, path);
+	}));
+	Arr.forEach(ignoredProperties, (p) => {
+		MutableHashMap.set(allowed, p.key, p);
+	});
+	return [{
+		_tag: "Closed",
+		ignoredProperties,
+		allowedProperties: Arr.fromIterable(MutableHashMap.values(allowed))
+	}];
+};
+const sparqlConstraints = (r, id) => Arr.flatMap(objects(r, id, sh.sparql), (s) => {
+	if (!isShapeId(s)) return failShapes(`the value of sh:sparql on ${id.key} must be an IRI or blank node`, id);
+	return isTrueOption(r.single(s, sh.deactivated)) ? [] : [{
+		_tag: "Sparql",
+		node: s
+	}];
+});
+const noParameters = [[]];
+const componentConstraints = (r, id, components) => Arr.flatMap(components, (decl) => {
+	const bindings = Arr.map([...decl.mandatory, ...decl.optional], (p) => [p, objects(r, id, p)]);
+	if (decl.mandatory.some((p) => Arr.isReadonlyArrayEmpty(objects(r, id, p)))) return [];
+	const combos = Arr.reduce(bindings, noParameters, (acc, [path, values]) => Arr.isReadonlyArrayEmpty(values) ? acc : Arr.flatMap(acc, (combo) => values.map((value) => Arr.append(combo, {
+		path,
+		value
+	}))));
+	return Arr.map(combos, (parameters) => ({
+		_tag: "Component",
+		component: decl.component,
+		parameters
+	}));
+});
+const parseShape = (r, components, classInstances, id) => {
+	const targets = parseTargets(r, id, classInstances);
+	const severity = Option.match(r.single(id, sh.severity), {
+		onNone: () => sh.Violation,
+		onSome: (node) => iriOf(id, sh.severity, node)
+	});
+	const messages = objects(r, id, sh.message).filter(isLiteral);
+	const deactivated = isTrueOption(r.single(id, sh.deactivated));
+	const constraints = [
+		...valueConstraints(r, id),
+		...shapeConstraints(r, id),
+		...qualifiedConstraints(r, id),
+		...closedConstraints(r, id),
+		...Arr.map(objects(r, id, sh.hasValue), (v) => ({
+			_tag: "HasValue",
+			value: v
+		})),
+		...Arr.map(objects(r, id, sh.in), (l) => ({
+			_tag: "In",
+			values: r.list(id, l, sh.in)
+		})),
+		...sparqlConstraints(r, id),
+		...componentConstraints(r, id, components)
+	];
+	return Option.match(r.single(id, sh.path), {
+		onNone: () => ({
+			_tag: "NodeShape",
+			id,
+			targets,
+			constraints,
+			severity,
+			messages,
+			deactivated
+		}),
+		onSome: (pathNode) => ({
+			_tag: "PropertyShape",
+			id,
+			path: Result.getOrElse(fromRdf(r.g, pathNode), (failure) => failShapes(`ill-formed sh:path of ${id.key}: ${failure.message}`, id)),
+			targets,
+			constraints,
+			severity,
+			messages,
+			deactivated
+		})
+	});
+};
+const parseUnsafe = (g) => {
+	const r = makeReader(g);
+	const components = componentDeclarations(r);
+	const candidates = collectCandidates(r, components);
+	const classInstances = MutableHashSet.fromIterable(Arr.map(instancesOf(g, rdfs.Class), (c) => c.key));
+	const shapes = Arr.map(candidates, (id) => parseShape(r, components, classInstances, id));
+	return {
+		_tag: "ShapesGraph",
+		dataset: g,
+		shapes,
+		index: new Map(shapes.map((s) => [s.id.key, s]))
+	};
+};
+export { isShapesGraph as a, targetedShapes as c, get as i, usesSparql as l, Shapes_exports as n, parse as o, componentOf as r, parseResult as s, ShapesGraphError as t };
+
+//# sourceMappingURL=Shapes-18GjfyBV.mjs.map