@thomasfosterau/effect-rdf 0.0.0 → 0.1.0

package/dist/Parser-xARsOWXk.mjs

@@ -0,0 +1,1317 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { O as defaultGraph, T as blankNode$1, Y as literal, Z as namedNode, c as NamedNode, d as Quad, it as variable$2, q as isVariable, rt as triple } from "./Term-CFLG1qu4.mjs";
+import { l as resolve$1 } from "./Iri-Cr92gsQV.mjs";
+import { a as digit, g as pnCharsU, i as blankNodeLabel$1, l as hex, n as alpha, r as alphanumeric, u as iriExcluded } from "./Grammar-mQ8CgE1M.mjs";
+import { f as prefixedName, o as exponent, p as skip } from "./Grammar-CPlSxGH6.mjs";
+import { a as setOf, n as empty } from "./stringMap-D5YIpYtR.mjs";
+import { A as pathPattern, B as update, D as oneOrMore, E as negated$1, F as sequence, H as zeroOrMore, I as service, L as subSelect$1, N as quadPattern$1, O as operation, R as triplePattern, T as minus, U as zeroOrOne, V as values, _ as group, a as bgp, b as isBuiltInName, f as exists, g as graph, h as functionCall, k as optional, l as containsAggregate, m as filter, n as aggregate$1, o as bind, p as expressionVariables, r as alternative, s as builtInArity, v as inScopeVariables, w as link, x as isPath, y as inverse, z as union } from "./Ast-CPRZmBvk.mjs";
+import { t as loop } from "./loop-D5-gNx9K.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 "@thomasfosterau/effect-parse/ParseError";
+// src/sparql/internal/lexer.ts
+/**
+* The SPARQL lexer, written with `@thomasfosterau/effect-parse`: a compiled
+* grammar turning a query or update into tokens, built on the Turtle
+* grammar's terminals (`/turtle`'s `Grammar`), which SPARQL shares,
+* plus SPARQL's own (variables, keywords, punctuation). A pass then resolves
+* IRIs in document order, as `BASE` and `PREFIX` declarations are met, so
+* that the parser works on resolved tokens and needs no per-query state for
+* names.
+*
+* Where no token can be read, the tokens end with an `ERROR` token, which the
+* parser reports if it gets that far (as a lazy lexer would).
+*
+* @internal
+*/
+const make = (t, start, end) => ({
+	type: t.type,
+	value: t.value,
+	extra: t.extra ?? "",
+	kind: t.type === "PUNCT" ? t.value : t.type === "WORD" ? t.value === "a" ? "a" : t.value.toUpperCase() : t.type,
+	start: t.at ?? start,
+	end,
+	error: Option.none()
+});
+/** A token that ends the stream, with the reason. */
+const errorToken = (value, at) => at === void 0 ? {
+	type: "ERROR",
+	value
+} : {
+	type: "ERROR",
+	value,
+	at
+};
+const hex4 = Token.takeWhile(hex, 4);
+const hex8 = Token.takeWhile(hex, 8);
+/** Decodes a `UCHAR`, rejecting surrogates and code points beyond U+10FFFF. */
+const decodeUchar = (hex) => {
+	const code = parseInt(hex, 16);
+	return code >= 55296 && code <= 57343 || code > 1114111 ? Option.none() : Option.some(String.fromCodePoint(code));
+};
+const forbiddenInIri = /[<>"{}|^`\\\u0000- ]/;
+/** `IRIREF`, decoding its `UCHAR`s (an escape may not produce a disallowed character). */
+const iri$1 = Parser.delimited(Token.literal("<"), Parser.taken(Parser.repeat(Parser.alt(Token.takeTill([iriExcluded, "\\"], { min: 1 }), Parser.seq(Token.literal("\\u"), hex4), Parser.seq(Token.literal("\\U"), hex8)))), Token.literal(">")).pipe(Parser.map((raw) => {
+	if (raw.indexOf("\\") === -1) return {
+		type: "IRI",
+		value: raw
+	};
+	let bad = Option.none();
+	const value = raw.replace(/\\u([0-9A-Fa-f]{4})|\\U([0-9A-Fa-f]{8})/g, (_, a, b) => {
+		const hex = a ?? b;
+		const c = decodeUchar(hex);
+		if (Option.isNone(c)) {
+			if (Option.isNone(bad)) bad = Option.some(`Invalid code point escape \\u${hex}`);
+			return "";
+		}
+		return c.value;
+	});
+	if (Option.isSome(bad)) return errorToken(bad.value);
+	return forbiddenInIri.test(value) ? errorToken("Invalid character in IRI") : {
+		type: "IRI",
+		value
+	};
+}));
+const varChars = [
+	pnCharsU,
+	digit,
+	"·",
+	Token.range("̀", "ͯ"),
+	Token.range("‿", "⁀")
+];
+/** `VAR1` / `VAR2` */
+const variable$1 = Parser.preceded(Token.oneOf("?$"), Parser.taken(Parser.seq(Token.oneOf([pnCharsU, digit]), Token.takeWhile(varChars)))).pipe(Parser.map((value) => ({
+	type: "VAR",
+	value
+})));
+const ECHAR = {
+	t: "	",
+	b: "\b",
+	n: "\n",
+	r: "\r",
+	f: "\f",
+	"\"": "\"",
+	"'": "'",
+	"\\": "\\"
+};
+const HEX = /^[0-9A-Fa-f]+$/;
+/**
+* The runs of characters a string takes as they are: all but its quote and
+* `\` (and, in a short string, line breaks).
+*/
+const SHORT_RUN_DOUBLE = /[^"\\\n\r]*/y;
+const SHORT_RUN_SINGLE = /[^'\\\n\r]*/y;
+const LONG_RUN_DOUBLE = /[^"\\]*/y;
+const LONG_RUN_SINGLE = /[^'\\]*/y;
+/** Up to two quotes before a long string's closing delimiter. */
+const EXTRA_DOUBLE = /"{0,2}/y;
+const EXTRA_SINGLE = /'{0,2}/y;
+/** The end of the run `re` matches at `pos`. */
+const runEnd = (re, input, pos) => {
+	re.lastIndex = pos;
+	re.test(input);
+	return re.lastIndex;
+};
+/**
+* A string literal. Long strings may end with up to two quotes before the
+* closing delimiter (`"""a""""` is `a"`). Written as plain code: it is a
+* leaf, and its error reporting follows the reference lexer.
+*/
+const string$1 = Parser.make((state) => {
+	const input = state.input;
+	const start = state.pos;
+	const quote = input.charAt(start);
+	const long = input.startsWith(quote.repeat(3), start);
+	const double = quote === "\"";
+	const run = long ? double ? LONG_RUN_DOUBLE : LONG_RUN_SINGLE : double ? SHORT_RUN_DOUBLE : SHORT_RUN_SINGLE;
+	let i = start + (long ? 3 : 1);
+	let out = "";
+	let token = errorToken("Unterminated string literal");
+	const error = (message, at) => {
+		state.pos = input.length;
+		token = errorToken(message, at);
+		return false;
+	};
+	/** Reads the next run and the character after it; `false` once the literal ends. */
+	const step = () => {
+		const runTo = runEnd(run, input, i);
+		out += input.slice(i, runTo);
+		i = runTo;
+		if (i >= input.length) return error("Unterminated string literal");
+		const c = input.charAt(i);
+		if (c === "\\") {
+			const e = input.charAt(i + 1);
+			if (e === "u" || e === "U") {
+				const len = e === "u" ? 4 : 8;
+				const hex = input.slice(i + 2, i + 2 + len);
+				if (hex.length !== len || !HEX.test(hex)) return error("Invalid \\u escape", i);
+				const decoded = decodeUchar(hex);
+				if (Option.isNone(decoded)) return error(`Invalid code point escape \\u${hex}`, i);
+				out += decoded.value;
+				i += 2 + len;
+				return true;
+			}
+			const decoded = e === "" ? void 0 : ECHAR[e];
+			if (decoded === void 0) return error("Invalid escape sequence in string", i);
+			out += decoded;
+			i += 2;
+			return true;
+		}
+		if (long) {
+			if (input.startsWith(quote.repeat(3), i)) {
+				const j = runEnd(double ? EXTRA_DOUBLE : EXTRA_SINGLE, input, i + 3) - 3;
+				out += input.slice(i, j);
+				state.pos = j + 3;
+				token = {
+					type: "STRING",
+					value: out,
+					extra: "long"
+				};
+				return false;
+			}
+			out += c;
+			i++;
+			return true;
+		}
+		if (c === quote) {
+			state.pos = i + 1;
+			token = {
+				type: "STRING",
+				value: out
+			};
+			return false;
+		}
+		return error("Newline in string literal", i);
+	};
+	loop(step);
+	return token;
+});
+const digits0 = Token.takeWhile(digit);
+const digits1 = Token.takeWhile(digit, { min: 1 });
+/** An unsigned number (the sign is a separate token in SPARQL). */
+const number = Parser.alt(Parser.taken(Parser.alt(Parser.seq(digits1, Parser.opt(Parser.seq(Token.literal("."), digits0)), exponent), Parser.seq(Token.literal("."), digits1, exponent))).pipe(Parser.map((value) => ({
+	type: "DOUBLE",
+	value
+}))), Parser.taken(Parser.seq(digits0, Token.literal("."), digits1)).pipe(Parser.map((value) => ({
+	type: "DECIMAL",
+	value
+}))), digits1.pipe(Parser.map((value) => ({
+	type: "INTEGER",
+	value
+}))));
+/** `LANG_DIR`: a language tag with an optional `--direction` (checked by the parser). */
+const langTag = Parser.alt(Parser.preceded(Token.literal("@"), Parser.taken(Parser.seq(Token.takeWhile(alpha, { min: 1 }), Parser.repeat(Parser.preceded(Token.literal("-"), Token.takeWhile(alphanumeric, { min: 1 }))), Parser.opt(Parser.preceded(Token.literal("--"), Token.takeWhile(alpha, { min: 1 })))))).pipe(Parser.map((value) => ({
+	type: "LANGTAG",
+	value
+}))), Parser.preceded(Token.literal("@"), Parser.succeed(errorToken("Invalid language tag"))));
+const blankNode = Parser.alt(blankNodeLabel$1.pipe(Parser.map((value) => ({
+	type: "BNODE",
+	value
+}))), Parser.preceded(Token.literal("_:"), Parser.succeed(errorToken("Invalid blank node label"))));
+const pname = prefixedName.pipe(Parser.map(({ prefix, local }) => ({
+	type: "PNAME",
+	value: local,
+	extra: prefix
+})));
+const word = Parser.taken(Parser.seq(Token.oneOf(alpha), Token.takeWhile([alphanumeric, "_"]))).pipe(Parser.map((value) => ({
+	type: "WORD",
+	value
+})));
+const PUNCTUATION = [
+	"<<(",
+	")>>",
+	"{|",
+	"|}",
+	"<<",
+	">>",
+	"^^",
+	"&&",
+	"||",
+	"!=",
+	"<=",
+	">=",
+	..."{}()[].,;=<>!+-*/^|?~".split("")
+];
+const punctuation = Parser.alt(...PUNCTUATION.map((p) => Token.literal(p))).pipe(Parser.map((value) => ({
+	type: "PUNCT",
+	value
+})));
+const unexpected$1 = Token.any.pipe(Parser.map((c) => errorToken(`Unexpected character '${c}'`)));
+/** One token, in the order of preference of the reference lexer. */
+const token = Parser.alt(Parser.preceded(Parser.peek(Token.literal("<")), Parser.backtrack(iri$1)), Parser.preceded(Parser.peek(Token.oneOf("?$")), variable$1), Parser.preceded(Token.literal("$"), Parser.succeed(errorToken("Invalid variable"))), Parser.preceded(Parser.peek(Token.oneOf("\"'")), string$1), Parser.preceded(Parser.peek(Parser.alt(Token.oneOf(digit), Parser.seq(Token.literal("."), Token.oneOf(digit)))), number), Parser.preceded(Parser.peek(Token.literal("@")), langTag), Parser.preceded(Parser.peek(Token.literal("_:")), blankNode), pname, word, punctuation, unexpected$1);
+const lexer = Compiler.jit(Parser.seq(Parser.repeat(Parser.preceded(Parser.seq(skip, Parser.not(Parser.eof)), Parser.withSpan(token).pipe(Parser.map(([t, { start, end }]) => make(t, start, end))))), Parser.preceded(skip, Parser.location)));
+/** Splits a query or update into tokens (ending at the first `ERROR` token, if any). */
+const tokenize = (input) => {
+	const tokens = Result.match(Parser.parsePeek(lexer, input), {
+		onSuccess: ([, [lexed]]) => lexed,
+		onFailure: () => [make(errorToken("No token could be read"), 0, 0)]
+	});
+	const error = tokens.findIndex((t) => t.type === "ERROR");
+	if (error !== -1) tokens.length = error + 1;
+	return tokens;
+};
+/**
+* Resolves the IRIs of `tokens` in place, in document order: IRI references
+* against the base and prefixed names against the prefixes, as `BASE` and
+* `PREFIX` declarations set them. The name a `PREFIX` declares is left
+* alone; a prefixed name with an undefined prefix gets an `error`.
+*/
+const resolve = (tokens, baseIri, initialPrefixes) => {
+	const state = {
+		base: baseIri,
+		prefixes: { ...initialPrefixes }
+	};
+	let i = 0;
+	loop(() => {
+		const t = tokens[i];
+		if (t === void 0) return false;
+		i += resolveToken(t, tokens, i, state) + 1;
+		return true;
+	});
+	return {
+		base: state.base,
+		prefixes: state.prefixes
+	};
+};
+const resolveIri = (state, ref) => Option.match(state.base, {
+	onNone: () => ref,
+	onSome: (base) => resolve$1(ref, base)
+});
+/** Resolves a `BASE` or `PREFIX` directive's IRI; how many tokens it consumed. */
+const resolveDirective = (t, tokens, i, state) => {
+	const next = tokens[i + 1];
+	if (t.kind === "BASE" && next?.type === "IRI") {
+		next.value = resolveIri(state, next.value);
+		state.base = Option.some(next.value);
+		return 1;
+	}
+	if (t.kind === "PREFIX" && next?.type === "PNAME" && next.value === "") {
+		const value = tokens[i + 2];
+		if (value?.type === "IRI") {
+			value.value = resolveIri(state, value.value);
+			state.prefixes[next.extra] = value.value;
+			return 2;
+		}
+	}
+	return 0;
+};
+/**
+* Resolves one token in place and returns how many of the following tokens
+* it consumed (a `BASE` or `PREFIX` directive's IRI and name). A plain
+* branch per type: it runs once per token.
+*/
+const resolveToken = (t, tokens, i, state) => {
+	if (t.type === "IRI") {
+		t.value = resolveIri(state, t.value);
+		return 0;
+	}
+	if (t.type === "PNAME") {
+		const ns = state.prefixes[t.extra];
+		if (ns === void 0) t.error = Option.some(`Undefined prefix '${t.extra}:'`);
+		else t.value = ns + t.value;
+		return 0;
+	}
+	return t.type === "WORD" ? resolveDirective(t, tokens, i, state) : 0;
+};
+// src/sparql/internal/parser.ts
+/**
+* The SPARQL 1.1 / 1.2 query and update grammar, written with
+* `@thomasfosterau/effect-parse` as a compiled LL(1) grammar over the tokens
+* of `lexer.ts` (whose names are already resolved). It builds the AST
+* directly, expanding every abbreviation and enforcing the static rules of
+* the specification.
+*
+* Three things depend on the order in which the input is read: the labels of
+* generated blank nodes, the scopes of blank node labels, and where
+* aggregates are allowed. They live in a per-parse context, which small
+* hooks (`Parser.make`) update at the points where the reference parser does,
+* and which is reset at the start of every run of the grammar.
+*
+* @internal
+*/
+const RDF = "http://www.w3.org/1999/02/22-rdf-syntax-ns#";
+const XSD = "http://www.w3.org/2001/XMLSchema#";
+const rdfType = namedNode(`${RDF}type`);
+const rdfFirst = namedNode(`${RDF}first`);
+const rdfRest = namedNode(`${RDF}rest`);
+const rdfNil = namedNode(`${RDF}nil`);
+const rdfReifies = namedNode(`${RDF}reifies`);
+const xsdInteger = namedNode(`${XSD}integer`);
+const xsdDecimal = namedNode(`${XSD}decimal`);
+const xsdDouble = namedNode(`${XSD}double`);
+const xsdBoolean = namedNode(`${XSD}boolean`);
+/** A syntax or static error, at a character offset. */
+var Failure = class {
+	message;
+	offset;
+	constructor(message, offset) {
+		this.message = message;
+		this.offset = offset;
+	}
+};
+const fail = (message, offset) => {
+	throw new Failure(message, offset);
+};
+/**
+* What a hook sees past the last token: a token no grammar rule matches (its
+* kind is no keyword or punctuation), at the end of the input.
+*/
+const END = {
+	type: "END",
+	value: "",
+	extra: "",
+	kind: "",
+	start: -1,
+	end: -1,
+	error: Option.none()
+};
+/** The token at `pos`, or `END` past the last one. */
+const tokenAt = (tokens, pos) => tokens[pos] ?? END;
+/**
+* A set of token kinds, read through its backing `Map` by the token
+* predicates (one lookup per token, without an `Option` per lookup).
+*/
+const kindSet = (kinds) => setOf(kinds);
+/** Whether a triple-shaped item is a triple pattern (not a path pattern). */
+const isTriplePattern = (t) => Predicate.isTagged(t, "TriplePattern");
+/** The context outside every pattern (never read: the grammar sets one first). */
+const noContext = {
+	variables: true,
+	blankNodes: true,
+	scope: 0,
+	labels: empty()
+};
+var Context = class {
+	input;
+	usedLabels;
+	bnodeCounter = 0;
+	scopeCounter = 0;
+	opIndex = 0;
+	patternLabels = empty();
+	templateLabels = empty();
+	aggregatesAllowed = false;
+	inAggregate = false;
+	/** The aggregate flags saved by `withFlags`, in pairs. */
+	flags = [];
+	/** The triple contexts in force, innermost last. */
+	triples = [];
+	/** The last `VERSION` declared. */
+	version = Option.none();
+	/** Whether the verbs being read are simple predicates, innermost last. */
+	verbs = [];
+	/** The first token of the subject being read. */
+	subjectStart = END;
+	constructor(input) {
+		this.input = input;
+		this.usedLabels = setOf(Array.from(input.matchAll(/_:([^\s.;,(){}[\]]+)/g), (m) => m[1] ?? ""));
+	}
+	get tc() {
+		return this.triples[this.triples.length - 1] ?? noContext;
+	}
+	patternContext() {
+		return {
+			variables: true,
+			blankNodes: true,
+			scope: ++this.scopeCounter,
+			labels: this.patternLabels
+		};
+	}
+	freshBlankNode() {
+		let label = `g${this.bnodeCounter++}`;
+		loop(() => {
+			if (!this.usedLabels.has(label)) return false;
+			label = `g${this.bnodeCounter++}`;
+			return true;
+		});
+		return blankNode$1(label);
+	}
+};
+let ctx = new Context("");
+let fresh = () => new Context("");
+/** Starts a run of the grammar with a new context (the compiled run and any re-run). */
+const start = Parser.make(() => {
+	ctx = fresh();
+});
+const offsetOf = (t) => t === END ? ctx.input.length : t.start;
+/**
+* Runs `f`, returning a thrown `Failure` (a syntax error found while
+* building) as the failure; any other exception is a defect and propagates.
+*/
+const catchFailure = (f) => Result.try({
+	try: f,
+	catch: (cause) => {
+		if (cause instanceof Failure) return cause;
+		throw cause;
+	}
+});
+/**
+* A hook: runs `f` on the current token (without consuming it). A `Failure`
+* thrown by `f` is an unrecoverable error.
+*/
+const hook = (f) => Parser.make((state) => {
+	try {
+		return f(tokenAt(state.input, state.pos));
+	} catch (e) {
+		if (e instanceof Failure) return state.failCause("Cut", "Verify", e);
+		throw e;
+	}
+});
+/**
+* A token parser written as a hook: `f` returns the value for the current
+* token (consumed), or `None` to fail without consuming it.
+*/
+const take = (label, f) => {
+	const expected = [label];
+	return Parser.make((state) => {
+		const t = state.input[state.pos];
+		if (t === void 0 || t.type === "ERROR") return state.backtrack("Token", expected);
+		try {
+			const a = f(t, tokenAt(state.input, state.pos + 1));
+			if (Option.isNone(a)) return state.backtrack("Token", expected);
+			state.pos++;
+			return a.value;
+		} catch (e) {
+			if (e instanceof Failure) return state.failCause("Cut", "Verify", e);
+			throw e;
+		}
+	});
+};
+/** A `take` result: the token is taken. */
+const taken = Option.some(true);
+const notTaken = Option.none();
+/**
+* Runs `p` with the aggregate flags set (`inAggregate` left alone when
+* `None`), restoring them afterwards.
+*/
+const withFlags = (aggregatesAllowed, inAggregate, p) => Parser.delimited(hook(() => {
+	ctx.flags.push(ctx.aggregatesAllowed, ctx.inAggregate);
+	ctx.aggregatesAllowed = aggregatesAllowed;
+	if (Option.isSome(inAggregate)) ctx.inAggregate = inAggregate.value;
+}), p, hook(() => {
+	ctx.inAggregate = ctx.flags.pop() ?? false;
+	ctx.aggregatesAllowed = ctx.flags.pop() ?? false;
+}));
+/** Runs `p` in a triple context, restoring the enclosing one afterwards. */
+const inContext = (make, p) => Parser.delimited(hook(() => {
+	ctx.triples.push(make());
+}), p, hook(() => {
+	ctx.triples.pop();
+}));
+const describe = (t) => t === END ? "end of input" : t.type === "STRING" ? "string literal" : `'${ctx.input.slice(t.start, t.end)}'`;
+const unexpected = (t, expected) => fail(`Unexpected ${describe(t)}${expected !== void 0 ? `, expected ${expected}` : ""}`, offsetOf(t));
+/** The reference parser's "Unexpected …" error at `t` (or the lexer's, at an error token). */
+const unexpectedAt = (t, expected) => t.type === "ERROR" ? fail(t.value, t.start) : unexpected(t, expected);
+/** Fails with the reference parser's "Unexpected …" message at the current token. */
+const unexpectedHere = (expected) => hook((t) => unexpectedAt(t, expected));
+/**
+* A token of the given kind (see `Tok.kind`). A token set rather than a
+* `Parser.make` hook, so the compiler inlines the match instead of calling
+* back into an interpreted step.
+*/
+const tok = (kind) => Token.oneOf((t) => t.kind === kind).pipe(Parser.expected(`'${kind}'`));
+/** `kind`, or the "Unexpected …, expected …" error. */
+const expect = (kind, label = kind === kind.toUpperCase() && /^[A-Z]/.test(kind) ? kind : `'${kind}'`) => Parser.alt(tok(kind), unexpectedHere(label));
+/** Whether the next token is of kind `kind` (consumed if so). */
+const eat = (kind) => Parser.opt(tok(kind)).pipe(Parser.map(Option.isSome));
+/**
+* Whether the next token's kind is one of `kinds` (not consumed). A peeked
+* token set, like `tok`, so the compiler inlines it.
+*/
+const peekKind = (kinds) => {
+	const set = kindSet(kinds);
+	return Parser.peek(Token.oneOf((t) => set.has(t.kind))).pipe(Parser.asVoid, Parser.expected(kinds.map((k) => `'${k}'`).join(" or ")));
+};
+/** Any token but a lexer error token (consumed). A token set, like `tok`. */
+const anyToken = Token.oneOf((t) => t.type !== "ERROR").pipe(Parser.expected("a token"));
+/**
+* Chooses a parser by the kind of the next token; when no case matches,
+* `otherwise` (or a failure that consumes nothing).
+*/
+const select = (cases, otherwise) => {
+	const seen = MutableHashSet.empty();
+	const branches = Arr.filterMap(cases, ([kinds, p]) => {
+		const own = Arr.dedupe(kinds.filter((k) => !MutableHashSet.has(seen, k)));
+		own.forEach((k) => MutableHashSet.add(seen, k));
+		return Arr.isArrayNonEmpty(own) ? Result.succeed(Parser.preceded(peekKind(own), p)) : Result.failVoid;
+	});
+	if (otherwise !== void 0) branches.push(otherwise);
+	return Parser.alt(...branches);
+};
+/** Whether the next tokens are `a` then `b` (not consumed). */
+const peek2 = (a, b) => Parser.peek(Parser.seq(tok(a), tok(b)));
+const nil = peek2("(", ")");
+const anon = peek2("[", "]");
+const iri = take("an IRI", (t) => {
+	if (t.type === "IRI") return Option.some(namedNode(t.value));
+	if (t.type === "PNAME") return Option.isSome(t.error) ? fail(t.error.value, t.start) : Option.some(namedNode(t.value));
+	return notTaken;
+});
+const iriOrError = Parser.alt(iri, unexpectedHere("an IRI"));
+const variable = take("a variable", (t) => t.type === "VAR" ? Option.some(variable$2(t.value)) : notTaken);
+const variableOrError = Parser.alt(variable, unexpectedHere("a variable"));
+/** A variable in a pattern (checked against the triple context). */
+const patternVariable = take("a variable", (t) => {
+	if (t.type !== "VAR") return notTaken;
+	if (!ctx.tc.variables) fail("Variables are not allowed here", t.start);
+	return Option.some(variable$2(t.value));
+});
+const isIri = (t) => t.type === "IRI" || t.type === "PNAME";
+const isNumber = (t) => t.type === "INTEGER" || t.type === "DECIMAL" || t.type === "DOUBLE";
+const blankNodeLabel = take("a blank node", (t) => {
+	if (t.type !== "BNODE") return notTaken;
+	const tc = ctx.tc;
+	if (!tc.blankNodes) fail("Blank nodes are not allowed here", t.start);
+	const existing = tc.labels.get(t.value);
+	if (existing !== void 0 && existing !== tc.scope) fail(`Blank node label _:${t.value} is used in more than one scope`, t.start);
+	tc.labels.set(t.value, tc.scope);
+	return Option.some(blankNode$1(t.value));
+});
+/** A generated blank node in a pattern (checked against the triple context). */
+const freshPatternBlankNode = hook((t) => {
+	if (!ctx.tc.blankNodes) fail("Blank nodes are not allowed here", offsetOf(t));
+	return ctx.freshBlankNode();
+});
+const string = take("a string", (t) => t.type === "STRING" ? Option.some(t) : notTaken);
+const isDirection = (direction) => direction === "ltr" || direction === "rtl";
+const rdfLiteral = Parser.seq(string, Parser.alt(take("a language tag", (t, next) => {
+	if (t.type !== "LANGTAG") return notTaken;
+	const tag = t.value;
+	const i = tag.indexOf("--");
+	if (i === -1) return Option.some({
+		tag,
+		direction: Option.none()
+	});
+	const direction = tag.slice(i + 2).toLowerCase();
+	return isDirection(direction) ? Option.some({
+		tag: tag.slice(0, i),
+		direction: Option.some(direction)
+	}) : fail(`Invalid base direction '${direction}'`, offsetOf(next));
+}), Parser.preceded(tok("^^"), iriOrError), Parser.succeed(void 0))).pipe(Parser.map(([s, suffix]) => {
+	if (suffix === void 0) return literal(s.value);
+	if (suffix instanceof NamedNode) return literal(s.value, suffix);
+	return Option.isSome(suffix.direction) ? literal(s.value, {
+		language: suffix.tag,
+		direction: suffix.direction.value
+	}) : literal(s.value, suffix.tag);
+}));
+const numberLiteral = (t, sign) => literal(sign + t.value, t.type === "INTEGER" ? xsdInteger : t.type === "DECIMAL" ? xsdDecimal : xsdDouble);
+const numericLiteral = take("a number", (t) => isNumber(t) ? Option.some(numberLiteral(t, "")) : notTaken);
+/** `+` or `-` immediately followed by a number. */
+const signedNumber = Parser.make((state) => {
+	const t = state.input[state.pos];
+	const n = state.input[state.pos + 1];
+	if (t !== void 0 && (t.kind === "+" || t.kind === "-") && n !== void 0 && n.start === t.end && isNumber(n)) {
+		state.pos += 2;
+		return numberLiteral(n, t.value);
+	}
+	return state.backtrack("Token", ["a number"]);
+});
+const booleanLiteral = take("a boolean", (t) => t.kind === "TRUE" || t.kind === "FALSE" ? Option.some(literal(t.value.toLowerCase(), xsdBoolean)) : notTaken);
+/** `a`, or an IRI. */
+const aOrIri = Parser.alt(tok("a").pipe(Parser.as(rdfType)), iriOrError);
+/** iri | RDFLiteral | NumericLiteral | BooleanLiteral */
+const dataTerm = Parser.alt(iri, rdfLiteral, numericLiteral, signedNumber, booleanLiteral, unexpectedHere("an RDF term"));
+const tripleTermData = Parser.preceded(tok("<<("), Parser.seq(iriOrError, aOrIri, Parser.alt(Parser.suspend(() => tripleTermData), dataTerm), expect(")>>"))).pipe(Parser.map(([s, p, o]) => triple(s, p, o)));
+/** A data block value; `None` for `UNDEF`. */
+const dataBlockValue = Parser.alt(tok("UNDEF").pipe(Parser.as(Option.none())), Parser.alt(tripleTermData, dataTerm).pipe(Parser.map(Option.some)));
+const dataBlock = Parser.alt(Parser.seq(variable, Parser.preceded(expect("{"), Parser.terminated(Parser.repeat(Parser.preceded(Parser.not(tok("}")), dataBlockValue)), tok("}")))).pipe(Parser.map(([v, values$1]) => values([v], values$1.map((x) => [Option.getOrUndefined(x)])))), Parser.seq(Parser.preceded(expect("("), Parser.repeat(Parser.seq(variable, hook((t) => t))).pipe(Parser.tryMap((vars) => Option.match(Arr.findFirst(vars, ([v], i) => vars.findIndex(([x]) => x.value === v.value) < i), {
+	onNone: () => Result.succeed(vars.map(([v]) => v)),
+	onSome: ([v, next]) => Result.fail(new Failure(`Duplicate variable ?${v.value} in VALUES`, offsetOf(next)))
+})), Parser.cut)), Parser.preceded(Parser.seq(expect(")"), expect("{")), Parser.terminated(Parser.repeat(Parser.preceded(Parser.not(tok("}")), Parser.seq(hook((t) => offsetOf(t)), Parser.preceded(expect("("), Parser.terminated(Parser.repeat(Parser.preceded(Parser.not(tok(")")), dataBlockValue)), anyToken))))), expect("}")))).pipe(Parser.tryMap(([variables, rows]) => Option.match(Arr.findFirst(rows, ([, row]) => row.length !== variables.length), {
+	onNone: () => Result.succeed(values(variables, rows.map(([, row]) => row.map(Option.getOrUndefined)))),
+	onSome: ([at, row]) => Result.fail(new Failure(`VALUES row has ${row.length} values but ${variables.length} variables`, at))
+})), Parser.cut));
+const node = (term, triples = []) => ({
+	term,
+	triples
+});
+/** The triples of a property list, in the order the reference parser emits them. */
+const build = (subject, pl, out = []) => {
+	pl.forEach(([v, objects]) => {
+		const predicate = v.predicate;
+		objects.forEach(({ node: o, annotation }) => {
+			o.triples.forEach((t) => out.push(t));
+			if (isPath(predicate)) {
+				out.push(pathPattern(subject, predicate, o.term));
+				return;
+			}
+			out.push(triplePattern(subject, predicate, o.term));
+			if (Arr.isReadonlyArrayEmpty(annotation)) return;
+			const triple$1 = triple(subject, predicate, o.term);
+			annotation.forEach((a) => {
+				out.push(triplePattern(a.reifier, rdfReifies, triple$1));
+				if (Option.isSome(a.block)) build(a.reifier, a.block.value, out);
+			});
+		});
+	});
+	return out;
+};
+/** The token types that start a triples block on their own. */
+const TRIPLES_START = kindSet([
+	"VAR",
+	"IRI",
+	"PNAME",
+	"BNODE",
+	"STRING",
+	"INTEGER",
+	"DECIMAL",
+	"DOUBLE"
+]);
+/** Whether a token can start a triples block. A plain branch per type: it runs once per peek. */
+const startsTriplesToken = (t, next) => {
+	if (TRIPLES_START.has(t.type)) return true;
+	if (t.type === "WORD") return t.kind === "TRUE" || t.kind === "FALSE";
+	if (t.type !== "PUNCT") return false;
+	const v = t.value;
+	return v === "(" || v === "[" || v === "<<" || v === "<<(" || (v === "+" || v === "-") && isNumber(next);
+};
+const startsTriples = Parser.peek(take("triples", (t, next) => startsTriplesToken(t, next) ? taken : notTaken));
+const path = Parser.suspend(() => pathDef);
+const triplesGrammar = (paths) => {
+	const graphNode = Parser.suspend(() => graphNodeDef);
+	const propertyList = Parser.suspend(() => propertyListDef);
+	const varOrTerm = (allowNil) => Parser.alt(patternVariable, iri, blankNodeLabel, rdfLiteral, numericLiteral, booleanLiteral, signedNumber, ...allowNil ? [Parser.preceded(Parser.seq(nil, anyToken, anyToken), Parser.succeed(rdfNil))] : [], Parser.preceded(Parser.seq(anon, anyToken, anyToken), freshPatternBlankNode), Parser.suspend(() => tripleTerm), unexpectedHere("an RDF term or variable"));
+	const patternPredicate = Parser.alt(patternVariable, aOrIri);
+	const tripleTermComponent = Parser.alt(Parser.suspend(() => tripleTerm), Parser.preceded(Parser.peek(Parser.alt(tok("("), tok("<<"), Parser.preceded(Parser.not(anon), tok("[")))), unexpectedHere()), varOrTerm(false));
+	const tripleTerm = Parser.preceded(tok("<<("), Parser.seq(tripleTermComponent, patternPredicate, tripleTermComponent, expect(")>>"))).pipe(Parser.map(([s, p, o]) => triple(s, p, o)));
+	const reifier = Parser.preceded(tok("~"), Parser.alt(patternVariable, iri, blankNodeLabel, Parser.preceded(Parser.seq(anon, anyToken, anyToken), freshPatternBlankNode), freshPatternBlankNode));
+	const reifiedTriple = Parser.suspend(() => reifiedTripleDef);
+	const reifiedTripleComponent = Parser.alt(reifiedTriple, Parser.suspend(() => tripleTerm).pipe(Parser.map((t) => node(t))), Parser.preceded(Parser.peek(Parser.alt(tok("("), Parser.preceded(Parser.not(anon), tok("[")))), unexpectedHere()), varOrTerm(false).pipe(Parser.map((t) => node(t))));
+	const reifiedTripleDef = Parser.preceded(tok("<<"), Parser.seq(reifiedTripleComponent, patternPredicate, reifiedTripleComponent, Parser.alt(reifier, freshPatternBlankNode), expect(">>"))).pipe(Parser.map(([s, p, o, r]) => node(r, [
+		...s.triples,
+		...o.triples,
+		triplePattern(r, rdfReifies, triple(s.term, p, o.term))
+	])));
+	const triplesNode = Parser.alt(Parser.preceded(tok("["), Parser.seq(freshPatternBlankNode, Parser.terminated(propertyList, expect("]")))).pipe(Parser.map(([b, pl]) => node(b, build(b, pl)))), Parser.preceded(tok("("), Parser.seq(Parser.terminated(Parser.repeat(Parser.preceded(Parser.not(tok(")")), graphNode)), anyToken), hook((t) => t))).pipe(Parser.map(([items, t]) => {
+		if (!Arr.isArrayNonEmpty(items)) return node(rdfNil);
+		if (!ctx.tc.blankNodes) fail("Blank nodes are not allowed here", offsetOf(t));
+		const cells = Arr.map(items, (item) => [ctx.freshBlankNode(), item]);
+		const triples = [];
+		items.forEach((item) => item.triples.forEach((x) => triples.push(x)));
+		cells.forEach(([cell, item], i) => {
+			triples.push(triplePattern(cell, rdfFirst, item.term));
+			triples.push(triplePattern(cell, rdfRest, cells[i + 1]?.[0] ?? rdfNil));
+		});
+		return node(cells[0][0], triples);
+	})));
+	/** GraphNode / GraphNodePath */
+	const graphNodeDef = Parser.alt(reifiedTriple, Parser.preceded(Parser.alt(Parser.seq(Parser.not(nil), Parser.peek(tok("("))), Parser.seq(Parser.not(anon), Parser.peek(tok("[")))), triplesNode), varOrTerm(true).pipe(Parser.map((t) => node(t))));
+	const startsVerb = Parser.peek(take("a verb", (t) => t.type === "VAR" || isIri(t) || t.kind === "a" || paths && (t.kind === "^" || t.kind === "!" || t.kind === "(") ? taken : notTaken));
+	/** A verb; whether it is simple is pushed on `ctx.verbs` until its objects are read. */
+	const verb = Parser.alt(Parser.seq(patternVariable, paths ? Parser.preceded(Parser.peek(Parser.alt(tok("/"), tok("|"))), unexpectedHere()).pipe(Parser.opt) : Parser.succeed(void 0)).pipe(Parser.map(([v]) => ({
+		predicate: v,
+		simple: true
+	}))), paths ? path.pipe(Parser.map((p) => Predicate.isTagged(p, "PathLink") ? {
+		predicate: p.iri,
+		simple: true
+	} : {
+		predicate: p,
+		simple: false
+	})) : aOrIri.pipe(Parser.map((predicate) => ({
+		predicate,
+		simple: true
+	})))).pipe(Parser.map((v) => {
+		ctx.verbs.push(v.simple);
+		return v;
+	}));
+	const annotationBlock = Parser.terminated(propertyList, expect("|}"));
+	const annotationItem = Parser.alt(Parser.seq(reifier, Parser.opt(Parser.preceded(tok("{|"), annotationBlock))).pipe(Parser.map(([r, block]) => ({
+		reifier: r,
+		block
+	}))), Parser.preceded(tok("{|"), Parser.seq(freshPatternBlankNode, annotationBlock)).pipe(Parser.map(([r, block]) => ({
+		reifier: r,
+		block: Option.some(block)
+	}))));
+	const annotation = Parser.alt(Parser.preceded(Parser.seq(Parser.peek(Parser.alt(tok("~"), tok("{|"))), hook((t) => {
+		if (!ctx.verbs[ctx.verbs.length - 1]) fail("Reifiers and annotations require a simple predicate", offsetOf(t));
+	})), Parser.repeat(annotationItem, { min: 1 })), Parser.succeed([]));
+	const objectList = Parser.separated(Parser.seq(graphNode, annotation).pipe(Parser.map(([n, a]) => ({
+		node: n,
+		annotation: a
+	}))), tok(","), { min: 1 });
+	const verbObjects = Parser.seq(verb, Parser.terminated(objectList, hook(() => {
+		ctx.verbs.pop();
+	})));
+	const propertyListDef = Parser.seq(verbObjects, Parser.repeat(Parser.preceded(Parser.repeat(tok(";"), { min: 1 }), Parser.preceded(startsVerb, verbObjects))), Parser.opt(Parser.repeat(tok(";"), { min: 1 }))).pipe(Parser.map(([first, rest]) => [first, ...rest]));
+	const withProperties = (subject) => Parser.seq(subject, Parser.opt(Parser.preceded(startsVerb, propertyList))).pipe(Parser.map(([s, pl]) => Option.isSome(pl) ? build(s.term, pl.value, [...s.triples]) : s.triples));
+	const triplesSameSubject = Parser.alt(withProperties(reifiedTriple), Parser.preceded(Parser.alt(Parser.seq(Parser.not(nil), Parser.peek(tok("("))), Parser.seq(Parser.not(anon), Parser.peek(tok("[")))), withProperties(triplesNode)), Parser.seq(hook((t) => {
+		ctx.subjectStart = t;
+	}), varOrTerm(true), Parser.alt(Parser.preceded(startsVerb, propertyList), hook((t) => unexpectedAt(t, `a predicate after ${describe(ctx.subjectStart)}`)))).pipe(Parser.map(([, subject, pl]) => build(subject, pl))));
+	return {
+		triplesSameSubject,
+		triplesBlock: Parser.seq(triplesSameSubject, Parser.repeat(Parser.preceded(Parser.seq(tok("."), startsTriples), triplesSameSubject)), eat(".")).pipe(Parser.map(([first, rest, dot]) => [[...first, ...rest.flat()], dot])),
+		triplesTemplate: Parser.opt(Parser.preceded(Parser.seq(Parser.not(tok("}")), startsTriples), Parser.seq(triplesSameSubject, Parser.repeat(Parser.preceded(Parser.seq(tok("."), Parser.not(tok("}")), startsTriples), triplesSameSubject)), eat(".")))).pipe(Parser.map((o) => Option.isNone(o) ? [] : [...o.value[0], ...o.value[1].flat()]))
+	};
+};
+const negatedOne = Parser.seq(eat("^"), aOrIri);
+const negated = Parser.alt(Parser.preceded(tok("("), Parser.terminated(Parser.opt(Parser.separated(negatedOne, tok("|"), { min: 1 })), expect(")"))).pipe(Parser.map((o) => Option.getOrElse(o, () => []))), negatedOne.pipe(Parser.map((one) => [one]))).pipe(Parser.map((ones) => negated$1(ones.filter(([inv]) => !inv).map(([, i]) => i), ones.filter(([inv]) => inv).map(([, i]) => i))));
+const pathPrimary = Parser.alt(tok("a").pipe(Parser.as(link(rdfType))), iri.pipe(Parser.map((i) => link(i))), Parser.preceded(tok("!"), negated), Parser.delimited(tok("("), path, expect(")")), unexpectedHere("a property path"));
+const pathElt = Parser.seq(pathPrimary, Parser.opt(Parser.alt(tok("?"), tok("*"), tok("+")))).pipe(Parser.map(([primary, mod]) => Option.isNone(mod) ? primary : mod.value.kind === "?" ? zeroOrOne(primary) : mod.value.kind === "*" ? zeroOrMore(primary) : oneOrMore(primary)));
+const pathEltOrInverse = Parser.alt(Parser.preceded(tok("^"), pathElt).pipe(Parser.map((p) => inverse(p))), pathElt);
+const pathSequence = Parser.separated(pathEltOrInverse, tok("/"), { min: 1 }).pipe(Parser.map((ps) => ps.length === 1 ? ps[0] : sequence(...ps)));
+const pathDef = Parser.separated(pathSequence, tok("|"), { min: 1 }).pipe(Parser.map((ps) => ps.length === 1 ? ps[0] : alternative(...ps)));
+const expression = Parser.suspend(() => expressionDef);
+const groupGraphPattern = Parser.suspend(() => groupGraphPatternDef);
+const AGGREGATES = [
+	"COUNT",
+	"SUM",
+	"MIN",
+	"MAX",
+	"AVG",
+	"SAMPLE",
+	"GROUP_CONCAT"
+];
+const AGGREGATE_KINDS = kindSet(AGGREGATES);
+const isBuiltInStart = (t) => t.type === "WORD" && (isBuiltInName(t.kind) || AGGREGATE_KINDS.has(t.kind) || t.kind === "EXISTS" || t.kind === "NOT");
+const startsBuiltIn = Parser.peek(take("a function", (t) => isBuiltInStart(t) ? taken : notTaken));
+const brackettedExpression = Parser.delimited(expect("("), expression, expect(")"));
+const expressionList = Parser.preceded(expect("("), Parser.alt(tok(")").pipe(Parser.as([])), Parser.terminated(Parser.separated(expression, tok(","), { min: 1 }), expect(")"))));
+/** The arguments of a function call, and whether they are DISTINCT. */
+const functionArgs = Parser.alt(Parser.preceded(Parser.seq(nil, anyToken, anyToken), Parser.succeed([[], false])), Parser.preceded(expect("("), Parser.seq(Parser.opt(take("DISTINCT", (t) => {
+	if (t.kind !== "DISTINCT") return notTaken;
+	if (!ctx.aggregatesAllowed || ctx.inAggregate) fail("DISTINCT is only allowed in aggregate function calls", t.start);
+	return taken;
+})), Parser.separated(expression, tok(","), { min: 1 }), expect(")"))).pipe(Parser.map(([distinct, args]) => [args, Option.isSome(distinct)])));
+const groupGraphPatternInExpression = withFlags(false, Option.some(false), groupGraphPattern);
+/** An aggregate, from its name. */
+const aggregate = (name) => Parser.preceded(hook((t) => {
+	if (!ctx.aggregatesAllowed) fail(`Aggregate ${name} is not allowed here`, offsetOf(t));
+	if (ctx.inAggregate) fail("Aggregates cannot be nested", offsetOf(t));
+}), Parser.seq(Parser.preceded(Parser.seq(anyToken, expect("(")), eat("DISTINCT")), Parser.preceded(hook(() => {
+	ctx.inAggregate = true;
+}), Parser.alt(...name === "COUNT" ? [Parser.preceded(tok("*"), expect(")")).pipe(Parser.as("*"))] : [], Parser.seq(expression, name === "GROUP_CONCAT" ? Parser.opt(Parser.preceded(Parser.seq(tok(";"), expect("SEPARATOR"), expect("=")), Parser.alt(string, unexpectedHere("a string")))) : Parser.succeed(Option.none()), expect(")")))), hook(() => {
+	ctx.inAggregate = false;
+}))).pipe(Parser.map(([distinct, body]) => {
+	if (body === "*") return aggregate$1("COUNT", "*", { distinct });
+	const [e, sep] = body;
+	return Option.isSome(sep) ? aggregate$1(name, e, {
+		distinct,
+		separator: sep.value.value
+	}) : aggregate$1(name, e, { distinct });
+}));
+const BUILT_INS = Record.keys(builtInArity);
+/** The built-in a token names (`peekKind(BUILT_INS)` lets only those through). */
+const builtInName = (t) => isBuiltInName(t.kind) ? t.kind : unexpected(t, "a function");
+const builtInCall = Parser.alt(Parser.preceded(peekKind(BUILT_INS.filter((n) => n !== "BOUND" && builtInArity[n][1] > 0)), Parser.seq(anyToken, expressionList)).pipe(Parser.map(([t, args]) => {
+	const name = builtInName(t);
+	const [min, max] = builtInArity[name];
+	return args.length < min || args.length > max ? fail(`${name} expects ${min === max ? min : `${min} to ${max}`} arguments`, t.start) : operation(name, ...args);
+})), Parser.preceded(peekKind(BUILT_INS.filter((n) => builtInArity[n][1] === 0)), Parser.seq(anyToken, Parser.alt(Parser.seq(nil, anyToken, anyToken), unexpectedHere("'()'")))).pipe(Parser.map(([t]) => operation(builtInName(t)))), Parser.preceded(Parser.seq(tok("BOUND"), expect("(")), Parser.terminated(variableOrError, expect(")"))).pipe(Parser.map((v) => operation("BOUND", v))), Parser.preceded(tok("EXISTS"), groupGraphPatternInExpression).pipe(Parser.map((g) => exists(g, false))), Parser.preceded(Parser.seq(tok("NOT"), expect("EXISTS")), groupGraphPatternInExpression).pipe(Parser.map((g) => exists(g, true))), ...AGGREGATES.map((name) => Parser.preceded(peekKind([name]), aggregate(name))));
+const exprTripleTerm = Parser.preceded(tok("<<("), Parser.seq(Parser.alt(variable, iriOrError), Parser.alt(tok("a").pipe(Parser.as(rdfType)), variable, iriOrError), Parser.alt(Parser.suspend(() => exprTripleTerm), variable, dataTerm), expect(")>>"))).pipe(Parser.map(([s, p, o]) => triple(s, p, o)));
+const primary = Parser.alt(variable, Parser.seq(iri, Parser.opt(Parser.preceded(Parser.peek(tok("(")), functionArgs))).pipe(Parser.map(([i, args]) => Option.isSome(args) ? functionCall(i, args.value[0], args.value[1]) : i)), rdfLiteral, numericLiteral, booleanLiteral, Parser.preceded(startsBuiltIn, builtInCall), Parser.preceded(Parser.peek(tok("(")), brackettedExpression), exprTripleTerm, unexpectedHere("an expression"));
+const unary = Parser.alt(Parser.preceded(tok("!"), Parser.suspend(() => unary)).pipe(Parser.map((e) => operation("!", e))), signedNumber, Parser.seq(Parser.alt(tok("+"), tok("-")), primary).pipe(Parser.map(([op, e]) => operation(op.kind === "+" ? "UPLUS" : "UMINUS", e))), primary);
+/** Matches the token of an operator, typed as that operator. */
+const operator = (o) => tok(o).pipe(Parser.map(() => o));
+const leftAssoc = (operand, ops) => Parser.seq(operand, Parser.repeat(Parser.seq(Parser.alt(...ops.map(operator)), operand))).pipe(Parser.map(([first, rest]) => rest.reduce((left, [op, right]) => operation(op, left, right), first)));
+const additive = leftAssoc(leftAssoc(unary, ["*", "/"]), ["+", "-"]);
+const expressionDef = leftAssoc(leftAssoc(Parser.seq(additive, Parser.opt(Parser.alt(Parser.seq(Parser.alt(...[
+	"=",
+	"!=",
+	"<",
+	">",
+	"<=",
+	">="
+].map(operator)), additive).pipe(Parser.map(([op, right]) => (left) => operation(op, left, right))), Parser.preceded(tok("IN"), expressionList).pipe(Parser.map((list) => (left) => operation("IN", left, ...list))), Parser.preceded(Parser.seq(tok("NOT"), tok("IN")), expressionList).pipe(Parser.map((list) => (left) => operation("NOT IN", left, ...list)))))).pipe(Parser.map(([left, rest]) => Option.isSome(rest) ? rest.value(left) : left)), ["&&"]), ["||"]);
+const constraint = Parser.alt(Parser.preceded(Parser.peek(tok("(")), brackettedExpression), Parser.preceded(startsBuiltIn, builtInCall), Parser.seq(iri, Parser.alt(Parser.preceded(Parser.peek(tok("(")), functionArgs), unexpectedHere("'('"))).pipe(Parser.map(([i, [args, distinct]]) => functionCall(i, args, distinct))), unexpectedHere("a constraint"));
+/** Whether a constraint (`(`, a built-in, an IRI) starts here. */
+const startsConstraint = Parser.peek(take("a constraint", (t) => t.kind === "(" || isBuiltInStart(t) || isIri(t) ? taken : notTaken));
+const patternTriples = triplesGrammar(true);
+const templateTriples = triplesGrammar(false);
+const varOrIri = Parser.alt(variable, iriOrError);
+const GPNT = kindSet([
+	"OPTIONAL",
+	"MINUS",
+	"GRAPH",
+	"SERVICE",
+	"FILTER",
+	"BIND",
+	"VALUES"
+]);
+const graphPatternNotTriples = select([
+	[["{"], Parser.seq(groupGraphPattern, Parser.repeat(Parser.preceded(tok("UNION"), groupGraphPattern))).pipe(Parser.map(([first, rest]) => Arr.isReadonlyArrayEmpty(rest) ? first : union([first, ...rest])))],
+	[["OPTIONAL"], Parser.preceded(anyToken, groupGraphPattern).pipe(Parser.map((g) => optional(g)))],
+	[["MINUS"], Parser.preceded(anyToken, groupGraphPattern).pipe(Parser.map((g) => minus(g)))],
+	[["GRAPH"], Parser.preceded(anyToken, Parser.seq(varOrIri, groupGraphPattern)).pipe(Parser.map(([name, g]) => graph(name, g)))],
+	[["SERVICE"], Parser.preceded(anyToken, Parser.seq(eat("SILENT"), varOrIri, groupGraphPattern)).pipe(Parser.map(([silent, name, g]) => service(name, g, silent)))],
+	[["FILTER"], Parser.preceded(anyToken, constraint).pipe(Parser.map((e) => filter(e)))],
+	[["BIND"], Parser.preceded(Parser.seq(anyToken, expect("(")), Parser.seq(expression, Parser.preceded(expect("AS"), variableOrError), expect(")"))).pipe(Parser.map(([e, v]) => bind(e, v)))],
+	[["VALUES"], Parser.preceded(anyToken, dataBlock)]
+]);
+const startsGPNT = Parser.peek(take("a graph pattern", (t) => t.kind === "{" || t.type === "WORD" && GPNT.has(t.kind) ? taken : notTaken));
+const gpntItem = Parser.preceded(startsGPNT, Parser.seq(hook((t) => offsetOf(t)), graphPatternNotTriples, eat("."))).pipe(Parser.map(([at, pattern]) => {
+	if (!Predicate.isTagged(pattern, "Filter")) ctx.triples[ctx.triples.length - 1] = ctx.patternContext();
+	return {
+		_tag: "Pattern",
+		pattern,
+		at
+	};
+}));
+const isGPNTStart = (t) => t.type !== "ERROR" && (t.kind === "{" || t.type === "WORD" && GPNT.has(t.kind));
+/** A triples block; one not ended by `.` must be followed by a pattern or `}`. */
+const triplesItem = Parser.preceded(startsTriples, Parser.seq(patternTriples.triplesBlock, hook((t) => t))).pipe(Parser.map(([[triples, dot], t]) => {
+	if (!dot && t.kind !== "}" && !isGPNTStart(t)) unexpectedAt(t, "'.' or '}'");
+	return {
+		_tag: "Triples",
+		triples
+	};
+}));
+/** The elements of a group, up to its `}` (not consumed). */
+const groupItems = Parser.repeat(Parser.preceded(Parser.not(tok("}")), Parser.alt(gpntItem, triplesItem, unexpectedHere())));
+/**
+* Adds a group item to the patterns read so far; the failure if it is a
+* `BIND` of a variable already in scope.
+*/
+const addGroupItem = (patterns, item) => {
+	if (Predicate.isTagged(item, "Triples")) {
+		const last = patterns[patterns.length - 1];
+		if (Predicate.isTagged(last, "Bgp")) patterns[patterns.length - 1] = bgp([...last.triples, ...item.triples]);
+		else patterns.push(bgp(item.triples));
+		return Option.none();
+	}
+	const p = item.pattern;
+	if (Predicate.isTagged(p, "Bind")) {
+		const name = p.variable.value;
+		if (patterns.some((q) => inScopeVariables(q).includes(name))) return Option.some(new Failure(`BIND variable ?${name} is already in scope`, item.at));
+	}
+	patterns.push(p);
+	return Option.none();
+};
+const assembleGroup = (items) => {
+	const patterns = [];
+	return Option.match(Arr.findFirst(items, (item) => addGroupItem(patterns, item)), {
+		onNone: () => Result.succeed(group(patterns)),
+		onSome: Result.fail
+	});
+};
+const subSelect = Parser.suspend(() => subSelectDef);
+const groupGraphPatternDef = Parser.preceded(expect("{"), Parser.alt(Parser.preceded(Parser.peek(tok("SELECT")), subSelect), inContext(() => ctx.patternContext(), Parser.terminated(groupItems, expect("}"))).pipe(Parser.tryMap(assembleGroup), Parser.cut)));
+let prologue = { value: () => ({ prefixes: {} }) };
+/** Skips the prologue (names are resolved by the lexer), recording `VERSION`. */
+const prologueDecls = Parser.asVoid(Parser.repeat(select([
+	[["BASE"], Parser.preceded(anyToken, Parser.alt(take("an IRI", (t) => t.type === "IRI" ? Option.some(t) : notTaken), unexpectedHere("an IRI")))],
+	[["PREFIX"], Parser.preceded(anyToken, Parser.seq(Parser.alt(take("a prefix name", (t) => t.type === "PNAME" && t.value === "" ? Option.some(t) : notTaken), unexpectedHere("a prefix name")), Parser.alt(take("an IRI", (t) => t.type === "IRI" ? Option.some(t) : notTaken), unexpectedHere("an IRI"))))],
+	[["VERSION"], Parser.preceded(anyToken, Parser.alt(take("a version string", (t) => {
+		if (t.type !== "STRING" || t.extra === "long") return notTaken;
+		ctx.version = Option.some(t.value);
+		return Option.some(t);
+	}), unexpectedHere("a version string")))]
+])));
+/** `query` with its dataset clause; an absent clause leaves the member absent. */
+const withDataset = (query, dataset) => Option.isNone(dataset) ? query : {
+	...query,
+	dataset: dataset.value
+};
+const withAggregates = (p) => withFlags(true, Option.none(), p);
+const groupCondition = Parser.alt(variable.pipe(Parser.map((v) => ({ expression: v }))), Parser.preceded(tok("("), Parser.seq(expression, Parser.opt(Parser.preceded(tok("AS"), variableOrError)), expect(")"))).pipe(Parser.map(([e, v]) => Option.isSome(v) ? {
+	expression: e,
+	variable: v.value
+} : { expression: e })), Parser.preceded(Parser.peek(take("a constraint", (t) => isBuiltInStart(t) || isIri(t) ? taken : notTaken)), constraint).pipe(Parser.map((e) => ({ expression: e }))));
+const orderCondition = Parser.alt(Parser.seq(Parser.alt(tok("ASC"), tok("DESC")), Parser.alt(Parser.preceded(Parser.peek(tok("(")), brackettedExpression), unexpectedHere("'('"))).pipe(Parser.map(([d, e]) => ({
+	expression: e,
+	descending: d.kind === "DESC"
+}))), variable.pipe(Parser.map((v) => ({
+	expression: v,
+	descending: false
+}))), Parser.preceded(startsConstraint, constraint).pipe(Parser.map((e) => ({
+	expression: e,
+	descending: false
+}))));
+const atLeastOne = (p, label) => Parser.seq(Parser.repeat(p), hook((t) => t)).pipe(Parser.tryMap(([items, t]) => Arr.isReadonlyArrayEmpty(items) ? Result.fail(new Failure(t.type === "ERROR" ? t.value : `Unexpected ${describe(t)}, expected ${label}`, offsetOf(t))) : Result.succeed(items)), Parser.cut);
+const integer = Parser.alt(take("an integer", (t) => t.type === "INTEGER" ? Option.some(Number(t.value)) : notTaken), unexpectedHere("an integer"));
+const solutionModifiers = Parser.seq(Parser.opt(Parser.preceded(Parser.seq(tok("GROUP"), expect("BY")), atLeastOne(groupCondition, "a grouping condition"))), Parser.opt(Parser.preceded(tok("HAVING"), Parser.seq(withAggregates(Parser.repeat(Parser.preceded(startsConstraint, constraint))), hook((t) => t))).pipe(Parser.map(([having, t]) => Arr.isReadonlyArrayNonEmpty(having) ? having : unexpectedAt(t, "a HAVING condition")))), Parser.opt(Parser.preceded(Parser.seq(tok("ORDER"), expect("BY")), Parser.seq(withAggregates(Parser.repeat(orderCondition)), hook((t) => t))).pipe(Parser.map(([orderBy, t]) => Arr.isReadonlyArrayNonEmpty(orderBy) ? orderBy : unexpectedAt(t, "an ORDER BY condition")))), Parser.alt(Parser.seq(Parser.preceded(tok("LIMIT"), integer).pipe(Parser.map(Option.some)), Parser.opt(Parser.preceded(tok("OFFSET"), integer))), Parser.seq(Parser.preceded(tok("OFFSET"), integer).pipe(Parser.map(Option.some)), Parser.opt(Parser.preceded(tok("LIMIT"), integer))).pipe(Parser.map(([offset, limit]) => [limit, offset])), Parser.succeed([Option.none(), Option.none()]))).pipe(Parser.map(([groupBy, having, orderBy, [limit, offset]]) => {
+	const modifiers = {
+		groupBy: Option.getOrElse(groupBy, () => []),
+		having: Option.getOrElse(having, () => []),
+		orderBy: Option.getOrElse(orderBy, () => [])
+	};
+	const limited = Option.isNone(limit) ? modifiers : {
+		...modifiers,
+		limit: limit.value
+	};
+	return Option.isNone(offset) ? limited : {
+		...limited,
+		offset: offset.value
+	};
+}));
+const datasetClauses = Parser.repeat(Parser.preceded(tok("FROM"), Parser.seq(eat("NAMED"), iriOrError))).pipe(Parser.map((clauses) => Arr.isReadonlyArrayEmpty(clauses) ? Option.none() : Option.some({
+	default: clauses.filter(([named]) => !named).map(([, i]) => i),
+	named: clauses.filter(([named]) => named).map(([, i]) => i)
+})));
+const valuesClause = Parser.opt(Parser.preceded(tok("VALUES"), dataBlock));
+const projectionItem = Parser.alt(variable, Parser.preceded(tok("("), Parser.seq(withAggregates(expression), Parser.preceded(expect("AS"), variableOrError), expect(")"))).pipe(Parser.map(([e, v]) => ({
+	_tag: "Projection",
+	expression: e,
+	variable: v
+}))));
+const selectQuery = (sub) => Parser.preceded(expect("SELECT"), Parser.seq(Parser.alt(tok("DISTINCT").pipe(Parser.as([true, false])), tok("REDUCED").pipe(Parser.as([false, true])), Parser.succeed([false, false])), Parser.alt(tok("*").pipe(Parser.as("*")), atLeastOne(projectionItem, "a variable, expression or *")), sub ? Parser.succeed(Option.none()) : datasetClauses, Parser.preceded(eat("WHERE"), groupGraphPattern), solutionModifiers)).pipe(Parser.map(([[distinct, reduced], projection, dataset, where, modifiers]) => withDataset({
+	_tag: "Select",
+	prologue: prologue.value(),
+	distinct,
+	reduced,
+	projection,
+	where,
+	...modifiers
+}, dataset)));
+const constructTemplate = Parser.delimited(tok("{"), Parser.cut(inContext(() => ({
+	variables: true,
+	blankNodes: true,
+	scope: ++ctx.scopeCounter,
+	labels: ctx.templateLabels
+}), templateTriples.triplesTemplate)), expect("}")).pipe(Parser.map((t) => t.filter(isTriplePattern)));
+const constructQuery = Parser.preceded(tok("CONSTRUCT"), Parser.alt(Parser.seq(constructTemplate, datasetClauses, Parser.preceded(eat("WHERE"), groupGraphPattern), solutionModifiers).pipe(Parser.map(([template, dataset, where, modifiers]) => withDataset({
+	_tag: "Construct",
+	prologue: prologue.value(),
+	template,
+	where,
+	...modifiers
+}, dataset))), Parser.seq(datasetClauses, Parser.delimited(Parser.seq(expect("WHERE"), expect("{")), inContext(() => ctx.patternContext(), templateTriples.triplesTemplate), expect("}")), solutionModifiers).pipe(Parser.map(([dataset, triples, modifiers]) => {
+	const template = triples.filter(isTriplePattern);
+	return withDataset({
+		_tag: "Construct",
+		prologue: prologue.value(),
+		template,
+		where: group(Arr.isReadonlyArrayNonEmpty(template) ? [bgp(template)] : []),
+		short: true,
+		...modifiers
+	}, dataset);
+}))));
+const describeQuery = Parser.preceded(tok("DESCRIBE"), Parser.seq(Parser.alt(tok("*").pipe(Parser.as("*")), atLeastOne(Parser.alt(variable, iri), "a variable, IRI or *")), datasetClauses, Parser.alt(Parser.preceded(Parser.peek(Parser.alt(tok("WHERE"), tok("{"))), Parser.preceded(eat("WHERE"), groupGraphPattern)), Parser.succeed(group([]))), solutionModifiers)).pipe(Parser.map(([terms, dataset, where, modifiers]) => withDataset({
+	_tag: "Describe",
+	prologue: prologue.value(),
+	terms,
+	where,
+	...modifiers
+}, dataset)));
+const askQuery = Parser.preceded(tok("ASK"), Parser.seq(datasetClauses, Parser.preceded(eat("WHERE"), groupGraphPattern), solutionModifiers)).pipe(Parser.map(([dataset, where, modifiers]) => withDataset({
+	_tag: "Ask",
+	prologue: prologue.value(),
+	where,
+	...modifiers
+}, dataset)));
+const subSelectDef = Parser.seq(withFlags(false, Option.none(), Parser.seq(selectQuery(true), valuesClause)), Parser.preceded(expect("}"), hook((t) => offsetOf(t)))).pipe(Parser.map(([[query, values], at]) => {
+	const sub = Option.isSome(values) ? {
+		...query,
+		values: values.value
+	} : query;
+	validateSelect(sub, at);
+	return group([subSelect$1(sub)]);
+}));
+/** The variable a `GROUP BY` condition binds: its `AS` variable, or the variable it is. */
+const groupKey = (g) => g.variable !== void 0 ? Option.some(g.variable.value) : isVariable(g.expression) ? Option.some(g.expression.value) : Option.none();
+const validateSelect = (query, offset) => {
+	const projection = query.projection;
+	if (projection !== "*") {
+		const grouped = Arr.isReadonlyArrayNonEmpty(query.groupBy) || projection.some((p) => !isVariable(p) && containsAggregate(p.expression));
+		const inScope = MutableHashSet.fromIterable(grouped ? [] : inScopeVariables(query.where));
+		Arr.forEach(Arr.getSomes(query.groupBy.map(groupKey)), (v) => MutableHashSet.add(inScope, v));
+		(query.values?.variables ?? []).forEach((v) => MutableHashSet.add(inScope, v.value));
+		const seen = MutableHashSet.empty();
+		projection.forEach((item) => {
+			if (isVariable(item)) {
+				MutableHashSet.add(seen, item.value);
+				return;
+			}
+			const name = item.variable.value;
+			if (MutableHashSet.has(inScope, name) || MutableHashSet.has(seen, name)) fail(`Variable ?${name} is already in scope`, offset);
+			MutableHashSet.add(seen, name);
+		});
+	}
+	validateGrouping(query, offset);
+};
+const validateGrouping = (query, offset) => {
+	const projectionExprs = Predicate.isTagged(query, "Select") && query.projection !== "*" ? query.projection.flatMap((p) => isVariable(p) ? [] : [p.expression]) : [];
+	const grouped = Arr.isReadonlyArrayNonEmpty(query.groupBy) || projectionExprs.some(containsAggregate) || query.having.some(containsAggregate) || query.orderBy.some((o) => containsAggregate(o.expression));
+	query.groupBy.forEach((g) => {
+		if (containsAggregate(g.expression)) fail("Aggregates are not allowed in GROUP BY", offset);
+	});
+	if (!grouped || !Predicate.isTagged(query, "Select")) return;
+	const projection = query.projection;
+	if (projection === "*") return fail("SELECT * is not allowed with GROUP BY or aggregates", offset);
+	const allowed = MutableHashSet.fromIterable(query.values?.variables.map((v) => v.value) ?? []);
+	Arr.forEach(Arr.getSomes(query.groupBy.map(groupKey)), (v) => MutableHashSet.add(allowed, v));
+	const checkVariable = (v) => {
+		if (!MutableHashSet.has(allowed, v)) fail(`Variable ?${v} is not grouped`, offset);
+	};
+	const checkExpr = (e) => {
+		Match.value(e).pipe(Match.tag("Variable", (v) => checkVariable(v.value)), Match.tag("Operation", "FunctionCall", (call) => call.args.forEach(checkExpr)), Match.tag("Triple", (x) => expressionVariables(x).forEach(checkVariable)), Match.orElse(() => void 0));
+	};
+	projection.forEach((item) => {
+		if (isVariable(item)) checkVariable(item.value);
+		else {
+			checkExpr(item.expression);
+			MutableHashSet.add(allowed, item.variable.value);
+		}
+	});
+};
+const checked = (f) => (a) => catchFailure(() => {
+	f(a);
+	return a;
+});
+const queryUnit = Compiler.jit(Parser.preceded(Parser.seq(start, prologueDecls), Parser.seq(select([
+	[["SELECT"], selectQuery(false)],
+	[["CONSTRUCT"], constructQuery],
+	[["DESCRIBE"], describeQuery],
+	[["ASK"], askQuery]
+], unexpectedHere("SELECT, CONSTRUCT, DESCRIBE or ASK")), valuesClause, Parser.alt(Parser.eof, unexpectedHere())).pipe(Parser.map(([query, values]) => Option.isSome(values) ? {
+	...query,
+	values: values.value
+} : query), Parser.tryMap(checked((query) => {
+	if (Predicate.isTagged(query, "Select")) validateSelect(query, 0);
+	else validateGrouping(query, 0);
+})), Parser.cut)));
+const quadPattern = Parser.delimited(expect("{"), Parser.repeat(Parser.preceded(Parser.not(tok("}")), Parser.alt(Parser.preceded(tok("GRAPH"), Parser.seq(Parser.preceded(hook((t) => {
+	if (t.type === "VAR" && !ctx.tc.variables) fail("Variables are not allowed here", t.start);
+}), varOrIri), Parser.delimited(expect("{"), templateTriples.triplesTemplate, expect("}")), eat("."))).pipe(Parser.map(([g, triples]) => triples.filter(isTriplePattern).map((tp) => quadPattern$1(tp.subject, tp.predicate, tp.object, g)))), Parser.terminated(Parser.preceded(Parser.alt(startsTriples, unexpectedHere()), templateTriples.triplesTemplate), Parser.alt(Parser.peek(Parser.alt(tok("}"), tok("GRAPH"))), unexpectedHere("'.' or '}'"))).pipe(Parser.map((triples) => triples.filter(isTriplePattern).map((tp) => quadPattern$1(tp.subject, tp.predicate, tp.object, defaultGraph))))))), expect("}")).pipe(Parser.map((lists) => lists.flat()));
+const templateContext = (blankNodes) => () => ({
+	variables: true,
+	blankNodes,
+	scope: ctx.opIndex,
+	labels: empty()
+});
+const quadData = (blankNodes) => inContext(() => ({
+	variables: false,
+	blankNodes,
+	scope: ctx.opIndex,
+	labels: ctx.templateLabels
+}), quadPattern).pipe(Parser.map((quads) => quads.map((q) => new Quad(q.subject, q.predicate, q.object, q.graph))));
+const usingClauses = Parser.repeat(Parser.preceded(tok("USING"), Parser.seq(eat("NAMED"), iriOrError)));
+const modify = (deleteFirst) => Parser.seq(deleteFirst ? Parser.seq(inContext(templateContext(false), quadPattern), Parser.opt(Parser.preceded(tok("INSERT"), inContext(templateContext(true), quadPattern)))).pipe(Parser.map(([del, ins]) => [del, Option.getOrElse(ins, () => [])])) : inContext(templateContext(true), quadPattern).pipe(Parser.map((ins) => [[], ins])), usingClauses, Parser.preceded(expect("WHERE"), groupGraphPattern)).pipe(Parser.map(([[del, ins], using, where]) => {
+	const op = {
+		_tag: "Modify",
+		delete: del,
+		insert: ins,
+		where
+	};
+	return Arr.isReadonlyArrayEmpty(using) ? op : {
+		...op,
+		using: {
+			default: using.filter(([named]) => !named).map(([, i]) => i),
+			named: using.filter(([named]) => named).map(([, i]) => i)
+		}
+	};
+}));
+const graphRefAll = Parser.alt(tok("DEFAULT").pipe(Parser.as({ _tag: "Default" })), tok("NAMED").pipe(Parser.as({ _tag: "Named" })), tok("ALL").pipe(Parser.as({ _tag: "All" })), Parser.preceded(expect("GRAPH"), iriOrError));
+const graphOrDefault = Parser.alt(tok("DEFAULT").pipe(Parser.as(defaultGraph)), Parser.preceded(eat("GRAPH"), iriOrError));
+const update1 = select([
+	[["LOAD"], Parser.preceded(anyToken, Parser.seq(eat("SILENT"), iriOrError, Parser.opt(Parser.preceded(Parser.seq(tok("INTO"), expect("GRAPH")), iriOrError)))).pipe(Parser.map(([silent, source, dest]) => Option.isSome(dest) ? {
+		_tag: "Load",
+		silent,
+		source,
+		destination: dest.value
+	} : {
+		_tag: "Load",
+		silent,
+		source
+	}))],
+	[["CLEAR", "DROP"], Parser.seq(anyToken, eat("SILENT"), graphRefAll).pipe(Parser.map(([t, silent, target]) => ({
+		_tag: t.kind === "CLEAR" ? "Clear" : "Drop",
+		silent,
+		target
+	})))],
+	[["CREATE"], Parser.preceded(anyToken, Parser.seq(eat("SILENT"), Parser.preceded(expect("GRAPH"), iriOrError))).pipe(Parser.map(([silent, graph]) => ({
+		_tag: "Create",
+		silent,
+		graph
+	})))],
+	[[
+		"ADD",
+		"MOVE",
+		"COPY"
+	], Parser.seq(anyToken, eat("SILENT"), graphOrDefault, Parser.preceded(expect("TO"), graphOrDefault)).pipe(Parser.map(([t, silent, source, destination]) => ({
+		_tag: t.kind === "ADD" ? "Add" : t.kind === "MOVE" ? "Move" : "Copy",
+		silent,
+		source,
+		destination
+	})))],
+	[["INSERT"], Parser.preceded(anyToken, Parser.alt(Parser.preceded(tok("DATA"), quadData(true)).pipe(Parser.map((quads) => ({
+		_tag: "InsertData",
+		quads
+	}))), modify(false)))],
+	[["DELETE"], Parser.preceded(anyToken, Parser.alt(Parser.preceded(tok("DATA"), quadData(false)).pipe(Parser.map((quads) => ({
+		_tag: "DeleteData",
+		quads
+	}))), Parser.preceded(tok("WHERE"), inContext(() => ({
+		variables: true,
+		blankNodes: false,
+		scope: ++ctx.scopeCounter,
+		labels: ctx.patternLabels
+	}), quadPattern)).pipe(Parser.map((patterns) => ({
+		_tag: "DeleteWhere",
+		patterns
+	}))), modify(true)))],
+	[["WITH"], Parser.seq(Parser.preceded(anyToken, iriOrError), Parser.alt(Parser.preceded(tok("DELETE"), modify(true)), Parser.preceded(expect("INSERT"), modify(false)))).pipe(Parser.map(([i, { _tag, ...rest }]) => ({
+		_tag,
+		with: i,
+		...rest
+	})))]
+], unexpectedHere("an update operation"));
+const update1Indexed = Parser.terminated(update1, hook(() => {
+	ctx.opIndex++;
+}));
+const updateUnit = Compiler.jit(Parser.preceded(Parser.seq(start, prologueDecls), Parser.terminated(Parser.opt(Parser.preceded(Parser.not(Parser.eof), Parser.separated(update1Indexed, Parser.seq(tok(";"), prologueDecls, Parser.not(Parser.eof)), { min: 1 }))), Parser.seq(Parser.opt(Parser.seq(tok(";"), prologueDecls)), Parser.alt(Parser.eof, unexpectedHere("';'"))))).pipe(Parser.map((ops) => update(Option.getOrElse(ops, () => []), prologue.value()))));
+const run = (grammar, input, baseIri, prefixes) => {
+	const tokens = tokenize(input);
+	const resolved = resolve(tokens, baseIri, prefixes);
+	fresh = () => new Context(input);
+	ctx = fresh();
+	prologue = { value: () => {
+		const declared = { prefixes: { ...resolved.prefixes } };
+		const based = Option.isNone(resolved.base) ? declared : {
+			...declared,
+			base: resolved.base.value
+		};
+		return Option.isNone(ctx.version) ? based : {
+			...based,
+			version: ctx.version.value
+		};
+	} };
+	const parsed = catchFailure(() => Parser.parse(grammar, tokens));
+	if (Result.isFailure(parsed)) return Result.fail(parsed.failure);
+	const result = parsed.success;
+	if (Result.isSuccess(result)) return Result.succeed(result.success);
+	const error = result.failure;
+	if (error.cause !== void 0) return Result.fail(error.cause);
+	const t = tokenAt(tokens, error.offset);
+	if (t.type === "ERROR") return Result.fail(new Failure(t.value, t.start));
+	return Result.fail(new Failure(`Unexpected ${describe(t)}`, offsetOf(t)));
+};
+/** Parses a query against a base IRI (if any) and initial prefixes. */
+const parseQuery$1 = (input, baseIri, prefixes) => run(queryUnit, input, baseIri, prefixes);
+/** Parses an update request against a base IRI (if any) and initial prefixes. */
+const parseUpdate$1 = (input, baseIri, prefixes) => run(updateUnit, input, baseIri, prefixes);
+// src/sparql/Parser.ts
+/**
+* A complete parser for SPARQL 1.1 Query and Update, written with
+* `@thomasfosterau/effect-parse` (see `internal/parser.ts`), including the SPARQL 1.2 additions (triple terms, reified triples,
+* annotations, `VERSION`, directional language tags and the new built-in
+* functions).
+*
+* The parser expands all abbreviations (prefixed names, relative IRIs,
+* `a`, blank node property lists, collections, reifiers and annotations)
+* and enforces the static constraints of the specification (blank node
+* label scoping, grouping rules, `BIND`/`AS` scoping, `VALUES` arity,
+* variable-free `INSERT DATA`, blank-node-free `DELETE` templates, …).
+*
+* @since 0.1.0
+*/
+var Parser_exports = /* @__PURE__ */ __exportAll({
+	SparqlParseError: () => SparqlParseError,
+	parse: () => parse,
+	parseQuery: () => parseQuery,
+	parseQueryResult: () => parseQueryResult,
+	parseQueryUnsafe: () => parseQueryUnsafe,
+	parseUpdate: () => parseUpdate,
+	parseUpdateResult: () => parseUpdateResult,
+	parseUpdateUnsafe: () => parseUpdateUnsafe
+});
+/**
+* A syntax (or static semantic) error in a SPARQL query or update.
+*
+* @since 0.1.0
+* @category errors
+*/
+var SparqlParseError = class extends Schema.TaggedError()("SparqlParseError", {
+	message: Schema.String,
+	/** 1-based line of the error. */
+	line: Schema.Number,
+	/** 1-based column of the error. */
+	column: Schema.Number,
+	/** 0-based character offset of the error. */
+	offset: Schema.Number
+}) {};
+const position = (input, offset) => {
+	const before = input.slice(0, Math.max(0, Math.min(offset, input.length)));
+	const lineStart = before.lastIndexOf("\n") + 1;
+	return {
+		line: before.split("\n").length,
+		column: offset - lineStart + 1
+	};
+};
+/** The base IRI and prefixes of `options`, as the internal parser takes them. */
+const internalOptions = (options) => [Option.fromUndefinedOr(options?.baseIri), options?.prefixes ?? {}];
+const toError = (input) => (e) => {
+	const { line, column } = position(input, e.offset);
+	return new SparqlParseError({
+		message: `${e.message} (line ${line}, column ${column})`,
+		line,
+		column,
+		offset: e.offset
+	});
+};
+/**
+* Parses a SPARQL query, returning a `Result`.
+*
+* @since 0.1.0
+* @category parsing
+*/
+const parseQueryResult = (input, options) => Result.mapError(parseQuery$1(input, ...internalOptions(options)), toError(input));
+/**
+* Parses a SPARQL update request, returning a `Result`.
+*
+* @since 0.1.0
+* @category parsing
+*/
+const parseUpdateResult = (input, options) => Result.mapError(parseUpdate$1(input, ...internalOptions(options)), toError(input));
+/**
+* Parses a SPARQL query.
+*
+* @since 0.1.0
+* @category parsing
+*/
+const parseQuery = (input, options) => Effect.suspend(() => Effect.fromResult(parseQueryResult(input, options)));
+/**
+* Parses a SPARQL update request.
+*
+* @since 0.1.0
+* @category parsing
+*/
+const parseUpdate = (input, options) => Effect.suspend(() => Effect.fromResult(parseUpdateResult(input, options)));
+/**
+* Parses either a query or an update request: the text is parsed as a query
+* first and, if that fails, as an update.
+*
+* @since 0.1.0
+* @category parsing
+*/
+const parse = (input, options) => Effect.suspend(() => {
+	const q = parseQueryResult(input, options);
+	if (Result.isSuccess(q)) return Effect.succeed(q.success);
+	const u = parseUpdateResult(input, options);
+	if (Result.isSuccess(u)) return Effect.succeed(u.success);
+	return Effect.fail(q.failure.offset >= u.failure.offset ? q.failure : u.failure);
+});
+/**
+* Parses a SPARQL query, throwing a `SparqlParseError` on failure.
+*
+* @since 0.1.0
+* @category parsing
+*/
+const parseQueryUnsafe = (input, options) => {
+	const r = parseQueryResult(input, options);
+	if (Result.isFailure(r)) throw r.failure;
+	return r.success;
+};
+/**
+* Parses a SPARQL update request, throwing a `SparqlParseError` on failure.
+*
+* @since 0.1.0
+* @category parsing
+*/
+const parseUpdateUnsafe = (input, options) => {
+	const r = parseUpdateResult(input, options);
+	if (Result.isFailure(r)) throw r.failure;
+	return r.success;
+};
+export { parseQueryResult as a, parseUpdateResult as c, parseQuery as i, parseUpdateUnsafe as l, SparqlParseError as n, parseQueryUnsafe as o, parse as r, parseUpdate as s, Parser_exports as t };
+
+//# sourceMappingURL=Parser-xARsOWXk.mjs.map