@thomasfosterau/effect-rdf 0.0.0 → 0.1.0

package/dist/Ast-CPRZmBvk.mjs

@@ -0,0 +1,552 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { K as isTriple, O as defaultGraph, q as isVariable } from "./Term-CFLG1qu4.mjs";
+import { r as emptySet } from "./stringMap-D5YIpYtR.mjs";
+import * as Predicate from "effect/Predicate";
+import * as Match from "effect/Match";
+// src/sparql/Ast.ts
+/**
+* The abstract syntax tree of SPARQL 1.1 (and SPARQL 1.2) queries and
+* updates.
+*
+* The AST stays close to the surface syntax (group graph patterns, solution
+* modifiers, update operations) while using the core `Term` model for all
+* IRIs, literals, blank nodes, variables and triple terms. Abbreviated
+* syntax (prefixed names, `a`, blank node property lists, collections,
+* reifiers and annotations) is expanded by the parser, so every IRI in the
+* tree is absolute.
+*
+* All nodes are plain immutable objects discriminated by `_tag`; the
+* constructors in this module are the recommended way to build them.
+*
+* @since 0.1.0
+*/
+var Ast_exports = /* @__PURE__ */ __exportAll({
+	aggregate: () => aggregate,
+	alternative: () => alternative,
+	ask: () => ask,
+	bgp: () => bgp,
+	bind: () => bind,
+	builtInArity: () => builtInArity,
+	construct: () => construct,
+	containsAggregate: () => containsAggregate,
+	describe: () => describe,
+	emptyPrologue: () => emptyPrologue,
+	exists: () => exists,
+	expressionVariables: () => expressionVariables,
+	filter: () => filter,
+	functionCall: () => functionCall,
+	graph: () => graph,
+	group: () => group,
+	inScopeVariables: () => inScopeVariables,
+	inverse: () => inverse,
+	isBuiltInName: () => isBuiltInName,
+	isPath: () => isPath,
+	isQuery: () => isQuery,
+	isUpdate: () => isUpdate,
+	link: () => link,
+	minus: () => minus,
+	negated: () => negated,
+	oneOrMore: () => oneOrMore,
+	operation: () => operation,
+	optional: () => optional,
+	pathPattern: () => pathPattern,
+	projectedVariables: () => projectedVariables,
+	projection: () => projection,
+	quadPattern: () => quadPattern,
+	select: () => select,
+	sequence: () => sequence,
+	service: () => service,
+	subSelect: () => subSelect,
+	triplePattern: () => triplePattern,
+	union: () => union,
+	update: () => update,
+	values: () => values,
+	zeroOrMore: () => zeroOrMore,
+	zeroOrOne: () => zeroOrOne
+});
+/**
+* @since 0.1.0
+* @category guards
+*/
+const isPath = (u) => Predicate.hasProperty(u, "_tag") && Predicate.isString(u._tag) && u._tag.startsWith("Path");
+/**
+* Arity of each built-in function: `[min, max]` (`max` = `Infinity` for
+* variadic functions).
+*
+* @since 0.1.0
+* @category models
+*/
+const builtInArity = {
+	STR: [1, 1],
+	LANG: [1, 1],
+	LANGMATCHES: [2, 2],
+	LANGDIR: [1, 1],
+	DATATYPE: [1, 1],
+	BOUND: [1, 1],
+	IRI: [1, 1],
+	URI: [1, 1],
+	BNODE: [0, 1],
+	RAND: [0, 0],
+	ABS: [1, 1],
+	CEIL: [1, 1],
+	FLOOR: [1, 1],
+	ROUND: [1, 1],
+	CONCAT: [0, Infinity],
+	SUBSTR: [2, 3],
+	STRLEN: [1, 1],
+	REPLACE: [3, 4],
+	UCASE: [1, 1],
+	LCASE: [1, 1],
+	ENCODE_FOR_URI: [1, 1],
+	CONTAINS: [2, 2],
+	STRSTARTS: [2, 2],
+	STRENDS: [2, 2],
+	STRBEFORE: [2, 2],
+	STRAFTER: [2, 2],
+	YEAR: [1, 1],
+	MONTH: [1, 1],
+	DAY: [1, 1],
+	HOURS: [1, 1],
+	MINUTES: [1, 1],
+	SECONDS: [1, 1],
+	TIMEZONE: [1, 1],
+	TZ: [1, 1],
+	NOW: [0, 0],
+	UUID: [0, 0],
+	STRUUID: [0, 0],
+	MD5: [1, 1],
+	SHA1: [1, 1],
+	SHA256: [1, 1],
+	SHA384: [1, 1],
+	SHA512: [1, 1],
+	COALESCE: [0, Infinity],
+	IF: [3, 3],
+	STRLANG: [2, 2],
+	STRLANGDIR: [3, 3],
+	STRDT: [2, 2],
+	SAMETERM: [2, 2],
+	ISIRI: [1, 1],
+	ISURI: [1, 1],
+	ISBLANK: [1, 1],
+	ISLITERAL: [1, 1],
+	ISNUMERIC: [1, 1],
+	HASLANG: [1, 1],
+	HASLANGDIR: [1, 1],
+	REGEX: [2, 3],
+	ISTRIPLE: [1, 1],
+	TRIPLE: [3, 3],
+	SUBJECT: [1, 1],
+	PREDICATE: [1, 1],
+	OBJECT: [1, 1]
+};
+/**
+* Whether a (case-insensitive) name is a built-in function.
+*
+* @since 0.1.0
+* @category guards
+*/
+const isBuiltInName = (name) => Object.prototype.hasOwnProperty.call(builtInArity, name.toUpperCase());
+/**
+* @since 0.1.0
+* @category guards
+*/
+const isQuery = (u) => Predicate.isTagged(u, "Select") || Predicate.isTagged(u, "Construct") || Predicate.isTagged(u, "Ask") || Predicate.isTagged(u, "Describe");
+/**
+* @since 0.1.0
+* @category guards
+*/
+const isUpdate = (u) => Predicate.isTagged(u, "Update");
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const emptyPrologue = { prefixes: {} };
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const triplePattern = (subject, predicate, object) => ({
+	_tag: "TriplePattern",
+	subject,
+	predicate,
+	object
+});
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const pathPattern = (subject, path, object) => ({
+	_tag: "PathPattern",
+	subject,
+	path,
+	object
+});
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const quadPattern = (subject, predicate, object, graph = defaultGraph) => ({
+	_tag: "QuadPattern",
+	subject,
+	predicate,
+	object,
+	graph
+});
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const link = (iri) => ({
+	_tag: "PathLink",
+	iri
+});
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const inverse = (path) => ({
+	_tag: "PathInverse",
+	path
+});
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const sequence = (...paths) => ({
+	_tag: "PathSequence",
+	paths
+});
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const alternative = (...paths) => ({
+	_tag: "PathAlternative",
+	paths
+});
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const zeroOrMore = (path) => ({
+	_tag: "PathZeroOrMore",
+	path
+});
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const oneOrMore = (path) => ({
+	_tag: "PathOneOrMore",
+	path
+});
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const zeroOrOne = (path) => ({
+	_tag: "PathZeroOrOne",
+	path
+});
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const negated = (iris, inverse = []) => ({
+	_tag: "PathNegated",
+	iris,
+	inverse
+});
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const operation = (operator, ...args) => ({
+	_tag: "Operation",
+	operator,
+	args
+});
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const functionCall = (fn, args, distinct = false) => ({
+	_tag: "FunctionCall",
+	function: fn,
+	args,
+	distinct
+});
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const aggregate = (name, expression, options) => {
+	const plain = {
+		_tag: "Aggregate",
+		name,
+		expression,
+		distinct: options?.distinct ?? false
+	};
+	return options?.separator === void 0 ? plain : {
+		...plain,
+		separator: options.separator
+	};
+};
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const exists = (pattern, negated = false) => ({
+	_tag: "Exists",
+	negated,
+	pattern
+});
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const bgp = (triples) => ({
+	_tag: "Bgp",
+	triples
+});
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const group = (patterns) => ({
+	_tag: "Group",
+	patterns
+});
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const optional = (pattern) => ({
+	_tag: "Optional",
+	pattern
+});
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const union = (patterns) => ({
+	_tag: "Union",
+	patterns
+});
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const minus = (pattern) => ({
+	_tag: "Minus",
+	pattern
+});
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const graph = (name, pattern) => ({
+	_tag: "Graph",
+	name,
+	pattern
+});
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const service = (name, pattern, silent = false) => ({
+	_tag: "Service",
+	name,
+	pattern,
+	silent
+});
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const filter = (expression) => ({
+	_tag: "Filter",
+	expression
+});
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const bind = (expression, variable) => ({
+	_tag: "Bind",
+	expression,
+	variable
+});
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const values = (variables, rows) => ({
+	_tag: "Values",
+	variables,
+	rows
+});
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const subSelect = (query) => ({
+	_tag: "SubSelect",
+	query
+});
+/**
+* A projected `(expression AS ?variable)`.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const projection = (expression, variable) => ({
+	_tag: "Projection",
+	expression,
+	variable
+});
+const queryDefaults = {
+	prologue: emptyPrologue,
+	groupBy: [],
+	having: [],
+	orderBy: []
+};
+/**
+* Creates a `SELECT` query; omitted fields take their defaults.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const select = (fields) => ({
+	_tag: "Select",
+	...queryDefaults,
+	distinct: false,
+	reduced: false,
+	projection: "*",
+	...fields
+});
+/**
+* Creates a `CONSTRUCT` query.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const construct = (fields) => ({
+	_tag: "Construct",
+	...queryDefaults,
+	...fields
+});
+/**
+* Creates an `ASK` query.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const ask = (fields) => ({
+	_tag: "Ask",
+	...queryDefaults,
+	...fields
+});
+/**
+* Creates a `DESCRIBE` query.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const describe = (fields) => ({
+	_tag: "Describe",
+	...queryDefaults,
+	where: group([]),
+	...fields
+});
+/**
+* Creates an update request.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const update = (operations, prologue = emptyPrologue) => ({
+	_tag: "Update",
+	prologue,
+	operations
+});
+const addTermVariables = (term, out) => {
+	if (isVariable(term)) out.set(term.value, true);
+	else if (isTriple(term)) {
+		addTermVariables(term.subject, out);
+		addTermVariables(term.predicate, out);
+		addTermVariables(term.object, out);
+	}
+};
+/**
+* The variables that are in-scope after a graph pattern (SPARQL 1.1 §18.2.1),
+* in order of first appearance. Blank nodes are not included.
+*
+* @since 0.1.0
+* @category utils
+*/
+const inScopeVariables = (pattern) => {
+	const out = emptySet();
+	collectInScope(pattern, out);
+	return Array.from(out.keys());
+};
+const collectInScope = (pattern, out) => {
+	Match.value(pattern).pipe(Match.tag("Bgp", (b) => b.triples.forEach((t) => {
+		addTermVariables(t.subject, out);
+		if (Predicate.isTagged(t, "TriplePattern")) addTermVariables(t.predicate, out);
+		addTermVariables(t.object, out);
+	})), Match.tag("Group", "Union", (g) => g.patterns.forEach((p) => collectInScope(p, out))), Match.tag("Optional", (o) => collectInScope(o.pattern, out)), Match.tag("Minus", "Filter", () => void 0), Match.tag("Graph", "Service", (g) => {
+		addTermVariables(g.name, out);
+		collectInScope(g.pattern, out);
+	}), Match.tag("Bind", (b) => {
+		out.set(b.variable.value, true);
+	}), Match.tag("Values", (v) => v.variables.forEach((x) => out.set(x.value, true))), Match.tag("SubSelect", (s) => projectedVariables(s.query).forEach((v) => out.set(v, true))), Match.exhaustive);
+};
+/**
+* The variables projected by a `SELECT` query (for `SELECT *`, the
+* in-scope variables of its pattern and trailing `VALUES`).
+*
+* @since 0.1.0
+* @category utils
+*/
+const projectedVariables = (query) => {
+	if (query.projection === "*") {
+		const out = emptySet();
+		collectInScope(query.where, out);
+		query.values?.variables.forEach((v) => out.set(v.value, true));
+		return Array.from(out.keys());
+	}
+	return query.projection.map((p) => isVariable(p) ? p.value : p.variable.value);
+};
+/**
+* All variables mentioned anywhere in an expression (including inside
+* `EXISTS` patterns when `deep` is set).
+*
+* @since 0.1.0
+* @category utils
+*/
+const expressionVariables = (expression, deep = false) => {
+	const out = emptySet();
+	const go = (e) => {
+		Match.value(e).pipe(Match.tag("Variable", "Triple", (t) => addTermVariables(t, out)), Match.tag("Operation", "FunctionCall", (call) => call.args.forEach(go)), Match.tag("Aggregate", (a) => {
+			if (a.expression !== "*") go(a.expression);
+		}), Match.tag("Exists", (x) => {
+			if (deep) collectInScope(x.pattern, out);
+		}), Match.orElse(() => void 0));
+	};
+	go(expression);
+	return Array.from(out.keys());
+};
+/**
+* Whether an expression contains an aggregate (outside of nested `EXISTS`
+* patterns).
+*
+* @since 0.1.0
+* @category utils
+*/
+const containsAggregate = (expression) => {
+	return Match.value(expression).pipe(Match.tag("Aggregate", () => true), Match.tag("Operation", "FunctionCall", (call) => call.args.some(containsAggregate)), Match.orElse(() => false));
+};
+export { pathPattern as A, update as B, isUpdate as C, oneOrMore as D, negated as E, sequence as F, zeroOrMore as H, service as I, subSelect as L, projection as M, quadPattern as N, operation as O, select as P, triplePattern as R, isQuery as S, minus as T, zeroOrOne as U, values as V, group as _, bgp as a, isBuiltInName as b, construct as c, emptyPrologue as d, exists as f, graph as g, functionCall as h, ask as i, projectedVariables as j, optional as k, containsAggregate as l, filter as m, aggregate as n, bind as o, expressionVariables as p, alternative as r, builtInArity as s, Ast_exports as t, describe as u, inScopeVariables as v, link as w, isPath as x, inverse as y, union as z };
+
+//# sourceMappingURL=Ast-CPRZmBvk.mjs.map

