@thomasfosterau/effect-rdf 0.0.0 → 0.1.0

package/dist/ShExC-DJbB19i3.mjs

@@ -0,0 +1,1181 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { i as isAbsolute, l as resolve$1, s as relativize } from "./Iri-Cr92gsQV.mjs";
+import { i as empty$1, l as set, o as get, r as compact, s as make$1 } from "./PrefixMap-BHFPDLO-.mjs";
+import { n as RdfParseError } from "./Serialization-DP9H5bYQ.mjs";
+import { a as digit, d as iriRef, i as blankNodeLabel, l as hex, n as alpha, p as langTag$1 } from "./Grammar-mQ8CgE1M.mjs";
+import { c as numericLiteral, f as prefixedName, m as stringLiteral } from "./Grammar-CPlSxGH6.mjs";
+import { r as skip$1 } from "./tokens-C6BzeodQ.mjs";
+import * as Arr from "effect/Array";
+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";
+import * as Compiler from "@thomasfosterau/effect-parse/Compiler";
+import * as Parser from "@thomasfosterau/effect-parse/Parser";
+import * as Token from "@thomasfosterau/effect-parse/Token";
+import * as ParseError from "@thomasfosterau/effect-parse/ParseError";
+// src/shex/internal/lexer.ts
+/**
+* Lexical helpers shared by the ShExC lexer and the error reporting: the
+* unescaping of `REGEXP` and `CODE` bodies, and offset-to-position
+* conversion. The terminals are Turtle's (`../../turtle/Grammar.ts`) and `tokens.ts`.
+*
+* @internal
+*/
+/**
+* Replaces one escape: a numeric escape (`\uXXXX`, `\UXXXXXXXX`, the only
+* ones longer than two characters) by its code point, any other by `keep`
+* applied to the escaped character.
+*/
+const unescapeOne = (keep) => (all) => all.length > 2 ? String.fromCodePoint(parseInt(all.slice(2), 16)) : keep(all.slice(1), all);
+/**
+* Unescapes a ShExC `REGEXP` body: `\/` becomes `/` and numeric escapes are
+* replaced by their code points; every other escape is kept verbatim.
+*/
+const unescapeRegexp = (s) => s.replace(/\\u([0-9A-Fa-f]{4})|\\U([0-9A-Fa-f]{8})|\\(.)/gs, unescapeOne((c, all) => c === "/" ? "/" : all));
+/** Unescapes a semantic action `CODE` body (`\%`, `\\` and UCHAR). */
+const unescapeCode = (s) => s.replace(/\\u([0-9A-Fa-f]{4})|\\U([0-9A-Fa-f]{8})|\\([%\\])/g, unescapeOne((c) => c));
+/** Converts a string offset to a 1-based line and column. */
+const lineColumn = (input, pos) => {
+	const before = input.slice(0, Math.max(pos, 0));
+	return {
+		line: before.split("\n").length,
+		column: pos - (before.lastIndexOf("\n") + 1) + 1
+	};
+};
+const encodeJsonString = Schema.encodeSync(Schema.fromJsonString(Schema.String));
+/** Quotes a string as a JSON string literal, for error messages. */
+const quote = (s) => encodeJsonString(s);
+// src/shex/internal/shexcLexer.ts
+/**
+* The ShExC lexer, written with `@thomasfosterau/effect-parse`: a compiled
+* grammar turning a document into tokens, followed by a pass that resolves
+* IRIs (relative IRI references against the base, prefixed names against
+* the prefixes) in document order, as `BASE` and `PREFIX` directives are
+* met. The parser then works on resolved tokens, so neither grammar depends
+* on per-document state and both can be compiled.
+*
+* @internal
+*/
+/** A token, with every field present so that all tokens have the same shape. */
+const make = (t, start, end) => ({
+	type: t.type,
+	text: t.text,
+	kind: t.type === "KEYWORD" || t.type === "PUNCT" ? t.text : t.type,
+	start,
+	end,
+	iri: t.iri ?? "",
+	error: Option.none(),
+	suffix: t.suffix ?? "",
+	min: t.min ?? 0,
+	max: t.max ?? 0
+});
+const KEYWORDS = MutableHashSet.fromIterable([
+	"BASE",
+	"PREFIX",
+	"IMPORT",
+	"START",
+	"EXTERNAL",
+	"ABSTRACT",
+	"RESTRICTS",
+	"EXTENDS",
+	"CLOSED",
+	"EXTRA",
+	"LITERAL",
+	"BNODE",
+	"IRI",
+	"NONLITERAL",
+	"AND",
+	"OR",
+	"NOT",
+	"MININCLUSIVE",
+	"MINEXCLUSIVE",
+	"MAXINCLUSIVE",
+	"MAXEXCLUSIVE",
+	"LENGTH",
+	"MINLENGTH",
+	"MAXLENGTH",
+	"TOTALDIGITS",
+	"FRACTIONDIGITS"
+]);
+const pname = (type) => Parser.map(prefixedName, ({ prefix, local }) => ({
+	type,
+	text: prefix,
+	iri: local
+}));
+const numeric = Parser.map(numericLiteral, ([text, type]) => ({
+	type: type === "integer" ? "INTEGER" : type === "decimal" ? "DECIMAL" : "DOUBLE",
+	text
+}));
+const string = Parser.map(Parser.seq(stringLiteral, Parser.opt(langTag$1)), ([text, lang]) => Option.isSome(lang) ? {
+	type: "LANG_STRING",
+	text,
+	suffix: lang.value
+} : {
+	type: "STRING",
+	text
+});
+const regexp = Parser.preceded(Token.literal("/"), Parser.seq(Parser.taken(Parser.repeat(Parser.alt(Token.takeTill("/\\\n\r", { min: 1 }), Parser.seq(Token.literal("\\"), Token.oneOf("nrt\\|.?*+(){}$-[]^/")), Parser.seq(Token.literal("\\u"), Token.takeWhile(hex, 4)), Parser.seq(Token.literal("\\U"), Token.takeWhile(hex, 8))), { min: 1 })), Parser.preceded(Token.literal("/"), Token.takeWhile("smix")))).pipe(Parser.map(([body, flags]) => ({
+	type: "REGEXP",
+	text: unescapeRegexp(body),
+	suffix: flags
+})));
+const code = Parser.delimited(Token.literal("{"), Parser.taken(Parser.repeat(Parser.alt(Token.takeTill("%\\", { min: 1 }), Parser.seq(Token.literal("\\"), Token.oneOf("%\\")), Parser.seq(Token.literal("\\u"), Token.takeWhile(hex, 4)), Parser.seq(Token.literal("\\U"), Token.takeWhile(hex, 8))))), Token.literal("%}")).pipe(Parser.map((body) => ({
+	type: "CODE",
+	text: unescapeCode(body)
+})));
+const bound = Parser.preceded(Parser.opt(Token.oneOf("+-")), Token.takeWhile(digit, { min: 1 }));
+const repeatRange = Parser.delimited(Token.literal("{"), Parser.seq(bound, Parser.opt(Parser.preceded(Token.literal(","), Parser.opt(Parser.alt(bound, Token.literal("*")))))), Token.literal("}")).pipe(Parser.map(([min, rest]) => {
+	const lo = parseInt(min, 10);
+	return {
+		type: "REPEAT_RANGE",
+		text: "",
+		min: lo,
+		max: Option.match(rest, {
+			onNone: () => lo,
+			onSome: (upper) => Option.match(upper, {
+				onNone: () => -1,
+				onSome: (u) => u === "*" ? -1 : parseInt(u, 10)
+			})
+		})
+	};
+}));
+const word = Token.takeWhile(alpha, { min: 1 }).pipe(Parser.filterMap((w) => {
+	if (w === "a" || w === "true" || w === "false") return Option.some({
+		type: "PUNCT",
+		text: w
+	});
+	const upper = w.toUpperCase();
+	return MutableHashSet.has(KEYWORDS, upper) ? Option.some({
+		type: "KEYWORD",
+		text: upper
+	}) : Option.none();
+}));
+/** One token, in the order of preference of the ShEx 2 lexer. */
+const punctuation = (...ps) => Parser.alt(...ps.map((p) => Token.literal(p))).pipe(Parser.map((text) => ({
+	type: "PUNCT",
+	text
+})));
+const prefixedOrWord = Parser.alt(pname("PNAME"), word);
+const numericOr = (p) => Parser.alt(numeric, punctuation(p));
+/**
+* One token. The first character selects the candidates, which are tried in
+* the order of preference of the ShEx 2 lexer.
+*/
+const token = Parser.dispatch(Parser.peek(Token.any), {
+	"@": Parser.alt(Parser.preceded(Token.literal("@"), pname("ATPNAME")), langTag$1.pipe(Parser.map((text) => ({
+		type: "LANGTAG",
+		text
+	}))), punctuation("@")),
+	"<": iriRef.pipe(Parser.map((iri) => ({
+		type: "IRIREF",
+		text: "",
+		iri
+	}))),
+	"/": Parser.alt(punctuation("//"), regexp),
+	_: blankNodeLabel.pipe(Parser.map((label) => ({
+		type: "BLANK_NODE_LABEL",
+		text: `_:${label}`
+	}))),
+	"\"": string,
+	"'": string,
+	"{": Parser.alt(repeatRange, code, punctuation("{")),
+	"^": punctuation("^^", "^"),
+	"|": punctuation("||", "|"),
+	".": numericOr("."),
+	"+": numericOr("+"),
+	"-": numericOr("-"),
+	...Record.fromEntries(Arr.map("0123456789".split(""), (d) => [d, numeric])),
+	...Record.fromEntries(Arr.map("=}&,()[]$!~;*?%".split(""), (p) => [p, punctuation(p)]))
+}, prefixedOrWord);
+const lexer = Compiler.jit(Parser.seq(Parser.repeat(Parser.preceded(skip$1, Parser.withSpan(Parser.backtrack(token)).pipe(Parser.map(([t, { start, end }]) => make(t, start, end))))), Parser.preceded(skip$1, Parser.location)));
+/** Why no token could be read at `offset` (the messages of the ShEx 2 lexer). */
+const describe = (input, offset) => {
+	const c = input.charAt(offset);
+	if (c === "<") return "invalid IRI reference";
+	if (c === "/") return "invalid regular expression";
+	if (c === "\"" || c === "'") return "invalid string literal";
+	const w = /^[A-Za-z]+/.exec(input.slice(offset, offset + 64));
+	if (w !== null) return `unexpected word "${w[0]}"`;
+	return `invalid character ${quote(String.fromCodePoint(input.codePointAt(offset) ?? 0))}`;
+};
+/**
+* Splits a document into tokens. Where no token can be read, the tokens end
+* with an `ERROR` token whose text says why; no grammar rule accepts it, so
+* the parser reports it if it gets that far, as a lazy lexer would.
+*/
+const tokenize = (input) => {
+	const peeked = Parser.parsePeek(lexer, input);
+	if (Result.isFailure(peeked)) throw peeked.failure;
+	const [, [tokens, end]] = peeked.success;
+	if (end < input.length) tokens.push(make({
+		type: "ERROR",
+		text: describe(input, end)
+	}, end, end));
+	return tokens;
+};
+const skip = () => 0;
+/**
+* Resolves the IRIs of `tokens` in place, in document order: IRI references
+* against the base, and prefixed names against the prefixes, both as set by
+* the `BASE` and `PREFIX` directives met so far. The prefix name declared by
+* a `PREFIX` directive is left alone. A prefixed name with an unknown prefix
+* gets an `error`, which the parser reports when it reads the name.
+*/
+const resolve = (tokens, baseIri, initialPrefixes) => {
+	let base = baseIri;
+	let prefixes = initialPrefixes;
+	const resolveRef = (iri) => Option.isNone(base) || isAbsolute(iri) ? iri : resolve$1(iri, base.value);
+	const expand = (t) => {
+		const ns = get(prefixes, t.text);
+		if (Option.isNone(ns)) {
+			t.error = Option.some(`unknown prefix "${t.text}:"`);
+			return false;
+		}
+		t.iri = ns.value + t.iri;
+		return true;
+	};
+	const resolveIri = (t) => {
+		t.iri = resolveRef(t.iri);
+		return 0;
+	};
+	const expandName = (t) => {
+		expand(t);
+		return 0;
+	};
+	const directive = (t, i) => {
+		const next = tokens[i + 1];
+		if (t.text === "BASE" && next?.type === "IRIREF") {
+			next.iri = resolveRef(next.iri);
+			base = Option.some(next.iri);
+			return 1;
+		}
+		if (t.text === "PREFIX" && next?.type === "PNAME" && next.iri === "") {
+			const value = tokens[i + 2];
+			if (value?.type === "IRIREF") value.iri = resolveRef(value.iri);
+			else if (value?.type !== "PNAME" || !expand(value)) return 0;
+			prefixes = set(prefixes, next.text, value.iri);
+			return 2;
+		}
+		return 0;
+	};
+	const stepOf = Match.type().pipe(Match.withReturnType(), Match.when("IRIREF", () => resolveIri), Match.when(Match.is("PNAME", "ATPNAME"), () => expandName), Match.when("KEYWORD", () => directive), Match.orElse(() => skip));
+	const steps = {};
+	Arr.reduce(tokens, 0, (consumed, t, i) => consumed > 0 ? consumed - 1 : (steps[t.type] ??= stepOf(t.type))(t, i));
+	return {
+		baseIri: base,
+		prefixes
+	};
+};
+// src/shex/internal/shexcParser.ts
+/**
+* The ShEx compact syntax (ShExC) parser, producing ShExJ. It is written
+* with `@thomasfosterau/effect-parse` as a compiled grammar over the tokens
+* of `shexcLexer.ts` (whose IRIs are already resolved), followed by a pass
+* over the declarations in document order for the checks that depend on
+* what was declared before (duplicate labels, shape and triple expression
+* labels). The construction of ShExJ objects mirrors the reference grammar
+* (shex.js `ShExJison.jison`) so that the output matches the ShExJ
+* representations of the shexTest suite.
+*
+* Like the reference grammar, the parser is LL(1): every choice is made by
+* dispatching on the kind of the next token (and committing to it), never by
+* trying alternatives in turn.
+*
+* @internal
+*/
+const RDF_TYPE$1 = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type";
+const XSD$1 = "http://www.w3.org/2001/XMLSchema#";
+const XSD_INTEGER = `${XSD$1}integer`;
+const XSD_DECIMAL = `${XSD$1}decimal`;
+const XSD_DOUBLE = `${XSD$1}double`;
+const XSD_FLOAT = `${XSD$1}float`;
+const XSD_BOOLEAN = `${XSD$1}boolean`;
+const numericDatatypes = MutableHashSet.fromIterable([
+	"integer",
+	"decimal",
+	"float",
+	"double",
+	"string",
+	"boolean",
+	"dateTime",
+	"nonPositiveInteger",
+	"negativeInteger",
+	"long",
+	"int",
+	"short",
+	"byte",
+	"nonNegativeInteger",
+	"unsignedLong",
+	"unsignedInt",
+	"unsignedShort",
+	"unsignedByte",
+	"positiveInteger"
+].map((l) => XSD$1 + l));
+const numericFacetNames = [
+	"mininclusive",
+	"minexclusive",
+	"maxinclusive",
+	"maxexclusive"
+];
+/** A placeholder for the empty shape `.` / `{ }` (omitted as a value expression). */
+const EMPTY = { type: "Shape" };
+/** A token of the given kind (see `Tok.kind`). */
+const tok = (kind, label = `'${kind}'`) => Token.oneOf((t) => t.kind === kind).pipe(Parser.expected(label));
+const anyToken = Token.oneOf(() => true);
+const nextKind = Parser.peek(anyToken).pipe(Parser.map((t) => t.kind));
+/**
+* Chooses a parser by the kind of the next token, failing (without consuming
+* input) when no case matches and there is no `otherwise`.
+*/
+const select = (label, cases, otherwise) => {
+	const record = Record.fromEntries(Arr.flatMap(Arr.reverse(cases), ([kinds, p]) => Arr.map(kinds, (k) => [k, p])));
+	return (otherwise === void 0 ? Parser.dispatch(nextKind, record) : Parser.dispatch(nextKind, record, otherwise)).pipe(Parser.expected(label));
+};
+/** Fails with a semantic error at token index `at`. */
+const failAt = (message, at) => Result.fail({
+	message,
+	at
+});
+/** Whether the next token is of one of `kinds` (consumed if so). */
+const accept = (...kinds) => Parser.opt(Token.oneOf((t) => kinds.includes(t.kind))).pipe(Parser.map(Option.isSome));
+const IRI_KINDS = ["IRIREF", "PNAME"];
+/** The IRI of a resolved token (at token index `at`), or its resolution error. */
+const tokenIri = (t, at) => Option.isNone(t.error) ? Result.succeed(t.iri) : failAt(t.error.value, at);
+/** The IRI of an IRIREF or PNAME token, or the token's resolution error. */
+const iri = Parser.seq(Parser.location, Token.oneOf((t) => t.kind === "IRIREF" || t.kind === "PNAME")).pipe(Parser.tryMap(([at, t]) => tokenIri(t, at)), Parser.cut, Parser.expected("an IRI"));
+const blankNode = tok("BLANK_NODE_LABEL", "a blank node").pipe(Parser.map((t) => t.text));
+/** shapeExprLabel / tripleExprLabel: iri | blankNode */
+const label = select("an IRI or a blank node", [[IRI_KINDS, iri], [["BLANK_NODE_LABEL"], blankNode]]);
+const predicate = select("a predicate", [[["a"], anyToken.pipe(Parser.as(RDF_TYPE$1))], [IRI_KINDS, iri]]);
+const LITERAL_KINDS = [
+	"STRING",
+	"LANG_STRING",
+	"INTEGER",
+	"DECIMAL",
+	"DOUBLE",
+	"true",
+	"false"
+];
+const literal = select("a literal", [
+	[["INTEGER"], anyToken.pipe(Parser.map((t) => ({
+		value: t.text,
+		type: XSD_INTEGER
+	})))],
+	[["DECIMAL"], anyToken.pipe(Parser.map((t) => ({
+		value: t.text,
+		type: XSD_DECIMAL
+	})))],
+	[["DOUBLE"], anyToken.pipe(Parser.map((t) => ({
+		value: t.text,
+		type: XSD_DOUBLE
+	})))],
+	[["LANG_STRING"], anyToken.pipe(Parser.map((t) => ({
+		value: t.text,
+		language: t.suffix.toLowerCase()
+	})))],
+	[["STRING"], Parser.seq(anyToken, Parser.opt(Parser.preceded(tok("^^"), Parser.cut(iri)))).pipe(Parser.map(([t, datatype]) => Option.isSome(datatype) ? {
+		value: t.text,
+		type: datatype.value
+	} : { value: t.text }))],
+	[["true", "false"], anyToken.pipe(Parser.map((t) => ({
+		value: t.text,
+		type: XSD_BOOLEAN
+	})))]
+]);
+const plain = (e) => ({
+	e,
+	nested: false
+});
+const isJunction = (e) => !Predicate.isString(e) && (e.type === "ShapeAnd" || e.type === "ShapeOr");
+const junction = (type, atom, juncts) => {
+	if (Arr.isReadonlyArrayEmpty(juncts)) return atom.e;
+	const e = atom.e;
+	if (isJunction(e) && e.type === type && !atom.nested) return {
+		...e,
+		shapeExprs: e.shapeExprs.concat(juncts)
+	};
+	return {
+		type,
+		shapeExprs: [e, ...juncts]
+	};
+};
+const isAndRest = Predicate.isTagged("And");
+const prepend = (rest, atoms) => {
+	if (!isAndRest(rest)) return {
+		type: "ShapeOr",
+		shapeExprs: [...atoms, ...rest.ors]
+	};
+	const and = {
+		type: "ShapeAnd",
+		shapeExprs: [...atoms, ...rest.ands]
+	};
+	return Arr.isReadonlyArrayNonEmpty(rest.ors) ? {
+		type: "ShapeOr",
+		shapeExprs: [and, ...rest.ors]
+	} : and;
+};
+const prependAtom = (atom, rest) => Option.match(rest, {
+	onNone: () => atom.e,
+	onSome: (r) => {
+		const e = atom.e;
+		return !Predicate.isString(e) && e.type === "ShapeAnd" && isAndRest(r) && Arr.isReadonlyArrayEmpty(r.ors) && !atom.nested ? prepend(r, e.shapeExprs) : prepend(r, [e]);
+	}
+});
+const annotations = Parser.repeat(Parser.preceded(tok("//"), Parser.cut(Parser.seq(predicate, select("an IRI or a literal", [[IRI_KINDS, iri]], literal)).pipe(Parser.map(([pred, object]) => ({
+	type: "Annotation",
+	predicate: pred,
+	object
+}))))));
+const codeDecls = Parser.repeat(Parser.preceded(tok("%"), Parser.cut(Parser.seq(iri, select("code or %", [[["CODE"], anyToken.pipe(Parser.map((t) => Option.some(t.text)))], [["%"], anyToken.pipe(Parser.as(Option.none()))]])).pipe(Parser.map(([name, code]) => Option.match(code, {
+	onNone: () => ({
+		type: "SemAct",
+		name
+	}),
+	onSome: (c) => ({
+		type: "SemAct",
+		name,
+		code: c
+	})
+}))))), { min: 1 });
+const semanticActions = Parser.opt(codeDecls);
+const cardinality = Parser.opt(select("a cardinality", [
+	[["*"], anyToken.pipe(Parser.as({
+		min: 0,
+		max: -1
+	}))],
+	[["+"], anyToken.pipe(Parser.as({
+		min: 1,
+		max: -1
+	}))],
+	[["?"], anyToken.pipe(Parser.as({
+		min: 0,
+		max: 1
+	}))],
+	[["REPEAT_RANGE"], anyToken.pipe(Parser.map((t) => ({
+		min: t.min,
+		max: t.max
+	})))]
+]));
+const integer = Parser.cut(tok("INTEGER", "an integer")).pipe(Parser.map((t) => parseInt(t.text, 10)));
+const rawNumeric = select("a numeric literal", [
+	[["INTEGER"], anyToken.pipe(Parser.map((t) => parseInt(t.text, 10)))],
+	[["DECIMAL", "DOUBLE"], anyToken.pipe(Parser.map((t) => parseFloat(t.text)))],
+	[["STRING"], Parser.seq(anyToken, Parser.cut(Parser.preceded(tok("^^"), Parser.seq(Parser.location, iri)))).pipe(Parser.tryMap(([t, [at, dt]]) => {
+		const value = t.text;
+		if (dt === XSD_DECIMAL || dt === XSD_FLOAT || dt === XSD_DOUBLE) return Result.succeed(parseFloat(value));
+		if (MutableHashSet.has(numericDatatypes, dt)) return Result.succeed(parseInt(value, 10));
+		return failAt(`numeric range facet expected numeric datatype instead of ${dt}`, at);
+	}), Parser.cut)]
+]);
+const LENGTH_FACETS = [
+	"LENGTH",
+	"MINLENGTH",
+	"MAXLENGTH"
+];
+const DIGITS_FACETS = ["TOTALDIGITS", "FRACTIONDIGITS"];
+const RANGE_FACETS = [
+	"MININCLUSIVE",
+	"MINEXCLUSIVE",
+	"MAXINCLUSIVE",
+	"MAXEXCLUSIVE"
+];
+const NUMERIC_FACETS = [...DIGITS_FACETS, ...RANGE_FACETS];
+const integerFacet = Parser.seq(Parser.location, anyToken, integer).pipe(Parser.map(([at, t, n]) => [
+	t.text.toLowerCase(),
+	n,
+	at
+]));
+const stringFacetCases = [[["REGEXP"], Parser.seq(Parser.location, anyToken).pipe(Parser.map(([at, t]) => [
+	"pattern",
+	t.text,
+	at,
+	t.suffix
+]))], [LENGTH_FACETS, integerFacet]];
+const numericFacetCases = [[DIGITS_FACETS, integerFacet], [RANGE_FACETS, Parser.seq(Parser.location, anyToken, Parser.cut(rawNumeric)).pipe(Parser.map(([at, t, n]) => [
+	t.text.toLowerCase(),
+	n,
+	at
+]))]];
+const noFacets = () => Result.succeed({});
+const facets = (strings, numerics) => Parser.repeat(select("a facet", [...strings ? stringFacetCases : [], ...numerics ? numericFacetCases : []])).pipe(Parser.tryMap((list) => Arr.reduce(list, noFacets(), (acc, [key, value, at, flags]) => Result.flatMap(acc, (out) => {
+	if (key in out) return failAt(`facet ${key} defined multiple times`, at);
+	out[key] = value;
+	if (flags !== void 0 && flags !== "") out["flags"] = flags;
+	return Result.succeed(out);
+}))), Parser.cut);
+const tilde = accept("~");
+const exclusion = (p) => Parser.preceded(tok("-"), Parser.cut(p));
+const iriExclusion = exclusion(Parser.seq(iri, tilde).pipe(Parser.map(([base, stem]) => stem ? {
+	type: "IriStem",
+	stem: base
+} : base)));
+const literalExclusion = exclusion(Parser.seq(literal, tilde).pipe(Parser.map(([lit, stem]) => stem ? {
+	type: "LiteralStem",
+	stem: lit.value
+} : lit.value)));
+const langTag = tok("LANGTAG", "a language tag").pipe(Parser.map((t) => t.text));
+const languageExclusion = exclusion(Parser.seq(langTag, tilde).pipe(Parser.map(([tag, stem]) => stem ? {
+	type: "LanguageStem",
+	stem: tag
+} : tag)));
+const stemmed = (head, exclude, build) => Parser.seq(head, Parser.opt(Parser.preceded(tok("~"), Parser.repeat(exclude)))).pipe(Parser.map(([h, exclusions]) => build(h, Option.isSome(exclusions), Option.getOrElse(exclusions, () => []))));
+/** The exclusions after a `.` wildcard: their kind is chosen by the first one. */
+const wildcardExclusions = Parser.preceded(Parser.peek(tok("-")), Parser.dispatch(Parser.peek(Parser.preceded(anyToken, anyToken)).pipe(Parser.map((t) => t.kind)), {
+	LANGTAG: Parser.repeat(languageExclusion).pipe(Parser.map((exclusions) => ({
+		type: "LanguageStemRange",
+		stem: { type: "Wildcard" },
+		exclusions
+	}))),
+	...Record.fromEntries(Arr.map(IRI_KINDS, (k) => [k, Parser.repeat(iriExclusion).pipe(Parser.map((exclusions) => ({
+		type: "IriStemRange",
+		stem: { type: "Wildcard" },
+		exclusions
+	})))]))
+}, Parser.repeat(literalExclusion).pipe(Parser.map((exclusions) => ({
+	type: "LiteralStemRange",
+	stem: { type: "Wildcard" },
+	exclusions
+}))))).pipe(Parser.expected("'-'"));
+const valueSetValue = select("a value set value", [
+	[IRI_KINDS, Parser.cut(stemmed(iri, iriExclusion, (stem, isStem, exclusions) => !isStem ? stem : Arr.isReadonlyArrayNonEmpty(exclusions) ? {
+		type: "IriStemRange",
+		stem,
+		exclusions
+	} : {
+		type: "IriStem",
+		stem
+	}))],
+	[LITERAL_KINDS, Parser.cut(stemmed(literal, literalExclusion, (lit, isStem, exclusions) => !isStem ? lit : Arr.isReadonlyArrayNonEmpty(exclusions) ? {
+		type: "LiteralStemRange",
+		stem: lit.value,
+		exclusions
+	} : {
+		type: "LiteralStem",
+		stem: lit.value
+	}))],
+	[["LANGTAG"], Parser.cut(stemmed(langTag, languageExclusion, (tag, isStem, exclusions) => !isStem ? {
+		type: "Language",
+		languageTag: tag
+	} : Arr.isReadonlyArrayNonEmpty(exclusions) ? {
+		type: "LanguageStemRange",
+		stem: tag,
+		exclusions
+	} : {
+		type: "LanguageStem",
+		stem: tag
+	}))],
+	[["@"], Parser.preceded(anyToken, Parser.cut(Parser.preceded(tok("~"), Parser.repeat(languageExclusion)))).pipe(Parser.map((exclusions) => Arr.isReadonlyArrayNonEmpty(exclusions) ? {
+		type: "LanguageStemRange",
+		stem: "",
+		exclusions
+	} : {
+		type: "LanguageStem",
+		stem: ""
+	}))],
+	[["."], Parser.preceded(anyToken, Parser.cut(wildcardExclusions))]
+]);
+const valueSet = Parser.delimited(tok("["), Parser.cut(Parser.repeat(valueSetValue)), Parser.cut(tok("]")));
+const litInlineNodeConstraint = select("a node constraint", [
+	[["LITERAL"], Parser.preceded(anyToken, facets(true, true)).pipe(Parser.map((f) => ({
+		type: "NodeConstraint",
+		nodeKind: "literal",
+		...f
+	})))],
+	[IRI_KINDS, Parser.seq(Parser.location, iri, facets(true, true)).pipe(Parser.tryMap(([at, datatype, f]) => Option.match(MutableHashSet.has(numericDatatypes, datatype) ? Option.none() : Arr.findFirst(numericFacetNames, (name) => name in f), {
+		onNone: () => Result.succeed({
+			type: "NodeConstraint",
+			datatype,
+			...f
+		}),
+		onSome: (name) => failAt(`facet ${name} not allowed for unknown datatype ${datatype}`, at)
+	})), Parser.cut)],
+	[["["], Parser.terminated(valueSet, facets(true, true)).pipe(Parser.map((values) => ({
+		type: "NodeConstraint",
+		values
+	})))],
+	[NUMERIC_FACETS, facets(false, true).pipe(Parser.map((f) => ({
+		type: "NodeConstraint",
+		...f
+	})))]
+]);
+const NODE_KINDS = [
+	"IRI",
+	"BNODE",
+	"NONLITERAL"
+];
+const NON_LIT_KINDS = [
+	...NODE_KINDS,
+	"LENGTH",
+	"MINLENGTH",
+	"MAXLENGTH",
+	"REGEXP"
+];
+const LIT_KINDS = [
+	"LITERAL",
+	...NUMERIC_FACETS,
+	...IRI_KINDS,
+	"["
+];
+const nodeKindOf = (kind) => kind === "IRI" ? "iri" : kind === "BNODE" ? "bnode" : "nonliteral";
+const nonLitInlineNodeConstraint = Parser.seq(Parser.opt(select("a node kind", [[NODE_KINDS, anyToken.pipe(Parser.map((t) => t.text))]])), facets(true, false)).pipe(Parser.map(([kind, f]) => Option.isSome(kind) ? {
+	type: "NodeConstraint",
+	nodeKind: nodeKindOf(kind.value),
+	...f
+} : {
+	type: "NodeConstraint",
+	...f
+}));
+/** A non-literal node constraint, if one starts here. */
+const nonLitNodeConstraintOpt = Parser.opt(select("a node constraint", [[NON_LIT_KINDS, Parser.cut(nonLitInlineNodeConstraint)]]));
+const withAnnotations = (nc) => Parser.seq(nc, annotations, semanticActions).pipe(Parser.map(([constraint, annots, semActs]) => {
+	if (Arr.isReadonlyArrayEmpty(annots) && Option.isNone(semActs)) return constraint;
+	const out = constraint;
+	if (Arr.isReadonlyArrayNonEmpty(annots)) out.annotations = annots;
+	if (Option.isSome(semActs)) out.semActs = semActs.value;
+	return out;
+}));
+/** A non-literal node constraint with its annotations, if one starts here. */
+const annotatedNonLitNodeConstraintOpt = Parser.opt(select("a node constraint", [[NON_LIT_KINDS, Parser.cut(withAnnotations(nonLitInlineNodeConstraint))]]));
+const REF_KINDS = ["ATPNAME", "@"];
+const SHAPE_DEF_KINDS = [
+	"{",
+	"&",
+	"EXTENDS",
+	"EXTRA",
+	"CLOSED"
+];
+const shapeRef = select("a shape reference", [[["ATPNAME"], Parser.seq(Parser.location, anyToken).pipe(Parser.tryMap(([at, t]) => tokenIri(t, at)), Parser.cut)], [["@"], Parser.preceded(anyToken, Parser.cut(label))]]);
+const shapeExpressionBody = Parser.suspend(() => shapeExpressionBodyDef);
+const tripleExpression = Parser.suspend(() => tripleExpressionDef);
+const extendsShapeOr = Parser.suspend(() => extendsShapeOrDef);
+const inlineShapeExpression = Parser.suspend(() => inlineShapeExpressionDef);
+const parenthesised = Parser.delimited(anyToken, Parser.cut(shapeExpressionBody), Parser.cut(tok(")"))).pipe(Parser.map((e) => ({
+	e,
+	nested: true
+})));
+const empty = anyToken.pipe(Parser.as(plain(EMPTY)));
+const inlineShapeDefinition = Parser.seq(Parser.repeat(select("a shape qualifier", [
+	[["EXTENDS", "&"], Parser.preceded(anyToken, Parser.cut(extendsShapeOr)).pipe(Parser.map((e) => ({
+		_tag: "Extends",
+		e
+	})))],
+	[["EXTRA"], Parser.preceded(anyToken, Parser.cut(Parser.repeat(predicate, { min: 1 }))).pipe(Parser.map((predicates) => ({
+		_tag: "Extra",
+		predicates
+	})))],
+	[["CLOSED"], anyToken.pipe(Parser.as({ _tag: "Closed" }))]
+])), Parser.delimited(Parser.cut(tok("{")), select("a triple expression", [[["}"], Parser.succeed(Option.none())]], Parser.cut(tripleExpression).pipe(Parser.map(Option.some))), Parser.cut(tok("}")))).pipe(Parser.map(([qualifiers, expression]) => {
+	if (Option.isNone(expression) && Arr.isReadonlyArrayEmpty(qualifiers)) return EMPTY;
+	const extendsList = Arr.filterMap(qualifiers, (q) => Predicate.isTagged(q, "Extends") ? Result.succeed(q.e) : Result.failVoid);
+	const extra = Arr.flatMap(qualifiers, (q) => Predicate.isTagged(q, "Extra") ? q.predicates : []);
+	const shape = { type: "Shape" };
+	if (Option.isSome(expression)) shape.expression = expression.value;
+	if (Arr.isReadonlyArrayNonEmpty(extendsList)) shape.extends = extendsList;
+	if (Arr.some(qualifiers, (q) => Predicate.isTagged(q, "Extra"))) shape.extra = extra;
+	if (Arr.some(qualifiers, (q) => Predicate.isTagged(q, "Closed"))) shape.closed = true;
+	return shape;
+}));
+const shapeDefinition = Parser.seq(inlineShapeDefinition, annotations, semanticActions).pipe(Parser.map(([def, annots, semActs]) => {
+	const out = def === EMPTY ? { type: "Shape" } : def;
+	if (Arr.isReadonlyArrayNonEmpty(annots)) out.annotations = annots;
+	if (Option.isSome(semActs)) out.semActs = semActs.value;
+	return out;
+}));
+const shapeOrRef = select("a shape definition or reference", [[REF_KINDS, shapeRef]], shapeDefinition);
+const inlineShapeOrRef = select("a shape definition or reference", [[REF_KINDS, shapeRef]], inlineShapeDefinition);
+/** A shape definition or reference, if one starts here. */
+const shapeOrRefOpt = (p) => Parser.opt(select("a shape definition or reference", [[[...SHAPE_DEF_KINDS, ...REF_KINDS], Parser.cut(p)]]));
+/** A node constraint, conjoined with the shape definition or reference after it if any. */
+const andRef = (nc, ref) => Option.isSome(ref) ? {
+	type: "ShapeAnd",
+	shapeExprs: [{ ...nc }, ref.value]
+} : nc;
+/** shapeAtom (with `allowRef`) and shapeAtomNoRef. */
+const shapeAtom = (allowRef) => select("a shape expression", [
+	[NON_LIT_KINDS, Parser.cut(Parser.seq(withAnnotations(nonLitInlineNodeConstraint), shapeOrRefOpt(shapeOrRef)).pipe(Parser.map(([nc, ref]) => plain(andRef(nc, ref)))))],
+	[LIT_KINDS, Parser.cut(withAnnotations(litInlineNodeConstraint)).pipe(Parser.map(plain))],
+	[allowRef ? [...SHAPE_DEF_KINDS, ...REF_KINDS] : SHAPE_DEF_KINDS, Parser.cut(Parser.seq(shapeOrRef, annotatedNonLitNodeConstraintOpt).pipe(Parser.map(([sor, nc]) => plain(Option.match(nc, {
+		onNone: () => sor,
+		onSome: (c) => junction("ShapeAnd", plain(sor), [c])
+	})))))],
+	[["("], parenthesised],
+	[["."], empty]
+]);
+const shapeNot = select("a shape expression", [[["NOT"], Parser.preceded(anyToken, Parser.cut(shapeAtom(true))).pipe(Parser.map((a) => plain({
+	type: "ShapeNot",
+	shapeExpr: a.e
+})))]], shapeAtom(true));
+const shapeAnd = Parser.seq(shapeNot, Parser.repeat(Parser.preceded(tok("AND"), Parser.cut(shapeNot)))).pipe(Parser.map(([first, rest]) => junction("ShapeAnd", first, rest.map((a) => a.e))));
+const ors = Parser.repeat(Parser.preceded(tok("OR"), Parser.cut(shapeAnd)));
+const shapeOrRest = select("'AND' or 'OR'", [[["OR"], ors.pipe(Parser.map((operands) => ({
+	_tag: "Or",
+	ors: operands
+})))], [["AND"], Parser.seq(Parser.repeat(Parser.preceded(tok("AND"), Parser.cut(shapeNot))), ors).pipe(Parser.map(([conjuncts, operands]) => ({
+	_tag: "And",
+	ands: Arr.flatMap(conjuncts, (c) => !Predicate.isString(c.e) && c.e.type === "ShapeAnd" && !c.nested ? c.e.shapeExprs : [c.e]),
+	ors: operands
+})))]]);
+/**
+* shapeExpression ::= NOT? shapeAtomNoRef shapeOr? | NOT shapeRef shapeOr? | shapeRef shapeOr
+*/
+const shapeExpressionBodyDef = select("a shape expression", [[["NOT"], Parser.preceded(anyToken, Parser.cut(select("a shape expression", [[REF_KINDS, Parser.seq(shapeRef, Parser.opt(shapeOrRest)).pipe(Parser.map(([ref, rest]) => prependAtom(plain({
+	type: "ShapeNot",
+	shapeExpr: ref
+}), rest)))]], Parser.seq(shapeAtom(false), Parser.opt(shapeOrRest)).pipe(Parser.map(([a, rest]) => prependAtom(plain({
+	type: "ShapeNot",
+	shapeExpr: a.e
+}), rest))))))], [REF_KINDS, Parser.seq(shapeRef, Parser.cut(shapeOrRest)).pipe(Parser.map(([ref, rest]) => prepend(rest, [ref])))]], Parser.seq(shapeAtom(false), Parser.opt(shapeOrRest)).pipe(Parser.map(([a, rest]) => prependAtom(a, rest))));
+/** The atoms of inline and EXTENDS shape expressions, which differ in one case. */
+const inlineAtom = (extendsAtom) => select("a shape expression", [
+	[NON_LIT_KINDS, Parser.cut(extendsAtom ? Parser.seq(nonLitInlineNodeConstraint, inlineShapeOrRef).pipe(Parser.map(([nc, ref]) => plain({
+		type: "ShapeAnd",
+		shapeExprs: [{ ...nc }, ref]
+	}))) : Parser.seq(nonLitInlineNodeConstraint, shapeOrRefOpt(inlineShapeOrRef)).pipe(Parser.map(([nc, ref]) => plain(andRef(nc, ref)))))],
+	[LIT_KINDS, Parser.cut(litInlineNodeConstraint).pipe(Parser.map(plain))],
+	[[...SHAPE_DEF_KINDS, ...REF_KINDS], Parser.cut(Parser.seq(inlineShapeOrRef, nonLitNodeConstraintOpt).pipe(Parser.map(([sor, nc]) => plain(Option.match(nc, {
+		onNone: () => sor,
+		onSome: (c) => ({
+			type: "ShapeAnd",
+			shapeExprs: [sor, c]
+		})
+	})))))],
+	[["("], parenthesised],
+	[["."], empty]
+]);
+const junctions = (atom) => {
+	const not = select("a shape expression", [[["NOT"], Parser.preceded(anyToken, Parser.cut(atom)).pipe(Parser.map((a) => plain({
+		type: "ShapeNot",
+		shapeExpr: a.e
+	})))]], atom);
+	const and = Parser.seq(not, Parser.repeat(Parser.preceded(tok("AND"), Parser.cut(not)))).pipe(Parser.map(([first, rest]) => junction("ShapeAnd", first, rest.map((a) => a.e))));
+	return Parser.seq(and, Parser.repeat(Parser.preceded(tok("OR"), Parser.cut(and)))).pipe(Parser.map(([first, rest]) => junction("ShapeOr", plain(first), rest)));
+};
+const inlineShapeExpressionDef = junctions(inlineAtom(false));
+const extendsShapeOrDef = junctions(inlineAtom(true));
+/** The token index of the label of each labelled triple expression. */
+const labelAt = /* @__PURE__ */ new WeakMap();
+const tripleConstraint = Parser.seq(accept("^"), predicate, inlineShapeExpression, cardinality, annotations, semanticActions).pipe(Parser.map(([inverse, pred, valueExpr, card, annots, semActs]) => {
+	const tc = inverse ? {
+		type: "TripleConstraint",
+		inverse: true,
+		predicate: pred
+	} : {
+		type: "TripleConstraint",
+		predicate: pred
+	};
+	if (valueExpr !== EMPTY) tc.valueExpr = valueExpr;
+	if (Option.isSome(card)) {
+		tc.min = card.value.min;
+		tc.max = card.value.max;
+	}
+	if (Option.isSome(semActs)) tc.semActs = semActs.value;
+	if (Arr.isReadonlyArrayNonEmpty(annots)) tc.annotations = annots;
+	return tc;
+}));
+const bracketedOrConstraint = select("a triple expression", [[["("], Parser.seq(Parser.location, Parser.delimited(anyToken, Parser.cut(tripleExpression), Parser.cut(tok(")"))), cardinality, annotations, semanticActions).pipe(Parser.tryMap(([at, expr, card, annots, semActs]) => {
+	if (Option.isNone(card) && Arr.isReadonlyArrayEmpty(annots) && Option.isNone(semActs)) return Result.succeed(expr);
+	if (Predicate.isString(expr)) return failAt(`a group containing only the inclusion &<${expr}> can't take a cardinality, an annotation or a semantic action`, at);
+	const out = Option.isSome(card) && expr.type === "TripleConstraint" && (expr.min !== void 0 || expr.max !== void 0) ? {
+		type: "EachOf",
+		expressions: [expr]
+	} : expr;
+	if (Option.isSome(card)) {
+		out.min = card.value.min;
+		out.max = card.value.max;
+	}
+	if (Arr.isReadonlyArrayNonEmpty(annots)) out.annotations = annots;
+	if (Option.isSome(semActs)) out.semActs = [...out.semActs ?? [], ...semActs.value];
+	return Result.succeed(out);
+}), Parser.cut)]], tripleConstraint);
+const UNARY_KINDS = [
+	"$",
+	"&",
+	"(",
+	"^",
+	"a",
+	...IRI_KINDS
+];
+const unaryTripleExpr = select("a triple expression", [
+	[["&"], Parser.preceded(anyToken, Parser.cut(label))],
+	[["$"], Parser.seq(Parser.preceded(anyToken, Parser.cut(Parser.seq(Parser.location, label))), Parser.cut(bracketedOrConstraint)).pipe(Parser.tryMap(([[at, id], expr]) => {
+		if (Predicate.isString(expr)) return failAt(`a group containing only the inclusion &<${expr}> can't take a label`, at);
+		const labelled = {
+			id,
+			...expr
+		};
+		labelAt.set(labelled, at);
+		return Result.succeed(labelled);
+	}), Parser.cut)],
+	[[
+		"(",
+		"^",
+		"a",
+		...IRI_KINDS
+	], Parser.cut(bracketedOrConstraint)]
+]);
+const separator = select("; or ,", [[[";", ","], anyToken]]);
+const groupTripleExpr = Parser.terminated(Parser.seq(unaryTripleExpr, Parser.repeat(Parser.preceded(separator, select("a triple expression", [[UNARY_KINDS, unaryTripleExpr]])))), Parser.opt(separator)).pipe(Parser.map(([first, rest]) => Arr.isReadonlyArrayEmpty(rest) ? first : {
+	type: "EachOf",
+	expressions: [first, ...rest]
+}));
+const tripleExpressionDef = Parser.seq(groupTripleExpr, Parser.repeat(Parser.preceded(tok("|"), Parser.cut(groupTripleExpr)))).pipe(Parser.map(([first, rest]) => Arr.isReadonlyArrayEmpty(rest) ? first : {
+	type: "OneOf",
+	expressions: [first, ...rest]
+}));
+const noStatement = Option.none();
+const directiveCases = [
+	[["BASE"], Parser.preceded(anyToken, Parser.cut(tok("IRIREF", "an IRI reference"))).pipe(Parser.as(noStatement))],
+	[["PREFIX"], Parser.preceded(anyToken, Parser.cut(Parser.seq(Token.oneOf((t) => t.type === "PNAME" && t.iri === "").pipe(Parser.expected("a prefix name")), iri))).pipe(Parser.as(noStatement))],
+	[["IMPORT"], Parser.preceded(anyToken, Parser.cut(iri)).pipe(Parser.map((base) => Option.some({
+		_tag: "Import",
+		iri: base
+	})))]
+];
+const directive = select("a directive", directiveCases);
+const startDecl = Parser.seq(Parser.location, Parser.preceded(anyToken, Parser.cut(Parser.preceded(tok("="), Parser.seq(shapeAnd, ors))))).pipe(Parser.map(([at, [first, rest]]) => ({
+	_tag: "Start",
+	expr: junction("ShapeOr", plain(first), rest),
+	at
+})));
+const shapeExprDecl = Parser.seq(accept("ABSTRACT"), Parser.location, label, Parser.repeat(Parser.preceded(select("'RESTRICTS' or '-'", [[["RESTRICTS", "-"], anyToken]]), Parser.cut(shapeOrRef))), select("a shape expression", [[["EXTERNAL"], anyToken.pipe(Parser.as({ type: "ShapeExternal" }))], [REF_KINDS, Parser.seq(shapeRef, Parser.opt(shapeOrRest)).pipe(Parser.map(([ref, rest]) => Option.match(rest, {
+	onNone: () => ref,
+	onSome: (r) => prepend(r, [ref])
+})))]], shapeExpressionBody)).pipe(Parser.map(([abstract, at, name, restricts, body]) => {
+	const decl = {
+		type: "ShapeDecl",
+		id: name,
+		shapeExpr: body === EMPTY ? { type: "Shape" } : body
+	};
+	if (abstract) decl.abstract = true;
+	if (Arr.isReadonlyArrayNonEmpty(restricts)) decl.restricts = restricts;
+	return {
+		_tag: "Decl",
+		decl,
+		at
+	};
+}));
+const statement = select("a directive or shape declaration", [
+	...directiveCases,
+	[["START"], startDecl.pipe(Parser.map(Option.some))],
+	[[
+		"ABSTRACT",
+		"BLANK_NODE_LABEL",
+		...IRI_KINDS
+	], Parser.cut(shapeExprDecl).pipe(Parser.map(Option.some))]
+]);
+const document = Compiler.jit(Parser.terminated(Parser.seq(Parser.repeat(directive), Parser.opt(codeDecls), Parser.repeat(statement)), Parser.eof));
+const labelledShape = (s, f) => {
+	if (!Predicate.isString(s)) labelledShapeExpr(s, f);
+};
+const labelledTriple = (t, f) => {
+	if (Predicate.isString(t)) return;
+	if (t.type === "TripleConstraint") {
+		if (t.valueExpr !== void 0) labelledShape(t.valueExpr, f);
+	} else t.expressions.forEach((e) => labelledTriple(e, f));
+	if (t.id !== void 0) f(t, t.id);
+};
+const labelledShapeExpr = Match.fn((s, _f) => s).pipe(Match.when({ type: Match.is("ShapeOr", "ShapeAnd") }, (s, _s, f) => s.shapeExprs.forEach((e) => labelledShape(e, f))), Match.when({ type: "ShapeNot" }, (s, _s, f) => labelledShape(s.shapeExpr, f)), Match.when({ type: "Shape" }, (s, _s, f) => {
+	s.extends?.forEach((e) => labelledShape(e, f));
+	if (s.expression !== void 0) labelledTriple(s.expression, f);
+}), Match.orElse(() => void 0));
+/**
+* Calls `f` on each labelled triple expression of a shape expression, in
+* document order (each after the labelled expressions it contains).
+*/
+const eachLabelled = (e, f) => labelledShape(e, f);
+const assemble = (statements, startActs) => {
+	const imports = [];
+	const shapes = [];
+	const shapeIds = MutableHashSet.empty();
+	const productions = MutableHashSet.empty();
+	let error = Option.none();
+	const production = (t, id) => {
+		if (Option.isSome(error)) return;
+		const at = labelAt.get(t) ?? 0;
+		if (MutableHashSet.has(shapeIds, id)) error = Option.some({
+			message: `${id} is a shape expression`,
+			at
+		});
+		else if (MutableHashSet.has(productions, id)) error = Option.some({
+			message: `${id} already defined`,
+			at
+		});
+		else MutableHashSet.add(productions, id);
+	};
+	const step = (start, s) => {
+		if (Predicate.isTagged(s, "Import")) {
+			imports.push(s.iri);
+			return Result.succeed(start);
+		}
+		if (Predicate.isTagged(s, "Start")) {
+			if (Option.isSome(start)) return failAt("start already defined", s.at);
+			eachLabelled(s.expr, production);
+			return Option.isSome(error) ? Result.fail(error.value) : Result.succeed(Option.some(s.expr));
+		}
+		const { decl, at } = s;
+		decl.restricts?.forEach((r) => eachLabelled(r, production));
+		eachLabelled(decl.shapeExpr, production);
+		if (Option.isSome(error)) return Result.fail(error.value);
+		if (MutableHashSet.has(productions, decl.id)) return failAt(`${decl.id} is a triple expression`, at);
+		if (MutableHashSet.has(shapeIds, decl.id)) return failAt(`${decl.id} already defined`, at);
+		MutableHashSet.add(shapeIds, decl.id);
+		shapes.push(decl);
+		return Result.succeed(start);
+	};
+	const noStart = Result.succeed(Option.none());
+	return Arr.reduce(statements, noStart, (acc, s) => Result.flatMap(acc, (start) => step(start, s))).pipe(Result.map((start) => {
+		const schema = { type: "Schema" };
+		if (Arr.isReadonlyArrayNonEmpty(imports)) schema.imports = imports;
+		if (Option.isSome(startActs)) schema.startActs = startActs.value;
+		if (Option.isSome(start)) schema.start = start.value;
+		if (Arr.isReadonlyArrayNonEmpty(shapes)) schema.shapes = shapes;
+		return schema;
+	}));
+};
+const offsetOf = (tokens, input, at) => tokens[at]?.start ?? input.length;
+const grammarError = (input, tokens, error) => {
+	if (error.cause !== void 0) return {
+		message: error.cause.message,
+		offset: offsetOf(tokens, input, error.cause.at)
+	};
+	const t = tokens[error.offset];
+	if (t?.type === "ERROR") return {
+		message: t.text,
+		offset: t.start
+	};
+	const found = t === void 0 ? "end of input" : quote(input.slice(t.start, t.end));
+	const expected = ParseError.formatExpected(error.expected);
+	return {
+		message: expected === "" ? `unexpected ${found}` : `expected ${expected}, found ${found}`,
+		offset: offsetOf(tokens, input, error.offset)
+	};
+};
+/** Parses a ShExC document. Errors carry the character offset. */
+const parseShExC = (input, options) => {
+	const tokens = tokenize(input);
+	const resolved = resolve(tokens, options.baseIri, options.prefixes);
+	const parsed = Parser.parse(document, tokens);
+	if (Result.isFailure(parsed)) return Result.fail(grammarError(input, tokens, parsed.failure));
+	const [directives, startActs, statements] = parsed.success;
+	const schema = assemble(Arr.getSomes([...directives, ...statements]), startActs);
+	if (Result.isFailure(schema)) return Result.fail({
+		message: schema.failure.message,
+		offset: offsetOf(tokens, input, schema.failure.at)
+	});
+	return Result.succeed({
+		schema: schema.success,
+		prefixes: resolved.prefixes,
+		baseIri: resolved.baseIri
+	});
+};
+// src/shex/ShExC.ts
+/**
+* The ShEx compact syntax (ShExC): a hand-written parser producing ShExJ and
+* a printer from ShExJ back to ShExC.
+*
+* @since 0.1.0
+*/
+var ShExC_exports = /* @__PURE__ */ __exportAll({
+	parse: () => parse,
+	parseWithMetadata: () => parseWithMetadata,
+	print: () => print
+});
+const isPrefixMap = (prefixes) => "prefixes" in prefixes && prefixes.prefixes instanceof Map;
+const toPrefixMap = (prefixes) => prefixes === void 0 ? empty$1 : isPrefixMap(prefixes) ? prefixes : make$1(prefixes);
+/**
+* Parses a ShExC document, returning the schema together with its prefixes
+* and final base IRI.
+*
+* @since 0.1.0
+* @category parsing
+*/
+const parseWithMetadata = (input, options = {}) => Effect.suspend(() => {
+	const result = parseShExC(input, {
+		baseIri: Option.fromUndefinedOr(options.baseIri),
+		prefixes: toPrefixMap(options.prefixes)
+	});
+	if (Result.isFailure(result)) {
+		const { line, column } = lineColumn(input, result.failure.offset);
+		return Effect.fail(new RdfParseError({
+			format: "ShExC",
+			message: result.failure.message,
+			line,
+			column
+		}));
+	}
+	return Effect.succeed({
+		schema: result.success.schema,
+		prefixes: result.success.prefixes,
+		baseIri: Option.getOrUndefined(result.success.baseIri)
+	});
+});
+/**
+* Parses a ShExC document to a ShExJ schema.
+*
+* @since 0.1.0
+* @category parsing
+*/
+const parse = (input, options = {}) => Effect.map(parseWithMetadata(input, options), (r) => r.schema);
+const XSD = "http://www.w3.org/2001/XMLSchema#";
+const RDF_TYPE = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type";
+const escapeIri = (iri) => iri.replace(/[\u0000- <>"{}|^`\\]/g, (c) => `\\u${c.charCodeAt(0).toString(16).padStart(4, "0")}`);
+const escapeString = (s) => s.replace(/["\\\n\r\t\b\f]/g, (c) => c === "\"" ? "\\\"" : c === "\\" ? "\\\\" : c === "\n" ? "\\n" : c === "\r" ? "\\r" : c === "	" ? "\\t" : c === "\b" ? "\\b" : "\\f");
+const escapeRegexp = (s) => s.replace(/\//g, "\\/").replace(/\n/g, "\\n").replace(/\r/g, "\\r");
+const escapeCode = (s) => s.replace(/\\/g, "\\\\").replace(/%/g, "\\%");
+const quoteLiteral = (s) => `"${escapeString(s)}"`;
+/** A value without a string `type`, or with a `value`, is an object literal in ShExJ. */
+const isObjectLiteral = (v) => !Predicate.isString(v.type) || "value" in v;
+var Printer = class {
+	prefixes;
+	base;
+	unit;
+	constructor(options) {
+		this.prefixes = options.prefixes ?? empty$1;
+		this.base = Option.fromUndefinedOr(options.baseIri);
+		this.unit = options.indent ?? "  ";
+	}
+	iri(iri) {
+		return Option.match(compact(this.prefixes, iri), {
+			onSome: ([prefix, local]) => `${prefix}:${local}`,
+			onNone: () => `<${escapeIri(Option.getOrElse(Option.flatMap(this.base, (base) => relativize(iri, base)), () => iri))}>`
+		});
+	}
+	label(label) {
+		return label.startsWith("_:") ? label : this.iri(label);
+	}
+	predicate(p) {
+		return p === RDF_TYPE ? "a" : this.iri(p);
+	}
+	literal(l) {
+		const quoted = `"${escapeString(l.value)}"`;
+		if (l.language !== void 0) return `${quoted}@${l.language}`;
+		if (l.type === void 0 || l.type === `${XSD}string`) return quoted;
+		if (l.type === `${XSD}integer` && /^[+-]?\d+$/.test(l.value)) return l.value;
+		if (l.type === `${XSD}decimal` && /^[+-]?\d*\.\d+$/.test(l.value)) return l.value;
+		if (l.type === `${XSD}double` && /^[+-]?(\d+\.\d*|\.?\d+)[eE][+-]?\d+$/.test(l.value)) return l.value;
+		if (l.type === `${XSD}boolean` && (l.value === "true" || l.value === "false")) return l.value;
+		return `${quoted}^^${this.iri(l.type)}`;
+	}
+	objectValue(v) {
+		return Predicate.isString(v) ? this.iri(v) : this.literal(v);
+	}
+	semActs(acts = []) {
+		return acts.map((a) => ` %${this.iri(a.name)}${a.code === void 0 ? "%" : `{${escapeCode(a.code)}%}`}`).join("");
+	}
+	annotations(annots = []) {
+		return annots.map((a) => ` // ${this.predicate(a.predicate)} ${this.objectValue(a.object)}`).join("");
+	}
+	cardinality(c) {
+		const min = c.min ?? 1;
+		const max = c.max ?? 1;
+		if (c.min === void 0 && c.max === void 0) return "";
+		if (min === 0 && max === -1) return "*";
+		if (min === 1 && max === -1) return "+";
+		if (min === 0 && max === 1) return "?";
+		if (max === -1) return `{${min},}`;
+		if (min === max) return `{${min}}`;
+		return `{${min},${max}}`;
+	}
+	valueSetValue(v) {
+		if (Predicate.isString(v)) return this.iri(v);
+		if (isObjectLiteral(v)) return this.literal(v);
+		return Match.value(v).pipe(Match.withReturnType(), Match.discriminator("type")("IriStem", (member) => `${this.iri(member.stem)}~`), Match.discriminator("type")("LiteralStem", (member) => `${quoteLiteral(member.stem)}~`), Match.discriminator("type")("Language", (member) => `@${member.languageTag}`), Match.discriminator("type")("LanguageStem", (member) => member.stem === "" ? "@~" : `@${member.stem}~`), Match.discriminator("type")("IriStemRange", (member) => `${Predicate.isString(member.stem) ? `${this.iri(member.stem)}~` : "."}${member.exclusions.map((e) => ` - ${Predicate.isString(e) ? this.iri(e) : `${this.iri(e.stem)}~`}`).join("")}`), Match.discriminator("type")("LiteralStemRange", (member) => `${Predicate.isString(member.stem) ? `${quoteLiteral(member.stem)}~` : "."}${member.exclusions.map((e) => ` - ${Predicate.isString(e) ? quoteLiteral(e) : `${quoteLiteral(e.stem)}~`}`).join("")}`), Match.discriminator("type")("LanguageStemRange", (member) => `${Predicate.isString(member.stem) ? member.stem === "" ? "@~" : `@${member.stem}~` : "."}${member.exclusions.map((e) => ` - @${Predicate.isString(e) ? e : `${e.stem}~`}`).join("")}`), Match.orElse(() => ""));
+	}
+	nodeConstraint(nc) {
+		const parts = [];
+		if (nc.nodeKind !== void 0) parts.push(nc.nodeKind.toUpperCase());
+		if (nc.datatype !== void 0) parts.push(this.iri(nc.datatype));
+		if (nc.values !== void 0) parts.push(`[${nc.values.map((v) => this.valueSetValue(v)).join(" ")}]`);
+		if (nc.length !== void 0) parts.push(`LENGTH ${nc.length}`);
+		if (nc.minlength !== void 0) parts.push(`MINLENGTH ${nc.minlength}`);
+		if (nc.maxlength !== void 0) parts.push(`MAXLENGTH ${nc.maxlength}`);
+		if (nc.pattern !== void 0) parts.push(`/${escapeRegexp(nc.pattern)}/${nc.flags ?? ""}`);
+		if (nc.mininclusive !== void 0) parts.push(`MININCLUSIVE ${nc.mininclusive}`);
+		if (nc.minexclusive !== void 0) parts.push(`MINEXCLUSIVE ${nc.minexclusive}`);
+		if (nc.maxinclusive !== void 0) parts.push(`MAXINCLUSIVE ${nc.maxinclusive}`);
+		if (nc.maxexclusive !== void 0) parts.push(`MAXEXCLUSIVE ${nc.maxexclusive}`);
+		if (nc.totaldigits !== void 0) parts.push(`TOTALDIGITS ${nc.totaldigits}`);
+		if (nc.fractiondigits !== void 0) parts.push(`FRACTIONDIGITS ${nc.fractiondigits}`);
+		if (Arr.isReadonlyArrayEmpty(parts)) parts.push(".");
+		return parts.join(" ") + this.annotations(nc.annotations) + this.semActs(nc.semActs);
+	}
+	/**
+	* Prints a shape expression. `inline` forbids annotations and semantic
+	* actions at the top level, which are then wrapped in parentheses.
+	*/
+	shapeExpr(e, indent, inline) {
+		if (Predicate.isString(e)) return `@${this.label(e)}`;
+		return Match.value(e).pipe(Match.withReturnType(), Match.discriminator("type")("ShapeOr", (expr) => expr.shapeExprs.map((s) => this.junct(s, indent, "ShapeOr")).join(" OR ")), Match.discriminator("type")("ShapeAnd", (expr) => expr.shapeExprs.map((s) => this.junct(s, indent, "ShapeAnd")).join(" AND ")), Match.discriminator("type")("ShapeNot", (expr) => `NOT ${this.junct(expr.shapeExpr, indent, "ShapeNot")}`), Match.discriminator("type")("NodeConstraint", (expr) => {
+			const s = this.nodeConstraint(expr);
+			return inline && (expr.annotations !== void 0 || expr.semActs !== void 0) ? `(${s})` : s;
+		}), Match.discriminator("type")("Shape", (expr) => {
+			const s = this.shape(expr, indent);
+			return inline && (expr.annotations !== void 0 || expr.semActs !== void 0) ? `(${s})` : s;
+		}), Match.discriminator("type")("ShapeExternal", () => "EXTERNAL"), Match.exhaustive);
+	}
+	junct(e, indent, parent) {
+		if (Predicate.isString(e)) return `@${this.label(e)}`;
+		const needsParens = e.type === "ShapeOr" || e.type === "ShapeAnd" && parent !== "ShapeOr" || e.type === "ShapeNot" && parent === "ShapeNot" || e.type === "ShapeExternal";
+		const s = this.shapeExpr(e, indent, false);
+		return needsParens ? `(${s})` : s;
+	}
+	shape(s, indent) {
+		const head = [
+			...Arr.map(s.extends ?? [], (ext) => `EXTENDS ${this.junct(ext, indent, "ShapeNot")}`),
+			...s.extra === void 0 ? [] : [`EXTRA ${s.extra.map((p) => this.predicate(p)).join(" ")}`],
+			...s.closed === true ? ["CLOSED"] : []
+		];
+		const inner = indent + this.unit;
+		const body = s.expression === void 0 ? "{ }" : `{\n${inner}${this.tripleExpr(s.expression, inner, false)}\n${indent}}`;
+		return [...head, body].join(" ") + this.annotations(s.annotations) + this.semActs(s.semActs);
+	}
+	tripleExpr(t, indent, nested) {
+		if (Predicate.isString(t)) return `&${this.label(t)}`;
+		const id = t.id !== void 0 ? `$${this.label(t.id)} ` : "";
+		return Match.value(t).pipe(Match.withReturnType(), Match.discriminator("type")("TripleConstraint", (expr) => {
+			const value = expr.valueExpr === void 0 ? "." : this.shapeExpr(expr.valueExpr, indent, true);
+			return `${id}${expr.inverse === true ? "^" : ""}${this.predicate(expr.predicate)} ${value}${this.cardinality(expr)}${this.annotations(expr.annotations)}${this.semActs(expr.semActs)}`;
+		}), Match.discriminator("type")("EachOf", "OneOf", (expr) => {
+			const sep = expr.type === "EachOf" ? ` ;\n${indent}` : `\n${indent}| `;
+			const inner = indent + this.unit;
+			const items = expr.expressions.map((e) => this.tripleExpr(e, inner, !Predicate.isString(e) && e.type !== "TripleConstraint"));
+			const decorated = id !== "" || this.cardinality(expr) !== "" || expr.annotations !== void 0 || expr.semActs !== void 0;
+			if (!decorated && !nested) return items.join(sep);
+			if (!decorated && expr.type === "EachOf" && nested) return `(${items.join(sep)})`;
+			return `${id}(${items.join(sep)})${this.cardinality(expr)}${this.annotations(expr.annotations)}${this.semActs(expr.semActs)}`;
+		}), Match.exhaustive);
+	}
+	schema(schema) {
+		const header = [
+			...Arr.fromOption(Option.map(this.base, (base) => `BASE <${escapeIri(base)}>`)),
+			...Arr.map(Arr.fromIterable(this.prefixes.prefixes), ([p, ns]) => `PREFIX ${p}: <${escapeIri(ns)}>`),
+			...Arr.map(schema.imports ?? [], (imp) => `IMPORT ${this.iri(imp)}`)
+		];
+		return `${[
+			...header,
+			...Arr.isReadonlyArrayNonEmpty(header) ? [""] : [],
+			...schema.startActs === void 0 ? [] : [this.semActs(schema.startActs).trim()],
+			...schema.start === void 0 ? [] : [`start = ${this.shapeExpr(schema.start, "", false)}`],
+			...Arr.map(schema.shapes ?? [], (decl) => this.decl(decl))
+		].join("\n")}\n`;
+	}
+	decl(decl) {
+		return `${`${decl.abstract === true ? "ABSTRACT " : ""}${this.label(decl.id)}`}${(decl.restricts ?? []).map((r) => ` RESTRICTS ${this.junct(r, "", "ShapeNot")}`).join("")} ${!Predicate.isString(decl.shapeExpr) && decl.shapeExpr.type === "ShapeExternal" ? "EXTERNAL" : Predicate.isString(decl.shapeExpr) ? `@${this.label(decl.shapeExpr)}` : this.shapeExpr(decl.shapeExpr, "", false)}`;
+	}
+};
+/**
+* Prints a ShExJ schema as ShExC. Parsing the output yields an equivalent
+* schema.
+*
+* @since 0.1.0
+* @category printing
+*/
+const print = (schema, options = {}) => new Printer(options).schema(schema);
+export { print as i, parse as n, parseWithMetadata as r, ShExC_exports as t };
+
+//# sourceMappingURL=ShExC-DJbB19i3.mjs.map