@thomasfosterau/effect-rdf 0.0.0 → 0.1.0

package/dist/Structure-BjMo4Bkc.mjs

@@ -0,0 +1,334 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { a as ShExStructureError } from "./ShExError-CVtq2NnM.mjs";
+import * as Arr from "effect/Array";
+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 Effect from "effect/Effect";
+import * as Match from "effect/Match";
+// src/shex/internal/iterate.ts
+/**
+* A loop as a function: the cursor-driven scans of the engine, the
+* structural checks and the regular expression translator step a state
+* until it is done.
+*
+* @internal
+*/
+/** Steps `f` from `initial` until it returns none. */
+const iterate = (initial, f) => {
+	Arr.unfold(initial, (s) => Option.map(f(s), (next) => [void 0, next]));
+};
+// src/shex/Structure.ts
+/**
+* Schema indexing and the ShEx structural requirements: every reference
+* resolves, inclusions name triple expressions, shape expressions do not
+* refer to themselves except through triple constraints, there is no
+* reference cycle through negation (`NOT` or `EXTRA`), and the extension
+* hierarchy is acyclic.
+*
+* @since 0.1.0
+*/
+var Structure_exports = /* @__PURE__ */ __exportAll({
+	check: () => check,
+	makeIndex: () => makeIndex,
+	nestedShapes: () => nestedShapes,
+	problems: () => problems
+});
+const forEachShapeExprChild = Match.fn((e, _f) => e).pipe(Match.when({ type: Match.is("ShapeAnd", "ShapeOr") }, (e, _e, f) => e.shapeExprs.forEach(f)), Match.when({ type: "ShapeNot" }, (e, _e, f) => f(e.shapeExpr)), Match.orElse(() => void 0));
+/** Collects the labelled triple expressions of a shape expression tree. */
+const collectTripleExprs = (root, out, duplicates) => {
+	const visitShape = (e) => {
+		if (Predicate.isString(e)) return;
+		if (e.type === "Shape") {
+			e.extends?.forEach(visitShape);
+			if (e.expression !== void 0) visitTriple(e.expression);
+			return;
+		}
+		forEachShapeExprChild(e, visitShape);
+	};
+	const visitTriple = (t) => {
+		if (Predicate.isString(t)) return;
+		if (t.id !== void 0) {
+			const id = t.id;
+			if (Option.exists(MutableHashMap.get(out, id), (existing) => existing !== t)) duplicates.push(id);
+			MutableHashMap.set(out, id, t);
+		}
+		if (t.type === "TripleConstraint") {
+			if (t.valueExpr !== void 0) visitShape(t.valueExpr);
+		} else t.expressions.forEach(visitTriple);
+	};
+	visitShape(root);
+};
+const tripleExprsOf = (schema) => {
+	const tripleExprs = MutableHashMap.empty();
+	const duplicates = [];
+	schema.shapes?.forEach((d) => {
+		collectTripleExprs(d.shapeExpr, tripleExprs, duplicates);
+		d.restricts?.forEach((r) => collectTripleExprs(r, tripleExprs, duplicates));
+	});
+	if (schema.start !== void 0) collectTripleExprs(schema.start, tripleExprs, duplicates);
+	return {
+		tripleExprs,
+		duplicates
+	};
+};
+/** `nestedShapes`, with the declarations looked up by `declOf`. */
+const nestedShapesBy = (declOf, e) => {
+	const out = [];
+	const seen = MutableHashSet.empty();
+	const go = (x) => {
+		if (Predicate.isString(x)) {
+			if (MutableHashSet.has(seen, x)) return;
+			MutableHashSet.add(seen, x);
+			Option.map(declOf(x), (decl) => go(decl.shapeExpr));
+			return;
+		}
+		if (x.type === "Shape") out.push(x);
+		else forEachShapeExprChild(x, go);
+	};
+	go(e);
+	return out;
+};
+/**
+* The shapes nested in a shape expression (following references but not
+* triple constraints), per the ShEx 2.2 `nestedShapes` definition.
+*
+* @since 0.1.0
+* @category utils
+*/
+const nestedShapes = (shapes, e) => nestedShapesBy((label) => Option.fromUndefinedOr(shapes.get(label)), e);
+/** All shape labels referenced inside a shape expression (anywhere). */
+const refsOf = (e, out) => {
+	if (Predicate.isString(e)) {
+		out.push(e);
+		return;
+	}
+	if (e.type === "Shape") {
+		e.extends?.forEach((x) => refsOf(x, out));
+		return;
+	}
+	forEachShapeExprChild(e, (c) => refsOf(c, out));
+};
+/** The labels a declaration extends: the references in the `EXTENDS` of its nested shapes. */
+const parentsOf = (declOf, d) => {
+	const parents = [];
+	nestedShapesBy(declOf, d.shapeExpr).forEach((s) => s.extends?.forEach((ext) => refsOf(ext, parents)));
+	return parents;
+};
+/** Appends `value` to the list of `key`, starting the list if there is none. */
+const append = (map, key, value) => Option.match(MutableHashMap.get(map, key), {
+	onNone: () => {
+		MutableHashMap.set(map, key, [value]);
+	},
+	onSome: (list) => {
+		list.push(value);
+	}
+});
+/** The labels reachable from `label` in `children` (depth first, each once). */
+const descendantsOf = (children, label) => {
+	const out = [];
+	const seen = MutableHashSet.make(label);
+	iterate([label], (pending) => {
+		const l = pending.pop();
+		if (l === void 0) return Option.none();
+		Option.getOrElse(MutableHashMap.get(children, l), () => []).forEach((c) => {
+			if (MutableHashSet.has(seen, c)) return;
+			MutableHashSet.add(seen, c);
+			out.push(c);
+			pending.push(c);
+		});
+		return Option.some(pending);
+	});
+	return out;
+};
+/**
+* Builds the index of a schema (which should already include the
+* declarations of its imports).
+*
+* @since 0.1.0
+* @category constructors
+*/
+const makeIndex = (schema) => {
+	const decls = MutableHashMap.fromIterable(Arr.map(schema.shapes ?? [], (d) => [d.id, d]));
+	const declOf = (label) => MutableHashMap.get(decls, label);
+	const { tripleExprs } = tripleExprsOf(schema);
+	const children = MutableHashMap.empty();
+	schema.shapes?.forEach((d) => parentsOf(declOf, d).forEach((p) => {
+		if (!Option.exists(MutableHashMap.get(children, p), (l) => l.includes(d.id))) append(children, p, d.id);
+	}));
+	return {
+		schema,
+		shapes: new Map(decls),
+		tripleExprs: new Map(tripleExprs),
+		descendants: new Map(Arr.map(Arr.fromIterable(MutableHashMap.keys(children)), (label) => [label, descendantsOf(children, label)]))
+	};
+};
+/** The cycles of a dependency graph, each rendered as `a -> b -> a`. */
+const cyclesOf = (graph) => {
+	const state = MutableHashMap.empty();
+	const found = [];
+	const visit = (n, path) => {
+		const s = MutableHashMap.get(state, n);
+		if (Option.contains(s, 2)) return;
+		if (Option.contains(s, 1)) {
+			found.push([...path.slice(path.indexOf(n)), n].join(" -> "));
+			return;
+		}
+		MutableHashMap.set(state, n, 1);
+		path.push(n);
+		Option.getOrElse(MutableHashMap.get(graph, n), () => []).forEach((m) => visit(m, path));
+		path.pop();
+		MutableHashMap.set(state, n, 2);
+	};
+	Iterable.forEach(MutableHashMap.keys(graph), (n) => visit(n, []));
+	return found;
+};
+/**
+* Returns the structural problems of a schema (empty when it is
+* well-formed). When `allowUnresolved` is set, references to undeclared
+* labels are tolerated (e.g. before imports have been loaded).
+*
+* @since 0.1.0
+* @category checks
+*/
+const problems = (schema, options = {}) => {
+	const errors = [];
+	const shapes = MutableHashMap.empty();
+	schema.shapes?.forEach((d) => {
+		if (MutableHashMap.has(shapes, d.id)) errors.push(`shape ${d.id} is declared more than once`);
+		MutableHashMap.set(shapes, d.id, d);
+	});
+	const isShape = (label) => MutableHashMap.has(shapes, label);
+	const { tripleExprs, duplicates } = tripleExprsOf(schema);
+	duplicates.forEach((d) => errors.push(`triple expression ${d} is declared more than once`));
+	Iterable.forEach(MutableHashMap.keys(tripleExprs), (l) => {
+		if (isShape(l)) errors.push(`${l} labels both a shape and a triple expression`);
+	});
+	const checkRef = (label) => {
+		if (!isShape(label) && options.allowUnresolved !== true) errors.push(`reference to undeclared shape ${label}`);
+	};
+	const checkInclude = (label) => {
+		if (MutableHashMap.has(tripleExprs, label)) return;
+		if (isShape(label)) errors.push(`inclusion &${label} names a shape, not a triple expression`);
+		else if (options.allowUnresolved !== true) errors.push(`inclusion of undeclared triple expression ${label}`);
+	};
+	const deps = MutableHashMap.empty();
+	const direct = MutableHashMap.empty();
+	const walkShape = (from, e, negative, isDirect, visitingIncludes) => {
+		if (Predicate.isString(e)) {
+			checkRef(e);
+			append(deps, from, {
+				to: e,
+				negative
+			});
+			if (isDirect) append(direct, from, e);
+			return;
+		}
+		Match.value(e).pipe(Match.discriminator("type")("ShapeAnd", "ShapeOr", (expr) => expr.shapeExprs.forEach((c) => walkShape(from, c, negative, isDirect, visitingIncludes))), Match.discriminator("type")("ShapeNot", (expr) => walkShape(from, expr.shapeExpr, true, isDirect, visitingIncludes)), Match.discriminator("type")("Shape", (expr) => {
+			expr.extends?.forEach((x) => walkShape(from, x, negative, false, visitingIncludes));
+			const extra = MutableHashSet.fromIterable(expr.extra ?? []);
+			if (expr.expression !== void 0) walkTriple(from, expr.expression, negative, extra, visitingIncludes);
+		}), Match.orElse(() => void 0));
+	};
+	const walkTriple = (from, t, negative, extra, visitingIncludes) => {
+		if (Predicate.isString(t)) {
+			checkInclude(t);
+			if (MutableHashSet.has(visitingIncludes, t)) return;
+			Option.map(MutableHashMap.get(tripleExprs, t), (target) => {
+				MutableHashSet.add(visitingIncludes, t);
+				walkTriple(from, target, negative, extra, visitingIncludes);
+				MutableHashSet.remove(visitingIncludes, t);
+			});
+			return;
+		}
+		if (t.type === "TripleConstraint") {
+			if (t.valueExpr !== void 0) {
+				const neg = negative || MutableHashSet.has(extra, t.predicate) && t.inverse !== true;
+				walkShape(from, t.valueExpr, neg, false, visitingIncludes);
+			}
+			return;
+		}
+		t.expressions.forEach((c) => walkTriple(from, c, negative, extra, visitingIncludes));
+	};
+	const roots = Arr.flatMap(schema.shapes ?? [], (d) => [[d.id, d.shapeExpr], ...Arr.map(d.restricts ?? [], (r) => [d.id, r])]);
+	roots.forEach(([label]) => {
+		MutableHashMap.set(deps, label, []);
+		MutableHashMap.set(direct, label, []);
+	});
+	roots.forEach(([label, expr]) => walkShape(label, expr, false, true, MutableHashSet.empty()));
+	if (schema.start !== void 0) {
+		MutableHashMap.set(deps, "\0start", []);
+		MutableHashMap.set(direct, "\0start", []);
+		walkShape("\0start", schema.start, false, true, MutableHashSet.empty());
+	}
+	cyclesOf(direct).forEach((c) => errors.push(`shape expression refers to itself: ${c}`));
+	const sccOf = tarjan(Arr.fromIterable(MutableHashMap.keys(deps)), (n) => Arr.map(Option.getOrElse(MutableHashMap.get(deps, n), () => []), (e) => e.to));
+	Iterable.forEach(deps, ([from, edges]) => edges.forEach((e) => {
+		const component = MutableHashMap.get(sccOf, from);
+		if (e.negative && Option.exists(component, (c) => Option.contains(MutableHashMap.get(sccOf, e.to), c))) errors.push(`reference cycle through negation between ${from} and ${e.to}`);
+	}));
+	const declOf = (label) => MutableHashMap.get(shapes, label);
+	const extendsGraph = MutableHashMap.empty();
+	schema.shapes?.forEach((d) => MutableHashMap.set(extendsGraph, d.id, parentsOf(declOf, d)));
+	cyclesOf(extendsGraph).forEach((c) => errors.push(`cyclic extension hierarchy: ${c}`));
+	return Arr.dedupe(errors);
+};
+/** The strongly connected component of every node, by Tarjan's algorithm. */
+const tarjan = (nodes, succ) => {
+	let index = 0;
+	let component = 0;
+	const visited = MutableHashMap.empty();
+	const stack = [];
+	const result = MutableHashMap.empty();
+	const strong = (v) => {
+		const nv = {
+			index,
+			low: index,
+			onStack: true
+		};
+		MutableHashMap.set(visited, v, nv);
+		index++;
+		stack.push(v);
+		succ(v).forEach((w) => Option.match(MutableHashMap.get(visited, w), {
+			onNone: () => {
+				nv.low = Math.min(nv.low, strong(w).low);
+			},
+			onSome: (nw) => {
+				if (nw.onStack) nv.low = Math.min(nv.low, nw.index);
+			}
+		}));
+		if (nv.low === nv.index) {
+			iterate(stack, (pending) => {
+				const w = pending.pop();
+				if (w === void 0) return Option.none();
+				Option.map(MutableHashMap.get(visited, w), (nw) => {
+					nw.onStack = false;
+				});
+				MutableHashMap.set(result, w, component);
+				return w === v ? Option.none() : Option.some(pending);
+			});
+			component++;
+		}
+		return nv;
+	};
+	nodes.forEach((n) => {
+		if (!MutableHashMap.has(visited, n)) strong(n);
+	});
+	return result;
+};
+/**
+* Checks the structural requirements of a schema, failing with a
+* `ShExStructureError` listing the problems.
+*
+* @since 0.1.0
+* @category checks
+*/
+const check = (schema, options = {}) => Effect.suspend(() => {
+	const errs = problems(schema, options);
+	return Arr.isReadonlyArrayEmpty(errs) ? Effect.succeed(schema) : Effect.fail(new ShExStructureError({ message: errs.join("; ") }));
+});
+export { problems as a, nestedShapes as i, check as n, iterate as o, makeIndex as r, Structure_exports as t };
+
+//# sourceMappingURL=Structure-BjMo4Bkc.mjs.map