package/dist/Ast-CPRZmBvk.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Ast-CPRZmBvk.mjs","names":["Term.defaultGraph","Term.isVariable","Term.isTriple","StringMap.emptySet"],"sources":["../src/sparql/Ast.ts"],"sourcesContent":["/**\n * The abstract syntax tree of SPARQL 1.1 (and SPARQL 1.2) queries and\n * updates.\n *\n * The AST stays close to the surface syntax (group graph patterns, solution\n * modifiers, update operations) while using the core `Term` model for all\n * IRIs, literals, blank nodes, variables and triple terms. Abbreviated\n * syntax (prefixed names, `a`, blank node property lists, collections,\n * reifiers and annotations) is expanded by the parser, so every IRI in the\n * tree is absolute.\n *\n * All nodes are plain immutable objects discriminated by `_tag`; the\n * constructors in this module are the recommended way to build them.\n *\n * @since 0.1.0\n */\nimport * as Term from '../Term.ts';\nimport * as Predicate from 'effect/Predicate';\nimport * as Match from 'effect/Match';\nimport * as StringMap from './internal/stringMap.ts';\n\n// -----------------------------------------------------------------------------\n// Terms\n// -----------------------------------------------------------------------------\n\n/**\n * A term that may appear in a triple pattern: an IRI, literal, blank node,\n * variable or triple term (whose components may themselves be variables).\n *\n * @since 0.1.0\n * @category models\n */\nexport type TermPattern =\n  | Term.NamedNode\n  | Term.BlankNode\n  | Term.Literal\n  | Term.Variable\n  | Term.Triple<any, any, any>;\n\n/**\n * An IRI or a variable.\n *\n * @since 0.1.0\n * @category models\n */\nexport type VarOrIri = Term.NamedNode | Term.Variable;\n\n// -----------------------------------------------------------------------------\n// Property paths\n// -----------------------------------------------------------------------------\n\n/**\n * A property path expression (SPARQL 1.1 §9).\n *\n * A path consisting of a single IRI is represented as `PathLink`; triple\n * patterns whose predicate is a plain IRI use `TriplePattern` instead.\n *\n * @since 0.1.0\n * @category models\n */\nexport type Path =\n  | PathLink\n  | PathInverse\n  | PathSequence\n  | PathAlternative\n  | PathZeroOrMore\n  | PathOneOrMore\n  | PathZeroOrOne\n  | PathNegated;\n\n/**\n * @since 0.1.0\n * @category models\n */\nexport interface PathLink {\n  readonly _tag: 'PathLink';\n  readonly iri: Term.NamedNode;\n}\n\n/**\n * `^path`\n *\n * @since 0.1.0\n * @category models\n */\nexport interface PathInverse {\n  readonly _tag: 'PathInverse';\n  readonly path: Path;\n}\n\n/**\n * `path1 / path2 / …`\n *\n * @since 0.1.0\n * @category models\n */\nexport interface PathSequence {\n  readonly _tag: 'PathSequence';\n  readonly paths: ReadonlyArray<Path>;\n}\n\n/**\n * `path1 | path2 | …`\n *\n * @since 0.1.0\n * @category models\n */\nexport interface PathAlternative {\n  readonly _tag: 'PathAlternative';\n  readonly paths: ReadonlyArray<Path>;\n}\n\n/**\n * `path*`\n *\n * @since 0.1.0\n * @category models\n */\nexport interface PathZeroOrMore {\n  readonly _tag: 'PathZeroOrMore';\n  readonly path: Path;\n}\n\n/**\n * `path+`\n *\n * @since 0.1.0\n * @category models\n */\nexport interface PathOneOrMore {\n  readonly _tag: 'PathOneOrMore';\n  readonly path: Path;\n}\n\n/**\n * `path?`\n *\n * @since 0.1.0\n * @category models\n */\nexport interface PathZeroOrOne {\n  readonly _tag: 'PathZeroOrOne';\n  readonly path: Path;\n}\n\n/**\n * A negated property set `!(iri1 | ^iri2 | …)`. `iris` are the forward\n * IRIs and `inverse` the IRIs written with `^`.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface PathNegated {\n  readonly _tag: 'PathNegated';\n  readonly iris: ReadonlyArray<Term.NamedNode>;\n  readonly inverse: ReadonlyArray<Term.NamedNode>;\n}\n\n/**\n * @since 0.1.0\n * @category guards\n */\nexport const isPath = (u: unknown): u is Path =>\n  Predicate.hasProperty(u, '_tag') && Predicate.isString(u._tag) && u._tag.startsWith('Path');\n\n// -----------------------------------------------------------------------------\n// Triple and quad patterns\n// -----------------------------------------------------------------------------\n\n/**\n * A triple pattern whose predicate is an IRI or a variable.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface TriplePattern {\n  readonly _tag: 'TriplePattern';\n  readonly subject: TermPattern;\n  readonly predicate: VarOrIri;\n  readonly object: TermPattern;\n}\n\n/**\n * A triple pattern whose predicate is a (non-trivial) property path.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface PathPattern {\n  readonly _tag: 'PathPattern';\n  readonly subject: TermPattern;\n  readonly path: Path;\n  readonly object: TermPattern;\n}\n\n/**\n * A triple pattern within a graph: used by update templates (`INSERT`,\n * `DELETE`, `DELETE WHERE`). `graph` is the default graph for triples\n * outside of a `GRAPH` block.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface QuadPattern {\n  readonly _tag: 'QuadPattern';\n  readonly subject: TermPattern;\n  readonly predicate: VarOrIri;\n  readonly object: TermPattern;\n  readonly graph: Term.NamedNode | Term.Variable | Term.DefaultGraph;\n}\n\n// -----------------------------------------------------------------------------\n// Expressions\n// -----------------------------------------------------------------------------\n\n/**\n * The built-in operators and functions of SPARQL 1.1 and 1.2, in their\n * canonical (upper case) spelling. Unary plus and minus are `UPLUS` and\n * `UMINUS`; `IN` and `NOT IN` take the tested expression as their first\n * argument.\n *\n * @since 0.1.0\n * @category models\n */\nexport type Operator =\n  | '||'\n  | '&&'\n  | '!'\n  | '='\n  | '!='\n  | '<'\n  | '>'\n  | '<='\n  | '>='\n  | '+'\n  | '-'\n  | '*'\n  | '/'\n  | 'UPLUS'\n  | 'UMINUS'\n  | 'IN'\n  | 'NOT IN'\n  | BuiltInName;\n\n/**\n * Names of the built-in function calls (`BuiltInCall` in the grammar,\n * excluding aggregates and `EXISTS`).\n *\n * @since 0.1.0\n * @category models\n */\nexport type BuiltInName =\n  | 'STR'\n  | 'LANG'\n  | 'LANGMATCHES'\n  | 'LANGDIR'\n  | 'DATATYPE'\n  | 'BOUND'\n  | 'IRI'\n  | 'URI'\n  | 'BNODE'\n  | 'RAND'\n  | 'ABS'\n  | 'CEIL'\n  | 'FLOOR'\n  | 'ROUND'\n  | 'CONCAT'\n  | 'SUBSTR'\n  | 'STRLEN'\n  | 'REPLACE'\n  | 'UCASE'\n  | 'LCASE'\n  | 'ENCODE_FOR_URI'\n  | 'CONTAINS'\n  | 'STRSTARTS'\n  | 'STRENDS'\n  | 'STRBEFORE'\n  | 'STRAFTER'\n  | 'YEAR'\n  | 'MONTH'\n  | 'DAY'\n  | 'HOURS'\n  | 'MINUTES'\n  | 'SECONDS'\n  | 'TIMEZONE'\n  | 'TZ'\n  | 'NOW'\n  | 'UUID'\n  | 'STRUUID'\n  | 'MD5'\n  | 'SHA1'\n  | 'SHA256'\n  | 'SHA384'\n  | 'SHA512'\n  | 'COALESCE'\n  | 'IF'\n  | 'STRLANG'\n  | 'STRLANGDIR'\n  | 'STRDT'\n  | 'SAMETERM'\n  | 'ISIRI'\n  | 'ISURI'\n  | 'ISBLANK'\n  | 'ISLITERAL'\n  | 'ISNUMERIC'\n  | 'HASLANG'\n  | 'HASLANGDIR'\n  | 'REGEX'\n  | 'ISTRIPLE'\n  | 'TRIPLE'\n  | 'SUBJECT'\n  | 'PREDICATE'\n  | 'OBJECT';\n\n/**\n * Arity of each built-in function: `[min, max]` (`max` = `Infinity` for\n * variadic functions).\n *\n * @since 0.1.0\n * @category models\n */\nexport const builtInArity: Readonly<Record<BuiltInName, readonly [number, number]>> = {\n  STR: [1, 1],\n  LANG: [1, 1],\n  LANGMATCHES: [2, 2],\n  LANGDIR: [1, 1],\n  DATATYPE: [1, 1],\n  BOUND: [1, 1],\n  IRI: [1, 1],\n  URI: [1, 1],\n  BNODE: [0, 1],\n  RAND: [0, 0],\n  ABS: [1, 1],\n  CEIL: [1, 1],\n  FLOOR: [1, 1],\n  ROUND: [1, 1],\n  CONCAT: [0, Infinity],\n  SUBSTR: [2, 3],\n  STRLEN: [1, 1],\n  REPLACE: [3, 4],\n  UCASE: [1, 1],\n  LCASE: [1, 1],\n  ENCODE_FOR_URI: [1, 1],\n  CONTAINS: [2, 2],\n  STRSTARTS: [2, 2],\n  STRENDS: [2, 2],\n  STRBEFORE: [2, 2],\n  STRAFTER: [2, 2],\n  YEAR: [1, 1],\n  MONTH: [1, 1],\n  DAY: [1, 1],\n  HOURS: [1, 1],\n  MINUTES: [1, 1],\n  SECONDS: [1, 1],\n  TIMEZONE: [1, 1],\n  TZ: [1, 1],\n  NOW: [0, 0],\n  UUID: [0, 0],\n  STRUUID: [0, 0],\n  MD5: [1, 1],\n  SHA1: [1, 1],\n  SHA256: [1, 1],\n  SHA384: [1, 1],\n  SHA512: [1, 1],\n  COALESCE: [0, Infinity],\n  IF: [3, 3],\n  STRLANG: [2, 2],\n  STRLANGDIR: [3, 3],\n  STRDT: [2, 2],\n  SAMETERM: [2, 2],\n  ISIRI: [1, 1],\n  ISURI: [1, 1],\n  ISBLANK: [1, 1],\n  ISLITERAL: [1, 1],\n  ISNUMERIC: [1, 1],\n  HASLANG: [1, 1],\n  HASLANGDIR: [1, 1],\n  REGEX: [2, 3],\n  ISTRIPLE: [1, 1],\n  TRIPLE: [3, 3],\n  SUBJECT: [1, 1],\n  PREDICATE: [1, 1],\n  OBJECT: [1, 1],\n};\n\n/**\n * Whether a (case-insensitive) name is a built-in function.\n *\n * @since 0.1.0\n * @category guards\n */\nexport const isBuiltInName = (name: string): name is BuiltInName =>\n  Object.prototype.hasOwnProperty.call(builtInArity, name.toUpperCase());\n\n/**\n * A SPARQL expression. Variables and constant terms are expressions as-is.\n *\n * @since 0.1.0\n * @category models\n */\nexport type Expression =\n  | Term.Variable\n  | Term.NamedNode\n  | Term.Literal\n  | Term.BlankNode\n  | Term.Triple<any, any, any>\n  | OperationExpression\n  | FunctionCallExpression\n  | AggregateExpression\n  | ExistsExpression;\n\n/**\n * An operator or built-in function application.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface OperationExpression {\n  readonly _tag: 'Operation';\n  readonly operator: Operator;\n  readonly args: ReadonlyArray<Expression>;\n}\n\n/**\n * A call to an extension function (or a cast such as `xsd:integer(?x)`)\n * identified by IRI.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface FunctionCallExpression {\n  readonly _tag: 'FunctionCall';\n  readonly function: Term.NamedNode;\n  readonly args: ReadonlyArray<Expression>;\n  /** `DISTINCT` was given (only meaningful for custom aggregates). */\n  readonly distinct: boolean;\n}\n\n/**\n * @since 0.1.0\n * @category models\n */\nexport type AggregateName = 'COUNT' | 'SUM' | 'MIN' | 'MAX' | 'AVG' | 'SAMPLE' | 'GROUP_CONCAT';\n\n/**\n * An aggregate. `expression` is `'*'` for `COUNT(*)`.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface AggregateExpression {\n  readonly _tag: 'Aggregate';\n  readonly name: AggregateName;\n  readonly distinct: boolean;\n  readonly expression: Expression | '*';\n  /** The `SEPARATOR` of `GROUP_CONCAT` (defaults to a single space). */\n  readonly separator?: string | undefined;\n}\n\n/**\n * `EXISTS { … }` / `NOT EXISTS { … }`.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface ExistsExpression {\n  readonly _tag: 'Exists';\n  readonly negated: boolean;\n  readonly pattern: GroupPattern;\n}\n\n// -----------------------------------------------------------------------------\n// Graph patterns\n// -----------------------------------------------------------------------------\n\n/**\n * An element of a group graph pattern.\n *\n * @since 0.1.0\n * @category models\n */\nexport type Pattern =\n  | BgpPattern\n  | GroupPattern\n  | OptionalPattern\n  | UnionPattern\n  | MinusPattern\n  | GraphPattern\n  | ServicePattern\n  | FilterPattern\n  | BindPattern\n  | ValuesPattern\n  | SubSelectPattern;\n\n/**\n * A block of triple patterns (`TriplesBlock`).\n *\n * @since 0.1.0\n * @category models\n */\nexport interface BgpPattern {\n  readonly _tag: 'Bgp';\n  readonly triples: ReadonlyArray<TriplePattern | PathPattern>;\n}\n\n/**\n * A group graph pattern `{ … }`.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface GroupPattern {\n  readonly _tag: 'Group';\n  readonly patterns: ReadonlyArray<Pattern>;\n}\n\n/**\n * @since 0.1.0\n * @category models\n */\nexport interface OptionalPattern {\n  readonly _tag: 'Optional';\n  readonly pattern: GroupPattern;\n}\n\n/**\n * `{ … } UNION { … } UNION …`\n *\n * @since 0.1.0\n * @category models\n */\nexport interface UnionPattern {\n  readonly _tag: 'Union';\n  readonly patterns: ReadonlyArray<GroupPattern>;\n}\n\n/**\n * @since 0.1.0\n * @category models\n */\nexport interface MinusPattern {\n  readonly _tag: 'Minus';\n  readonly pattern: GroupPattern;\n}\n\n/**\n * `GRAPH ?g { … }`\n *\n * @since 0.1.0\n * @category models\n */\nexport interface GraphPattern {\n  readonly _tag: 'Graph';\n  readonly name: VarOrIri;\n  readonly pattern: GroupPattern;\n}\n\n/**\n * `SERVICE [SILENT] <endpoint> { … }`\n *\n * @since 0.1.0\n * @category models\n */\nexport interface ServicePattern {\n  readonly _tag: 'Service';\n  readonly name: VarOrIri;\n  readonly silent: boolean;\n  readonly pattern: GroupPattern;\n}\n\n/**\n * @since 0.1.0\n * @category models\n */\nexport interface FilterPattern {\n  readonly _tag: 'Filter';\n  readonly expression: Expression;\n}\n\n/**\n * `BIND (expr AS ?var)`\n *\n * @since 0.1.0\n * @category models\n */\nexport interface BindPattern {\n  readonly _tag: 'Bind';\n  readonly expression: Expression;\n  readonly variable: Term.Variable;\n}\n\n/**\n * Inline data. Each row has one entry per variable; `undefined` is `UNDEF`.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface ValuesPattern {\n  readonly _tag: 'Values';\n  readonly variables: ReadonlyArray<Term.Variable>;\n  readonly rows: ReadonlyArray<ReadonlyArray<Term.GroundTerm | undefined>>;\n}\n\n/**\n * A nested `SELECT` query.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface SubSelectPattern {\n  readonly _tag: 'SubSelect';\n  readonly query: SelectQuery;\n}\n\n// -----------------------------------------------------------------------------\n// Queries\n// -----------------------------------------------------------------------------\n\n/**\n * The prologue of a query or update: the declared base IRI, prefixes and\n * version. Declarations are kept for pretty printing only; the parser has\n * already expanded all IRIs.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Prologue {\n  readonly base?: string | undefined;\n  readonly prefixes: Readonly<Record<string, string>>;\n  readonly version?: string | undefined;\n}\n\n/**\n * `FROM` and `FROM NAMED` (or `USING` / `USING NAMED`) clauses.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface DatasetClause {\n  readonly default: ReadonlyArray<Term.NamedNode>;\n  readonly named: ReadonlyArray<Term.NamedNode>;\n}\n\n/**\n * A `GROUP BY` condition, optionally bound to a variable with `AS`.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface GroupCondition {\n  readonly expression: Expression;\n  readonly variable?: Term.Variable | undefined;\n}\n\n/**\n * An `ORDER BY` condition.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface OrderCondition {\n  readonly expression: Expression;\n  readonly descending: boolean;\n}\n\n/**\n * A projected `(expression AS ?variable)`.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Projection {\n  readonly _tag: 'Projection';\n  readonly expression: Expression;\n  readonly variable: Term.Variable;\n}\n\n/**\n * Fields shared by all query forms.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface QueryBase {\n  readonly prologue: Prologue;\n  readonly dataset?: DatasetClause | undefined;\n  readonly where: GroupPattern;\n  readonly groupBy: ReadonlyArray<GroupCondition>;\n  readonly having: ReadonlyArray<Expression>;\n  readonly orderBy: ReadonlyArray<OrderCondition>;\n  readonly limit?: number | undefined;\n  readonly offset?: number | undefined;\n  /** A trailing `VALUES` clause. */\n  readonly values?: ValuesPattern | undefined;\n}\n\n/**\n * @since 0.1.0\n * @category models\n */\nexport interface SelectQuery extends QueryBase {\n  readonly _tag: 'Select';\n  readonly distinct: boolean;\n  readonly reduced: boolean;\n  readonly projection: '*' | ReadonlyArray<Term.Variable | Projection>;\n}\n\n/**\n * @since 0.1.0\n * @category models\n */\nexport interface ConstructQuery extends QueryBase {\n  readonly _tag: 'Construct';\n  readonly template: ReadonlyArray<TriplePattern>;\n  /** Whether the short form `CONSTRUCT WHERE { … }` was used. */\n  readonly short?: boolean | undefined;\n}\n\n/**\n * @since 0.1.0\n * @category models\n */\nexport interface AskQuery extends QueryBase {\n  readonly _tag: 'Ask';\n}\n\n/**\n * @since 0.1.0\n * @category models\n */\nexport interface DescribeQuery extends QueryBase {\n  readonly _tag: 'Describe';\n  readonly terms: '*' | ReadonlyArray<VarOrIri>;\n}\n\n/**\n * Any query.\n *\n * @since 0.1.0\n * @category models\n */\nexport type Query = SelectQuery | ConstructQuery | AskQuery | DescribeQuery;\n\n// -----------------------------------------------------------------------------\n// Updates\n// -----------------------------------------------------------------------------\n\n/**\n * The target of `CLEAR` / `DROP`.\n *\n * @since 0.1.0\n * @category models\n */\nexport type GraphTarget =\n  | Term.NamedNode\n  | { readonly _tag: 'Default' }\n  | { readonly _tag: 'Named' }\n  | { readonly _tag: 'All' };\n\n/**\n * A graph or the default graph (`ADD`, `MOVE`, `COPY`).\n *\n * @since 0.1.0\n * @category models\n */\nexport type GraphOrDefault = Term.NamedNode | Term.DefaultGraph;\n\n/**\n * @since 0.1.0\n * @category models\n */\nexport interface InsertDataOperation {\n  readonly _tag: 'InsertData';\n  readonly quads: ReadonlyArray<Term.Quad>;\n}\n\n/**\n * @since 0.1.0\n * @category models\n */\nexport interface DeleteDataOperation {\n  readonly _tag: 'DeleteData';\n  readonly quads: ReadonlyArray<Term.Quad>;\n}\n\n/**\n * @since 0.1.0\n * @category models\n */\nexport interface DeleteWhereOperation {\n  readonly _tag: 'DeleteWhere';\n  readonly patterns: ReadonlyArray<QuadPattern>;\n}\n\n/**\n * `[WITH <g>] DELETE { … } INSERT { … } [USING …] WHERE { … }`\n *\n * @since 0.1.0\n * @category models\n */\nexport interface ModifyOperation {\n  readonly _tag: 'Modify';\n  readonly with?: Term.NamedNode | undefined;\n  readonly delete: ReadonlyArray<QuadPattern>;\n  readonly insert: ReadonlyArray<QuadPattern>;\n  readonly using?: DatasetClause | undefined;\n  readonly where: GroupPattern;\n}\n\n/**\n * @since 0.1.0\n * @category models\n */\nexport interface LoadOperation {\n  readonly _tag: 'Load';\n  readonly silent: boolean;\n  readonly source: Term.NamedNode;\n  readonly destination?: Term.NamedNode | undefined;\n}\n\n/**\n * @since 0.1.0\n * @category models\n */\nexport interface ClearOperation {\n  readonly _tag: 'Clear';\n  readonly silent: boolean;\n  readonly target: GraphTarget;\n}\n\n/**\n * @since 0.1.0\n * @category models\n */\nexport interface DropOperation {\n  readonly _tag: 'Drop';\n  readonly silent: boolean;\n  readonly target: GraphTarget;\n}\n\n/**\n * @since 0.1.0\n * @category models\n */\nexport interface CreateOperation {\n  readonly _tag: 'Create';\n  readonly silent: boolean;\n  readonly graph: Term.NamedNode;\n}\n\n/**\n * `ADD`, `MOVE` and `COPY`.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface TransferOperation {\n  readonly _tag: 'Add' | 'Move' | 'Copy';\n  readonly silent: boolean;\n  readonly source: GraphOrDefault;\n  readonly destination: GraphOrDefault;\n}\n\n/**\n * A single update operation.\n *\n * @since 0.1.0\n * @category models\n */\nexport type UpdateOperation =\n  | InsertDataOperation\n  | DeleteDataOperation\n  | DeleteWhereOperation\n  | ModifyOperation\n  | LoadOperation\n  | ClearOperation\n  | DropOperation\n  | CreateOperation\n  | TransferOperation;\n\n/**\n * An update request: a sequence of operations.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Update {\n  readonly _tag: 'Update';\n  readonly prologue: Prologue;\n  readonly operations: ReadonlyArray<UpdateOperation>;\n}\n\n// -----------------------------------------------------------------------------\n// Guards\n// -----------------------------------------------------------------------------\n\n/**\n * @since 0.1.0\n * @category guards\n */\nexport const isQuery = (u: unknown): u is Query =>\n  Predicate.isTagged(u, 'Select') ||\n  Predicate.isTagged(u, 'Construct') ||\n  Predicate.isTagged(u, 'Ask') ||\n  Predicate.isTagged(u, 'Describe');\n\n/**\n * @since 0.1.0\n * @category guards\n */\nexport const isUpdate = (u: unknown): u is Update => Predicate.isTagged(u, 'Update');\n\n// -----------------------------------------------------------------------------\n// Constructors\n// -----------------------------------------------------------------------------\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const emptyPrologue: Prologue = { prefixes: {} };\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const triplePattern = (\n  subject: TermPattern,\n  predicate: VarOrIri,\n  object: TermPattern,\n): TriplePattern => ({ _tag: 'TriplePattern', subject, predicate, object });\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const pathPattern = (\n  subject: TermPattern,\n  path: Path,\n  object: TermPattern,\n): PathPattern => ({\n  _tag: 'PathPattern',\n  subject,\n  path,\n  object,\n});\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const quadPattern = (\n  subject: TermPattern,\n  predicate: VarOrIri,\n  object: TermPattern,\n  graph: Term.NamedNode | Term.Variable | Term.DefaultGraph = Term.defaultGraph,\n): QuadPattern => ({ _tag: 'QuadPattern', subject, predicate, object, graph });\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const link = (iri: Term.NamedNode): PathLink => ({ _tag: 'PathLink', iri });\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const inverse = (path: Path): PathInverse => ({ _tag: 'PathInverse', path });\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const sequence = (...paths: ReadonlyArray<Path>): PathSequence => ({\n  _tag: 'PathSequence',\n  paths,\n});\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const alternative = (...paths: ReadonlyArray<Path>): PathAlternative => ({\n  _tag: 'PathAlternative',\n  paths,\n});\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const zeroOrMore = (path: Path): PathZeroOrMore => ({ _tag: 'PathZeroOrMore', path });\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const oneOrMore = (path: Path): PathOneOrMore => ({ _tag: 'PathOneOrMore', path });\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const zeroOrOne = (path: Path): PathZeroOrOne => ({ _tag: 'PathZeroOrOne', path });\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const negated = (\n  iris: ReadonlyArray<Term.NamedNode>,\n  inverse: ReadonlyArray<Term.NamedNode> = [],\n): PathNegated => ({ _tag: 'PathNegated', iris, inverse });\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const operation = (\n  operator: Operator,\n  ...args: ReadonlyArray<Expression>\n): OperationExpression => ({ _tag: 'Operation', operator, args });\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const functionCall = (\n  fn: Term.NamedNode,\n  args: ReadonlyArray<Expression>,\n  distinct = false,\n): FunctionCallExpression => ({ _tag: 'FunctionCall', function: fn, args, distinct });\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const aggregate = (\n  name: AggregateName,\n  expression: Expression | '*',\n  options?: { readonly distinct?: boolean; readonly separator?: string },\n): AggregateExpression => {\n  const plain: AggregateExpression = {\n    _tag: 'Aggregate',\n    name,\n    expression,\n    distinct: options?.distinct ?? false,\n  };\n  return options?.separator === undefined ? plain : { ...plain, separator: options.separator };\n};\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const exists = (pattern: GroupPattern, negated = false): ExistsExpression => ({\n  _tag: 'Exists',\n  negated,\n  pattern,\n});\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const bgp = (triples: ReadonlyArray<TriplePattern | PathPattern>): BgpPattern => ({\n  _tag: 'Bgp',\n  triples,\n});\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const group = (patterns: ReadonlyArray<Pattern>): GroupPattern => ({\n  _tag: 'Group',\n  patterns,\n});\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const optional = (pattern: GroupPattern): OptionalPattern => ({ _tag: 'Optional', pattern });\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const union = (patterns: ReadonlyArray<GroupPattern>): UnionPattern => ({\n  _tag: 'Union',\n  patterns,\n});\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const minus = (pattern: GroupPattern): MinusPattern => ({ _tag: 'Minus', pattern });\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const graph = (name: VarOrIri, pattern: GroupPattern): GraphPattern => ({\n  _tag: 'Graph',\n  name,\n  pattern,\n});\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const service = (name: VarOrIri, pattern: GroupPattern, silent = false): ServicePattern => ({\n  _tag: 'Service',\n  name,\n  pattern,\n  silent,\n});\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const filter = (expression: Expression): FilterPattern => ({ _tag: 'Filter', expression });\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const bind = (expression: Expression, variable: Term.Variable): BindPattern => ({\n  _tag: 'Bind',\n  expression,\n  variable,\n});\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const values = (\n  variables: ReadonlyArray<Term.Variable>,\n  rows: ReadonlyArray<ReadonlyArray<Term.GroundTerm | undefined>>,\n): ValuesPattern => ({ _tag: 'Values', variables, rows });\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const subSelect = (query: SelectQuery): SubSelectPattern => ({ _tag: 'SubSelect', query });\n\n/**\n * A projected `(expression AS ?variable)`.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const projection = (expression: Expression, variable: Term.Variable): Projection => ({\n  _tag: 'Projection',\n  expression,\n  variable,\n});\n\nconst queryDefaults = {\n  prologue: emptyPrologue,\n  groupBy: [],\n  having: [],\n  orderBy: [],\n} as const;\n\n/**\n * Creates a `SELECT` query; omitted fields take their defaults.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const select = (\n  fields: Partial<Omit<SelectQuery, '_tag'>> & Pick<SelectQuery, 'where'>,\n): SelectQuery => ({\n  _tag: 'Select',\n  ...queryDefaults,\n  distinct: false,\n  reduced: false,\n  projection: '*',\n  ...fields,\n});\n\n/**\n * Creates a `CONSTRUCT` query.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const construct = (\n  fields: Partial<Omit<ConstructQuery, '_tag'>> & Pick<ConstructQuery, 'where' | 'template'>,\n): ConstructQuery => ({ _tag: 'Construct', ...queryDefaults, ...fields });\n\n/**\n * Creates an `ASK` query.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const ask = (\n  fields: Partial<Omit<AskQuery, '_tag'>> & Pick<AskQuery, 'where'>,\n): AskQuery => ({ _tag: 'Ask', ...queryDefaults, ...fields });\n\n/**\n * Creates a `DESCRIBE` query.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const describe = (\n  fields: Partial<Omit<DescribeQuery, '_tag'>> & Pick<DescribeQuery, 'terms'>,\n): DescribeQuery => ({ _tag: 'Describe', ...queryDefaults, where: group([]), ...fields });\n\n/**\n * Creates an update request.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const update = (\n  operations: ReadonlyArray<UpdateOperation>,\n  prologue: Prologue = emptyPrologue,\n): Update => ({ _tag: 'Update', prologue, operations });\n\n// -----------------------------------------------------------------------------\n// Utilities\n// -----------------------------------------------------------------------------\n\n/** Variable names in order of first appearance, as a string set. */\ntype Names = Map<string, true>;\n\nconst addTermVariables = (term: TermPattern | Term.Term, out: Names): void => {\n  if (Term.isVariable(term)) out.set(term.value, true);\n  else if (Term.isTriple(term)) {\n    addTermVariables(term.subject, out);\n    addTermVariables(term.predicate, out);\n    addTermVariables(term.object, out);\n  }\n};\n\n/**\n * The variables that are in-scope after a graph pattern (SPARQL 1.1 §18.2.1),\n * in order of first appearance. Blank nodes are not included.\n *\n * @since 0.1.0\n * @category utils\n */\nexport const inScopeVariables = (pattern: Pattern): ReadonlyArray<string> => {\n  const out: Names = StringMap.emptySet();\n  collectInScope(pattern, out);\n  return Array.from(out.keys());\n};\n\nconst collectInScope = (pattern: Pattern, out: Names): void => {\n  Match.value(pattern).pipe(\n    Match.tag('Bgp', (b) =>\n      b.triples.forEach((t) => {\n        addTermVariables(t.subject, out);\n        if (Predicate.isTagged(t, 'TriplePattern')) addTermVariables(t.predicate, out);\n        addTermVariables(t.object, out);\n      }),\n    ),\n    Match.tag('Group', 'Union', (g) => g.patterns.forEach((p) => collectInScope(p, out))),\n    Match.tag('Optional', (o) => collectInScope(o.pattern, out)),\n    Match.tag('Minus', 'Filter', () => undefined),\n    Match.tag('Graph', 'Service', (g) => {\n      addTermVariables(g.name, out);\n      collectInScope(g.pattern, out);\n    }),\n    Match.tag('Bind', (b) => {\n      out.set(b.variable.value, true);\n    }),\n    Match.tag('Values', (v) => v.variables.forEach((x) => out.set(x.value, true))),\n    Match.tag('SubSelect', (s) => projectedVariables(s.query).forEach((v) => out.set(v, true))),\n    Match.exhaustive,\n  );\n};\n\n/**\n * The variables projected by a `SELECT` query (for `SELECT *`, the\n * in-scope variables of its pattern and trailing `VALUES`).\n *\n * @since 0.1.0\n * @category utils\n */\nexport const projectedVariables = (query: SelectQuery): ReadonlyArray<string> => {\n  if (query.projection === '*') {\n    const out: Names = StringMap.emptySet();\n    collectInScope(query.where, out);\n    query.values?.variables.forEach((v) => out.set(v.value, true));\n    return Array.from(out.keys());\n  }\n  return query.projection.map((p) => (Term.isVariable(p) ? p.value : p.variable.value));\n};\n\n/**\n * All variables mentioned anywhere in an expression (including inside\n * `EXISTS` patterns when `deep` is set).\n *\n * @since 0.1.0\n * @category utils\n */\nexport const expressionVariables = (\n  expression: Expression,\n  deep = false,\n): ReadonlyArray<string> => {\n  const out: Names = StringMap.emptySet();\n  const go = (e: Expression): void => {\n    Match.value(e).pipe(\n      Match.tag('Variable', 'Triple', (t) => addTermVariables(t, out)),\n      Match.tag('Operation', 'FunctionCall', (call) => call.args.forEach(go)),\n      Match.tag('Aggregate', (a) => {\n        if (a.expression !== '*') go(a.expression);\n      }),\n      Match.tag('Exists', (x) => {\n        if (deep) collectInScope(x.pattern, out);\n      }),\n      Match.orElse(() => undefined),\n    );\n  };\n  go(expression);\n  return Array.from(out.keys());\n};\n\n/**\n * Whether an expression contains an aggregate (outside of nested `EXISTS`\n * patterns).\n *\n * @since 0.1.0\n * @category utils\n */\nexport const containsAggregate = (expression: Expression): boolean => {\n  return Match.value(expression).pipe(\n    Match.tag('Aggregate', () => true),\n    Match.tag('Operation', 'FunctionCall', (call) => call.args.some(containsAggregate)),\n    Match.orElse(() => false),\n  );\n};\n"],"mappings":"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"}