package/dist/Structure-BjMo4Bkc.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Structure-BjMo4Bkc.mjs","names":[],"sources":["../src/shex/internal/iterate.ts","../src/shex/Structure.ts"],"sourcesContent":["/**\n * A loop as a function: the cursor-driven scans of the engine, the\n * structural checks and the regular expression translator step a state\n * until it is done.\n *\n * @internal\n */\nimport * as Arr from 'effect/Array';\nimport * as Option from 'effect/Option';\n\n/** Steps `f` from `initial` until it returns none. */\nexport const iterate = <S>(initial: S, f: (s: S) => Option.Option<S>): void => {\n  Arr.unfold(initial, (s) => Option.map(f(s), (next) => [undefined, next] as const));\n};\n","/**\n * Schema indexing and the ShEx structural requirements: every reference\n * resolves, inclusions name triple expressions, shape expressions do not\n * refer to themselves except through triple constraints, there is no\n * reference cycle through negation (`NOT` or `EXTRA`), and the extension\n * hierarchy is acyclic.\n *\n * @since 0.1.0\n */\nimport * as Arr from 'effect/Array';\nimport * as Effect from 'effect/Effect';\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 { iterate } from './internal/iterate.ts';\nimport { ShExStructureError } from './ShExError.ts';\nimport type * as ShExJ from './ShExJ.ts';\nimport * as Predicate from 'effect/Predicate';\n\n/**\n * An index of the declarations of a schema.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface SchemaIndex {\n  readonly schema: ShExJ.Schema;\n  /** Shape declarations by label. */\n  readonly shapes: ReadonlyMap<string, ShExJ.ShapeDecl>;\n  /** Labelled triple expressions by label. */\n  readonly tripleExprs: ReadonlyMap<string, ShExJ.TripleExpr>;\n  /**\n   * The extension hierarchy: for each label, the labels of the declarations\n   * that (directly or transitively) extend it.\n   */\n  readonly descendants: ReadonlyMap<string, ReadonlyArray<string>>;\n}\n\nconst forEachShapeExprChild: (\n  e: ShExJ.ShapeExpr,\n  f: (child: ShExJ.ShapeExprOrRef) => void,\n) => void = Match.fn((e: ShExJ.ShapeExpr, _f: (child: ShExJ.ShapeExprOrRef) => void) => e).pipe(\n  Match.when({ type: Match.is('ShapeAnd', 'ShapeOr') }, (e, _e, f) => e.shapeExprs.forEach(f)),\n  Match.when({ type: 'ShapeNot' }, (e, _e, f) => f(e.shapeExpr)),\n  Match.orElse(() => undefined),\n);\n\ntype Labels<A> = MutableHashMap.MutableHashMap<string, A>;\n\n/** Collects the labelled triple expressions of a shape expression tree. */\nconst collectTripleExprs = (\n  root: ShExJ.ShapeExprOrRef,\n  out: Labels<ShExJ.TripleExpr>,\n  duplicates: Array<string>,\n): void => {\n  const visitShape = (e: ShExJ.ShapeExprOrRef): void => {\n    if (Predicate.isString(e)) return;\n    if (e.type === 'Shape') {\n      e.extends?.forEach(visitShape);\n      if (e.expression !== undefined) visitTriple(e.expression);\n      return;\n    }\n    forEachShapeExprChild(e, visitShape);\n  };\n  const visitTriple = (t: ShExJ.TripleExprOrRef): void => {\n    if (Predicate.isString(t)) return;\n    if (t.id !== undefined) {\n      const id = t.id;\n      if (Option.exists(MutableHashMap.get(out, id), (existing) => existing !== t))\n        duplicates.push(id);\n      MutableHashMap.set(out, id, t);\n    }\n    if (t.type === 'TripleConstraint') {\n      if (t.valueExpr !== undefined) visitShape(t.valueExpr);\n    } else {\n      t.expressions.forEach(visitTriple);\n    }\n  };\n  visitShape(root);\n};\n\n/** The labelled triple expressions of a schema, and the labels declared more than once. */\ninterface TripleExprIndex {\n  readonly tripleExprs: Labels<ShExJ.TripleExpr>;\n  readonly duplicates: Array<string>;\n}\n\nconst tripleExprsOf = (schema: ShExJ.Schema): TripleExprIndex => {\n  const tripleExprs = MutableHashMap.empty<string, ShExJ.TripleExpr>();\n  const duplicates: Array<string> = [];\n  schema.shapes?.forEach((d) => {\n    collectTripleExprs(d.shapeExpr, tripleExprs, duplicates);\n    d.restricts?.forEach((r) => collectTripleExprs(r, tripleExprs, duplicates));\n  });\n  if (schema.start !== undefined) collectTripleExprs(schema.start, tripleExprs, duplicates);\n  return { tripleExprs, duplicates };\n};\n\n/** `nestedShapes`, with the declarations looked up by `declOf`. */\nconst nestedShapesBy = (\n  declOf: (label: string) => Option.Option<ShExJ.ShapeDecl>,\n  e: ShExJ.ShapeExprOrRef,\n): ReadonlyArray<ShExJ.Shape> => {\n  const out: Array<ShExJ.Shape> = [];\n  const seen = MutableHashSet.empty<string>();\n  const go = (x: ShExJ.ShapeExprOrRef): void => {\n    if (Predicate.isString(x)) {\n      if (MutableHashSet.has(seen, x)) return;\n      MutableHashSet.add(seen, x);\n      Option.map(declOf(x), (decl) => go(decl.shapeExpr));\n      return;\n    }\n    if (x.type === 'Shape') out.push(x);\n    else forEachShapeExprChild(x, go);\n  };\n  go(e);\n  return out;\n};\n\n/**\n * The shapes nested in a shape expression (following references but not\n * triple constraints), per the ShEx 2.2 `nestedShapes` definition.\n *\n * @since 0.1.0\n * @category utils\n */\nexport const nestedShapes = (\n  shapes: ReadonlyMap<string, ShExJ.ShapeDecl>,\n  e: ShExJ.ShapeExprOrRef,\n): ReadonlyArray<ShExJ.Shape> =>\n  nestedShapesBy((label) => Option.fromUndefinedOr(shapes.get(label)), e);\n\n/** All shape labels referenced inside a shape expression (anywhere). */\nconst refsOf = (e: ShExJ.ShapeExprOrRef, out: Array<string>): void => {\n  if (Predicate.isString(e)) {\n    out.push(e);\n    return;\n  }\n  if (e.type === 'Shape') {\n    // only the extends clause, not the triple expression\n    e.extends?.forEach((x) => refsOf(x, out));\n    return;\n  }\n  forEachShapeExprChild(e, (c) => refsOf(c, out));\n};\n\n/** The labels a declaration extends: the references in the `EXTENDS` of its nested shapes. */\nconst parentsOf = (\n  declOf: (label: string) => Option.Option<ShExJ.ShapeDecl>,\n  d: ShExJ.ShapeDecl,\n): Array<string> => {\n  const parents: Array<string> = [];\n  nestedShapesBy(declOf, d.shapeExpr).forEach((s) =>\n    s.extends?.forEach((ext) => refsOf(ext, parents)),\n  );\n  return parents;\n};\n\n/** Appends `value` to the list of `key`, starting the list if there is none. */\nconst append = <A>(map: Labels<Array<A>>, key: string, value: A): void =>\n  Option.match(MutableHashMap.get(map, key), {\n    onNone: () => {\n      MutableHashMap.set(map, key, [value]);\n    },\n    onSome: (list) => {\n      list.push(value);\n    },\n  });\n\n/** The labels reachable from `label` in `children` (depth first, each once). */\nconst descendantsOf = (children: Labels<Array<string>>, label: string): ReadonlyArray<string> => {\n  const out: Array<string> = [];\n  const seen = MutableHashSet.make(label);\n  const stack = [label];\n  iterate(stack, (pending) => {\n    const l = pending.pop();\n    if (l === undefined) return Option.none();\n    Option.getOrElse(MutableHashMap.get(children, l), () => []).forEach((c) => {\n      if (MutableHashSet.has(seen, c)) return;\n      MutableHashSet.add(seen, c);\n      out.push(c);\n      pending.push(c);\n    });\n    return Option.some(pending);\n  });\n  return out;\n};\n\n/**\n * Builds the index of a schema (which should already include the\n * declarations of its imports).\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const makeIndex = (schema: ShExJ.Schema): SchemaIndex => {\n  const decls = MutableHashMap.fromIterable(\n    Arr.map(schema.shapes ?? [], (d) => [d.id, d] as const),\n  );\n  const declOf = (label: string) => MutableHashMap.get(decls, label);\n  const { tripleExprs } = tripleExprsOf(schema);\n  // Extension hierarchy: parent label -> direct children (each once, in order).\n  const children = MutableHashMap.empty<string, Array<string>>();\n  schema.shapes?.forEach((d) =>\n    parentsOf(declOf, d).forEach((p) => {\n      if (!Option.exists(MutableHashMap.get(children, p), (l) => l.includes(d.id)))\n        append(children, p, d.id);\n    }),\n  );\n  // `SchemaIndex` exposes `ReadonlyMap`s, so the index is built on native maps.\n  return {\n    schema,\n    shapes: new Map(decls),\n    tripleExprs: new Map(tripleExprs),\n    descendants: new Map(\n      Arr.map(Arr.fromIterable(MutableHashMap.keys(children)), (label) => [\n        label,\n        descendantsOf(children, label),\n      ]),\n    ),\n  };\n};\n\n// -----------------------------------------------------------------------------\n// Structural checks\n// -----------------------------------------------------------------------------\n\ninterface Edge {\n  readonly to: string;\n  readonly negative: boolean;\n}\n\n/** The cycles of a dependency graph, each rendered as `a -> b -> a`. */\nconst cyclesOf = (graph: Labels<ReadonlyArray<string>>): ReadonlyArray<string> => {\n  // 1: on the current path; 2: done.\n  const state = MutableHashMap.empty<string, number>();\n  const found: Array<string> = [];\n  const visit = (n: string, path: Array<string>): void => {\n    const s = MutableHashMap.get(state, n);\n    if (Option.contains(s, 2)) return;\n    if (Option.contains(s, 1)) {\n      found.push([...path.slice(path.indexOf(n)), n].join(' -> '));\n      return;\n    }\n    MutableHashMap.set(state, n, 1);\n    path.push(n);\n    Option.getOrElse(MutableHashMap.get(graph, n), () => []).forEach((m) => visit(m, path));\n    path.pop();\n    MutableHashMap.set(state, n, 2);\n  };\n  Iterable.forEach(MutableHashMap.keys(graph), (n) => visit(n, []));\n  return found;\n};\n\n/**\n * Returns the structural problems of a schema (empty when it is\n * well-formed). When `allowUnresolved` is set, references to undeclared\n * labels are tolerated (e.g. before imports have been loaded).\n *\n * @since 0.1.0\n * @category checks\n */\nexport const problems = (\n  schema: ShExJ.Schema,\n  options: { readonly allowUnresolved?: boolean } = {},\n): ReadonlyArray<string> => {\n  const errors: Array<string> = [];\n  const shapes = MutableHashMap.empty<string, ShExJ.ShapeDecl>();\n  schema.shapes?.forEach((d) => {\n    if (MutableHashMap.has(shapes, d.id)) errors.push(`shape ${d.id} is declared more than once`);\n    MutableHashMap.set(shapes, d.id, d);\n  });\n  const isShape = (label: string) => MutableHashMap.has(shapes, label);\n  const { tripleExprs, duplicates } = tripleExprsOf(schema);\n  duplicates.forEach((d) => errors.push(`triple expression ${d} is declared more than once`));\n  Iterable.forEach(MutableHashMap.keys(tripleExprs), (l) => {\n    if (isShape(l)) errors.push(`${l} labels both a shape and a triple expression`);\n  });\n\n  const checkRef = (label: string) => {\n    if (!isShape(label) && options.allowUnresolved !== true)\n      errors.push(`reference to undeclared shape ${label}`);\n  };\n  const checkInclude = (label: string) => {\n    if (MutableHashMap.has(tripleExprs, label)) return;\n    if (isShape(label)) errors.push(`inclusion &${label} names a shape, not a triple expression`);\n    else if (options.allowUnresolved !== true)\n      errors.push(`inclusion of undeclared triple expression ${label}`);\n  };\n\n  // Dependency graph with polarity, and the direct (non-triple) reference graph.\n  const deps = MutableHashMap.empty<string, Array<Edge>>();\n  const direct = MutableHashMap.empty<string, Array<string>>();\n\n  const walkShape = (\n    from: string,\n    e: ShExJ.ShapeExprOrRef,\n    negative: boolean,\n    isDirect: boolean,\n    visitingIncludes: MutableHashSet.MutableHashSet<string>,\n  ): void => {\n    if (Predicate.isString(e)) {\n      checkRef(e);\n      append(deps, from, { to: e, negative });\n      if (isDirect) append(direct, from, e);\n      return;\n    }\n    Match.value(e).pipe(\n      Match.discriminator('type')('ShapeAnd', 'ShapeOr', (expr) =>\n        expr.shapeExprs.forEach((c) => walkShape(from, c, negative, isDirect, visitingIncludes)),\n      ),\n      Match.discriminator('type')('ShapeNot', (expr) =>\n        walkShape(from, expr.shapeExpr, true, isDirect, visitingIncludes),\n      ),\n      Match.discriminator('type')('Shape', (expr) => {\n        expr.extends?.forEach((x) => walkShape(from, x, negative, false, visitingIncludes));\n        const extra = MutableHashSet.fromIterable(expr.extra ?? []);\n        if (expr.expression !== undefined)\n          walkTriple(from, expr.expression, negative, extra, visitingIncludes);\n      }),\n      Match.orElse(() => undefined),\n    );\n  };\n  const walkTriple = (\n    from: string,\n    t: ShExJ.TripleExprOrRef,\n    negative: boolean,\n    extra: MutableHashSet.MutableHashSet<string>,\n    visitingIncludes: MutableHashSet.MutableHashSet<string>,\n  ): void => {\n    if (Predicate.isString(t)) {\n      checkInclude(t);\n      if (MutableHashSet.has(visitingIncludes, t)) return;\n      Option.map(MutableHashMap.get(tripleExprs, t), (target) => {\n        MutableHashSet.add(visitingIncludes, t);\n        walkTriple(from, target, negative, extra, visitingIncludes);\n        MutableHashSet.remove(visitingIncludes, t);\n      });\n      return;\n    }\n    if (t.type === 'TripleConstraint') {\n      if (t.valueExpr !== undefined) {\n        const neg = negative || (MutableHashSet.has(extra, t.predicate) && t.inverse !== true);\n        walkShape(from, t.valueExpr, neg, false, visitingIncludes);\n      }\n      return;\n    }\n    t.expressions.forEach((c) => walkTriple(from, c, negative, extra, visitingIncludes));\n  };\n\n  const roots = Arr.flatMap(schema.shapes ?? [], (d) => [\n    [d.id, d.shapeExpr] as const,\n    ...Arr.map(d.restricts ?? [], (r) => [d.id, r] as const),\n  ]);\n  roots.forEach(([label]) => {\n    MutableHashMap.set(deps, label, []);\n    MutableHashMap.set(direct, label, []);\n  });\n  roots.forEach(([label, expr]) => walkShape(label, expr, false, true, MutableHashSet.empty()));\n  if (schema.start !== undefined) {\n    MutableHashMap.set(deps, '\\u0000start', []);\n    MutableHashMap.set(direct, '\\u0000start', []);\n    walkShape('\\u0000start', schema.start, false, true, MutableHashSet.empty());\n  }\n\n  // Direct self-reference cycles.\n  cyclesOf(direct).forEach((c) => errors.push(`shape expression refers to itself: ${c}`));\n\n  // Negation requirement: no strongly connected component contains a negative edge.\n  const sccOf = tarjan(Arr.fromIterable(MutableHashMap.keys(deps)), (n) =>\n    Arr.map(\n      Option.getOrElse(MutableHashMap.get(deps, n), () => []),\n      (e) => e.to,\n    ),\n  );\n  Iterable.forEach(deps, ([from, edges]) =>\n    edges.forEach((e) => {\n      const component = MutableHashMap.get(sccOf, from);\n      if (\n        e.negative &&\n        Option.exists(component, (c) => Option.contains(MutableHashMap.get(sccOf, e.to), c))\n      ) {\n        errors.push(`reference cycle through negation between ${from} and ${e.to}`);\n      }\n    }),\n  );\n\n  // Acyclic extension hierarchy.\n  const declOf = (label: string) => MutableHashMap.get(shapes, label);\n  const extendsGraph = MutableHashMap.empty<string, ReadonlyArray<string>>();\n  schema.shapes?.forEach((d) => MutableHashMap.set(extendsGraph, d.id, parentsOf(declOf, d)));\n  cyclesOf(extendsGraph).forEach((c) => errors.push(`cyclic extension hierarchy: ${c}`));\n  return Arr.dedupe(errors);\n};\n\n/** Tarjan's bookkeeping for one node. */\ninterface Visited {\n  readonly index: number;\n  low: number;\n  onStack: boolean;\n}\n\n/** The strongly connected component of every node, by Tarjan's algorithm. */\nconst tarjan = (\n  nodes: ReadonlyArray<string>,\n  succ: (n: string) => ReadonlyArray<string>,\n): Labels<number> => {\n  let index = 0;\n  let component = 0;\n  const visited = MutableHashMap.empty<string, Visited>();\n  const stack: Array<string> = [];\n  const result = MutableHashMap.empty<string, number>();\n  const strong = (v: string): Visited => {\n    const nv: Visited = { index, low: index, onStack: true };\n    MutableHashMap.set(visited, v, nv);\n    index++;\n    stack.push(v);\n    succ(v).forEach((w) =>\n      Option.match(MutableHashMap.get(visited, w), {\n        onNone: () => {\n          nv.low = Math.min(nv.low, strong(w).low);\n        },\n        onSome: (nw) => {\n          if (nw.onStack) nv.low = Math.min(nv.low, nw.index);\n        },\n      }),\n    );\n    if (nv.low === nv.index) {\n      // Pop the component, down to and including `v`.\n      iterate(stack, (pending) => {\n        const w = pending.pop();\n        if (w === undefined) return Option.none();\n        Option.map(MutableHashMap.get(visited, w), (nw) => {\n          nw.onStack = false;\n        });\n        MutableHashMap.set(result, w, component);\n        return w === v ? Option.none() : Option.some(pending);\n      });\n      component++;\n    }\n    return nv;\n  };\n  nodes.forEach((n) => {\n    if (!MutableHashMap.has(visited, n)) strong(n);\n  });\n  return result;\n};\n\n/**\n * Checks the structural requirements of a schema, failing with a\n * `ShExStructureError` listing the problems.\n *\n * @since 0.1.0\n * @category checks\n */\nexport const check = (\n  schema: ShExJ.Schema,\n  options: { readonly allowUnresolved?: boolean } = {},\n): Effect.Effect<ShExJ.Schema, ShExStructureError> =>\n  Effect.suspend(() => {\n    const errs = problems(schema, options);\n    return Arr.isReadonlyArrayEmpty(errs)\n      ? Effect.succeed(schema)\n      : Effect.fail(new ShExStructureError({ message: errs.join('; ') }));\n  });\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAWA,MAAa,WAAc,SAAY,MAAwC;CAC7E,IAAI,OAAO,UAAU,MAAM,OAAO,IAAI,EAAE,CAAC,IAAI,SAAS,CAAC,KAAA,GAAW,IAAI,CAAU,CAAC;AACnF;;;;;;;;;;;;;;;;;AC2BA,MAAM,wBAGM,MAAM,IAAI,GAAoB,OAA8C,CAAC,CAAC,CAAC,KACzF,MAAM,KAAK,EAAE,MAAM,MAAM,GAAG,YAAY,SAAS,EAAE,IAAI,GAAG,IAAI,MAAM,EAAE,WAAW,QAAQ,CAAC,CAAC,GAC3F,MAAM,KAAK,EAAE,MAAM,WAAW,IAAI,GAAG,IAAI,MAAM,EAAE,EAAE,SAAS,CAAC,GAC7D,MAAM,aAAa,KAAA,CAAS,CAC9B;;AAKA,MAAM,sBACJ,MACA,KACA,eACS;CACT,MAAM,cAAc,MAAkC;EACpD,IAAI,UAAU,SAAS,CAAC,GAAG;EAC3B,IAAI,EAAE,SAAS,SAAS;GACtB,EAAE,SAAS,QAAQ,UAAU;GAC7B,IAAI,EAAE,eAAe,KAAA,GAAW,YAAY,EAAE,UAAU;GACxD;EACF;EACA,sBAAsB,GAAG,UAAU;CACrC;CACA,MAAM,eAAe,MAAmC;EACtD,IAAI,UAAU,SAAS,CAAC,GAAG;EAC3B,IAAI,EAAE,OAAO,KAAA,GAAW;GACtB,MAAM,KAAK,EAAE;GACb,IAAI,OAAO,OAAO,eAAe,IAAI,KAAK,EAAE,IAAI,aAAa,aAAa,CAAC,GACzE,WAAW,KAAK,EAAE;GACpB,eAAe,IAAI,KAAK,IAAI,CAAC;EAC/B;EACA,IAAI,EAAE,SAAS,oBACT;OAAA,EAAE,cAAc,KAAA,GAAW,WAAW,EAAE,SAAS;EAAA,OAErD,EAAE,YAAY,QAAQ,WAAW;CAErC;CACA,WAAW,IAAI;AACjB;AAQA,MAAM,iBAAiB,WAA0C;CAC/D,MAAM,cAAc,eAAe,MAAgC;CACnE,MAAM,aAA4B,CAAC;CACnC,OAAO,QAAQ,SAAS,MAAM;EAC5B,mBAAmB,EAAE,WAAW,aAAa,UAAU;EACvD,EAAE,WAAW,SAAS,MAAM,mBAAmB,GAAG,aAAa,UAAU,CAAC;CAC5E,CAAC;CACD,IAAI,OAAO,UAAU,KAAA,GAAW,mBAAmB,OAAO,OAAO,aAAa,UAAU;CACxF,OAAO;EAAE;EAAa;CAAW;AACnC;;AAGA,MAAM,kBACJ,QACA,MAC+B;CAC/B,MAAM,MAA0B,CAAC;CACjC,MAAM,OAAO,eAAe,MAAc;CAC1C,MAAM,MAAM,MAAkC;EAC5C,IAAI,UAAU,SAAS,CAAC,GAAG;GACzB,IAAI,eAAe,IAAI,MAAM,CAAC,GAAG;GACjC,eAAe,IAAI,MAAM,CAAC;GAC1B,OAAO,IAAI,OAAO,CAAC,IAAI,SAAS,GAAG,KAAK,SAAS,CAAC;GAClD;EACF;EACA,IAAI,EAAE,SAAS,SAAS,IAAI,KAAK,CAAC;OAC7B,sBAAsB,GAAG,EAAE;CAClC;CACA,GAAG,CAAC;CACJ,OAAO;AACT;;;;;;;;AASA,MAAa,gBACX,QACA,MAEA,gBAAgB,UAAU,OAAO,gBAAgB,OAAO,IAAI,KAAK,CAAC,GAAG,CAAC;;AAGxE,MAAM,UAAU,GAAyB,QAA6B;CACpE,IAAI,UAAU,SAAS,CAAC,GAAG;EACzB,IAAI,KAAK,CAAC;EACV;CACF;CACA,IAAI,EAAE,SAAS,SAAS;EAEtB,EAAE,SAAS,SAAS,MAAM,OAAO,GAAG,GAAG,CAAC;EACxC;CACF;CACA,sBAAsB,IAAI,MAAM,OAAO,GAAG,GAAG,CAAC;AAChD;;AAGA,MAAM,aACJ,QACA,MACkB;CAClB,MAAM,UAAyB,CAAC;CAChC,eAAe,QAAQ,EAAE,SAAS,CAAC,CAAC,SAAS,MAC3C,EAAE,SAAS,SAAS,QAAQ,OAAO,KAAK,OAAO,CAAC,CAClD;CACA,OAAO;AACT;;AAGA,MAAM,UAAa,KAAuB,KAAa,UACrD,OAAO,MAAM,eAAe,IAAI,KAAK,GAAG,GAAG;CACzC,cAAc;EACZ,eAAe,IAAI,KAAK,KAAK,CAAC,KAAK,CAAC;CACtC;CACA,SAAS,SAAS;EAChB,KAAK,KAAK,KAAK;CACjB;AACF,CAAC;;AAGH,MAAM,iBAAiB,UAAiC,UAAyC;CAC/F,MAAM,MAAqB,CAAC;CAC5B,MAAM,OAAO,eAAe,KAAK,KAAK;CAEtC,QAAQ,CADO,KACH,IAAI,YAAY;EAC1B,MAAM,IAAI,QAAQ,IAAI;EACtB,IAAI,MAAM,KAAA,GAAW,OAAO,OAAO,KAAK;EACxC,OAAO,UAAU,eAAe,IAAI,UAAU,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,MAAM;GACzE,IAAI,eAAe,IAAI,MAAM,CAAC,GAAG;GACjC,eAAe,IAAI,MAAM,CAAC;GAC1B,IAAI,KAAK,CAAC;GACV,QAAQ,KAAK,CAAC;EAChB,CAAC;EACD,OAAO,OAAO,KAAK,OAAO;CAC5B,CAAC;CACD,OAAO;AACT;;;;;;;;AASA,MAAa,aAAa,WAAsC;CAC9D,MAAM,QAAQ,eAAe,aAC3B,IAAI,IAAI,OAAO,UAAU,CAAC,IAAI,MAAM,CAAC,EAAE,IAAI,CAAC,CAAU,CACxD;CACA,MAAM,UAAU,UAAkB,eAAe,IAAI,OAAO,KAAK;CACjE,MAAM,EAAE,gBAAgB,cAAc,MAAM;CAE5C,MAAM,WAAW,eAAe,MAA6B;CAC7D,OAAO,QAAQ,SAAS,MACtB,UAAU,QAAQ,CAAC,CAAC,CAAC,SAAS,MAAM;EAClC,IAAI,CAAC,OAAO,OAAO,eAAe,IAAI,UAAU,CAAC,IAAI,MAAM,EAAE,SAAS,EAAE,EAAE,CAAC,GACzE,OAAO,UAAU,GAAG,EAAE,EAAE;CAC5B,CAAC,CACH;CAEA,OAAO;EACL;EACA,QAAQ,IAAI,IAAI,KAAK;EACrB,aAAa,IAAI,IAAI,WAAW;EAChC,aAAa,IAAI,IACf,IAAI,IAAI,IAAI,aAAa,eAAe,KAAK,QAAQ,CAAC,IAAI,UAAU,CAClE,OACA,cAAc,UAAU,KAAK,CAC/B,CAAC,CACH;CACF;AACF;;AAYA,MAAM,YAAY,UAAgE;CAEhF,MAAM,QAAQ,eAAe,MAAsB;CACnD,MAAM,QAAuB,CAAC;CAC9B,MAAM,SAAS,GAAW,SAA8B;EACtD,MAAM,IAAI,eAAe,IAAI,OAAO,CAAC;EACrC,IAAI,OAAO,SAAS,GAAG,CAAC,GAAG;EAC3B,IAAI,OAAO,SAAS,GAAG,CAAC,GAAG;GACzB,MAAM,KAAK,CAAC,GAAG,KAAK,MAAM,KAAK,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC;GAC3D;EACF;EACA,eAAe,IAAI,OAAO,GAAG,CAAC;EAC9B,KAAK,KAAK,CAAC;EACX,OAAO,UAAU,eAAe,IAAI,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,MAAM,MAAM,GAAG,IAAI,CAAC;EACtF,KAAK,IAAI;EACT,eAAe,IAAI,OAAO,GAAG,CAAC;CAChC;CACA,SAAS,QAAQ,eAAe,KAAK,KAAK,IAAI,MAAM,MAAM,GAAG,CAAC,CAAC,CAAC;CAChE,OAAO;AACT;;;;;;;;;AAUA,MAAa,YACX,QACA,UAAkD,CAAC,MACzB;CAC1B,MAAM,SAAwB,CAAC;CAC/B,MAAM,SAAS,eAAe,MAA+B;CAC7D,OAAO,QAAQ,SAAS,MAAM;EAC5B,IAAI,eAAe,IAAI,QAAQ,EAAE,EAAE,GAAG,OAAO,KAAK,SAAS,EAAE,GAAG,4BAA4B;EAC5F,eAAe,IAAI,QAAQ,EAAE,IAAI,CAAC;CACpC,CAAC;CACD,MAAM,WAAW,UAAkB,eAAe,IAAI,QAAQ,KAAK;CACnE,MAAM,EAAE,aAAa,eAAe,cAAc,MAAM;CACxD,WAAW,SAAS,MAAM,OAAO,KAAK,qBAAqB,EAAE,4BAA4B,CAAC;CAC1F,SAAS,QAAQ,eAAe,KAAK,WAAW,IAAI,MAAM;EACxD,IAAI,QAAQ,CAAC,GAAG,OAAO,KAAK,GAAG,EAAE,6CAA6C;CAChF,CAAC;CAED,MAAM,YAAY,UAAkB;EAClC,IAAI,CAAC,QAAQ,KAAK,KAAK,QAAQ,oBAAoB,MACjD,OAAO,KAAK,iCAAiC,OAAO;CACxD;CACA,MAAM,gBAAgB,UAAkB;EACtC,IAAI,eAAe,IAAI,aAAa,KAAK,GAAG;EAC5C,IAAI,QAAQ,KAAK,GAAG,OAAO,KAAK,cAAc,MAAM,wCAAwC;OACvF,IAAI,QAAQ,oBAAoB,MACnC,OAAO,KAAK,6CAA6C,OAAO;CACpE;CAGA,MAAM,OAAO,eAAe,MAA2B;CACvD,MAAM,SAAS,eAAe,MAA6B;CAE3D,MAAM,aACJ,MACA,GACA,UACA,UACA,qBACS;EACT,IAAI,UAAU,SAAS,CAAC,GAAG;GACzB,SAAS,CAAC;GACV,OAAO,MAAM,MAAM;IAAE,IAAI;IAAG;GAAS,CAAC;GACtC,IAAI,UAAU,OAAO,QAAQ,MAAM,CAAC;GACpC;EACF;EACA,MAAM,MAAM,CAAC,CAAC,CAAC,KACb,MAAM,cAAc,MAAM,CAAC,CAAC,YAAY,YAAY,SAClD,KAAK,WAAW,SAAS,MAAM,UAAU,MAAM,GAAG,UAAU,UAAU,gBAAgB,CAAC,CACzF,GACA,MAAM,cAAc,MAAM,CAAC,CAAC,aAAa,SACvC,UAAU,MAAM,KAAK,WAAW,MAAM,UAAU,gBAAgB,CAClE,GACA,MAAM,cAAc,MAAM,CAAC,CAAC,UAAU,SAAS;GAC7C,KAAK,SAAS,SAAS,MAAM,UAAU,MAAM,GAAG,UAAU,OAAO,gBAAgB,CAAC;GAClF,MAAM,QAAQ,eAAe,aAAa,KAAK,SAAS,CAAC,CAAC;GAC1D,IAAI,KAAK,eAAe,KAAA,GACtB,WAAW,MAAM,KAAK,YAAY,UAAU,OAAO,gBAAgB;EACvE,CAAC,GACD,MAAM,aAAa,KAAA,CAAS,CAC9B;CACF;CACA,MAAM,cACJ,MACA,GACA,UACA,OACA,qBACS;EACT,IAAI,UAAU,SAAS,CAAC,GAAG;GACzB,aAAa,CAAC;GACd,IAAI,eAAe,IAAI,kBAAkB,CAAC,GAAG;GAC7C,OAAO,IAAI,eAAe,IAAI,aAAa,CAAC,IAAI,WAAW;IACzD,eAAe,IAAI,kBAAkB,CAAC;IACtC,WAAW,MAAM,QAAQ,UAAU,OAAO,gBAAgB;IAC1D,eAAe,OAAO,kBAAkB,CAAC;GAC3C,CAAC;GACD;EACF;EACA,IAAI,EAAE,SAAS,oBAAoB;GACjC,IAAI,EAAE,cAAc,KAAA,GAAW;IAC7B,MAAM,MAAM,YAAa,eAAe,IAAI,OAAO,EAAE,SAAS,KAAK,EAAE,YAAY;IACjF,UAAU,MAAM,EAAE,WAAW,KAAK,OAAO,gBAAgB;GAC3D;GACA;EACF;EACA,EAAE,YAAY,SAAS,MAAM,WAAW,MAAM,GAAG,UAAU,OAAO,gBAAgB,CAAC;CACrF;CAEA,MAAM,QAAQ,IAAI,QAAQ,OAAO,UAAU,CAAC,IAAI,MAAM,CACpD,CAAC,EAAE,IAAI,EAAE,SAAS,GAClB,GAAG,IAAI,IAAI,EAAE,aAAa,CAAC,IAAI,MAAM,CAAC,EAAE,IAAI,CAAC,CAAU,CACzD,CAAC;CACD,MAAM,SAAS,CAAC,WAAW;EACzB,eAAe,IAAI,MAAM,OAAO,CAAC,CAAC;EAClC,eAAe,IAAI,QAAQ,OAAO,CAAC,CAAC;CACtC,CAAC;CACD,MAAM,SAAS,CAAC,OAAO,UAAU,UAAU,OAAO,MAAM,OAAO,MAAM,eAAe,MAAM,CAAC,CAAC;CAC5F,IAAI,OAAO,UAAU,KAAA,GAAW;EAC9B,eAAe,IAAI,MAAM,WAAe,CAAC,CAAC;EAC1C,eAAe,IAAI,QAAQ,WAAe,CAAC,CAAC;EAC5C,UAAU,WAAe,OAAO,OAAO,OAAO,MAAM,eAAe,MAAM,CAAC;CAC5E;CAGA,SAAS,MAAM,CAAC,CAAC,SAAS,MAAM,OAAO,KAAK,sCAAsC,GAAG,CAAC;CAGtF,MAAM,QAAQ,OAAO,IAAI,aAAa,eAAe,KAAK,IAAI,CAAC,IAAI,MACjE,IAAI,IACF,OAAO,UAAU,eAAe,IAAI,MAAM,CAAC,SAAS,CAAC,CAAC,IACrD,MAAM,EAAE,EACX,CACF;CACA,SAAS,QAAQ,OAAO,CAAC,MAAM,WAC7B,MAAM,SAAS,MAAM;EACnB,MAAM,YAAY,eAAe,IAAI,OAAO,IAAI;EAChD,IACE,EAAE,YACF,OAAO,OAAO,YAAY,MAAM,OAAO,SAAS,eAAe,IAAI,OAAO,EAAE,EAAE,GAAG,CAAC,CAAC,GAEnF,OAAO,KAAK,4CAA4C,KAAK,OAAO,EAAE,IAAI;CAE9E,CAAC,CACH;CAGA,MAAM,UAAU,UAAkB,eAAe,IAAI,QAAQ,KAAK;CAClE,MAAM,eAAe,eAAe,MAAqC;CACzE,OAAO,QAAQ,SAAS,MAAM,eAAe,IAAI,cAAc,EAAE,IAAI,UAAU,QAAQ,CAAC,CAAC,CAAC;CAC1F,SAAS,YAAY,CAAC,CAAC,SAAS,MAAM,OAAO,KAAK,+BAA+B,GAAG,CAAC;CACrF,OAAO,IAAI,OAAO,MAAM;AAC1B;;AAUA,MAAM,UACJ,OACA,SACmB;CACnB,IAAI,QAAQ;CACZ,IAAI,YAAY;CAChB,MAAM,UAAU,eAAe,MAAuB;CACtD,MAAM,QAAuB,CAAC;CAC9B,MAAM,SAAS,eAAe,MAAsB;CACpD,MAAM,UAAU,MAAuB;EACrC,MAAM,KAAc;GAAE;GAAO,KAAK;GAAO,SAAS;EAAK;EACvD,eAAe,IAAI,SAAS,GAAG,EAAE;EACjC;EACA,MAAM,KAAK,CAAC;EACZ,KAAK,CAAC,CAAC,CAAC,SAAS,MACf,OAAO,MAAM,eAAe,IAAI,SAAS,CAAC,GAAG;GAC3C,cAAc;IACZ,GAAG,MAAM,KAAK,IAAI,GAAG,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG;GACzC;GACA,SAAS,OAAO;IACd,IAAI,GAAG,SAAS,GAAG,MAAM,KAAK,IAAI,GAAG,KAAK,GAAG,KAAK;GACpD;EACF,CAAC,CACH;EACA,IAAI,GAAG,QAAQ,GAAG,OAAO;GAEvB,QAAQ,QAAQ,YAAY;IAC1B,MAAM,IAAI,QAAQ,IAAI;IACtB,IAAI,MAAM,KAAA,GAAW,OAAO,OAAO,KAAK;IACxC,OAAO,IAAI,eAAe,IAAI,SAAS,CAAC,IAAI,OAAO;KACjD,GAAG,UAAU;IACf,CAAC;IACD,eAAe,IAAI,QAAQ,GAAG,SAAS;IACvC,OAAO,MAAM,IAAI,OAAO,KAAK,IAAI,OAAO,KAAK,OAAO;GACtD,CAAC;GACD;EACF;EACA,OAAO;CACT;CACA,MAAM,SAAS,MAAM;EACnB,IAAI,CAAC,eAAe,IAAI,SAAS,CAAC,GAAG,OAAO,CAAC;CAC/C,CAAC;CACD,OAAO;AACT;;;;;;;;AASA,MAAa,SACX,QACA,UAAkD,CAAC,MAEnD,OAAO,cAAc;CACnB,MAAM,OAAO,SAAS,QAAQ,OAAO;CACrC,OAAO,IAAI,qBAAqB,IAAI,IAChC,OAAO,QAAQ,MAAM,IACrB,OAAO,KAAK,IAAI,mBAAmB,EAAE,SAAS,KAAK,KAAK,IAAI,EAAE,CAAC,CAAC;AACtE,CAAC"}

package/dist/Structure-n4CmDiab.d.mts

@@ -0,0 +1,63 @@
+import { a as ShExStructureError } from "./ShExError-BeYFD9rv.mjs";
+import { B as ShapeDecl, L as Shape, M as Schema, U as ShapeExprOrRef, tt as TripleExpr } from "./ShExJ-C1u_wgyD.mjs";
+import * as Effect from "effect/Effect";
+declare namespace Structure_d_exports {
+  export { SchemaIndex, check, makeIndex, nestedShapes, problems };
+}
+/**
+ * An index of the declarations of a schema.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface SchemaIndex {
+  readonly schema: Schema;
+  /** Shape declarations by label. */
+  readonly shapes: ReadonlyMap<string, ShapeDecl>;
+  /** Labelled triple expressions by label. */
+  readonly tripleExprs: ReadonlyMap<string, TripleExpr>;
+  /**
+   * The extension hierarchy: for each label, the labels of the declarations
+   * that (directly or transitively) extend it.
+   */
+  readonly descendants: ReadonlyMap<string, ReadonlyArray<string>>;
+}
+/**
+ * The shapes nested in a shape expression (following references but not
+ * triple constraints), per the ShEx 2.2 `nestedShapes` definition.
+ *
+ * @since 0.1.0
+ * @category utils
+ */
+declare const nestedShapes: (shapes: ReadonlyMap<string, ShapeDecl>, e: ShapeExprOrRef) => ReadonlyArray<Shape>;
+/**
+ * Builds the index of a schema (which should already include the
+ * declarations of its imports).
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const makeIndex: (schema: Schema) => SchemaIndex;
+/**
+ * Returns the structural problems of a schema (empty when it is
+ * well-formed). When `allowUnresolved` is set, references to undeclared
+ * labels are tolerated (e.g. before imports have been loaded).
+ *
+ * @since 0.1.0
+ * @category checks
+ */
+declare const problems: (schema: Schema, options?: {
+  readonly allowUnresolved?: boolean;
+}) => ReadonlyArray<string>;
+/**
+ * Checks the structural requirements of a schema, failing with a
+ * `ShExStructureError` listing the problems.
+ *
+ * @since 0.1.0
+ * @category checks
+ */
+declare const check: (schema: Schema, options?: {
+  readonly allowUnresolved?: boolean;
+}) => Effect.Effect<Schema, ShExStructureError>;
+export { nestedShapes as a, makeIndex as i, Structure_d_exports as n, problems as o, check as r, SchemaIndex as t };
+//# sourceMappingURL=Structure-n4CmDiab.d.mts.map