@manta-eu/datalog-parser 0.1.2 → 0.1.4

package/dist/index.js

@@ -1,47 +1,44 @@
-var br = Object.defineProperty;
-var Or = (e, t, r) => t in e ? br(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
-var d = (e, t, r) => Or(e, typeof t != "symbol" ? t + "" : t, r);
-import { match as p, P as u } from "ts-pattern";
-import Ie from "decimal.js";
-import { GeneratorBuilder as xr, ParserBuilder as P } from "@traqula/core";
-import { sparql11GeneratorBuilder as Mt } from "@traqula/generator-sparql-1-1";
-import { AstFactory as vr, lex as ze, completeGeneratorContext as Cr, gram as n, MinimalSparqlParser as Ir, sparqlCodepointEscape as Mr } from "@traqula/rules-sparql-1-1";
-import { createToken as c, Lexer as Bt, CstParser as Br, EOF as Fr } from "chevrotain";
-import { z as q } from "zod";
-const Mn = (e) => p(e).with({ type: "triple" }, () => !0).otherwise(() => !1), Bn = (e) => p(e).with({ type: "property" }, () => !0).otherwise(() => !1), Fn = (e) => p(e).with({ type: "class" }, () => !0).otherwise(() => !1), Pn = (e) => p(e).with({ type: "general" }, () => !0).otherwise(() => !1), I = (e) => p(e).with({ type: "variable" }, () => !0).otherwise(() => !1), kn = (e) => p(e).with({ type: "iri" }, () => !0).otherwise(() => !1), tt = (e) => p(e).with({ type: "literal" }, () => !0).otherwise(() => !1), $n = (e) => p(e).with({ type: "blank" }, () => !0).otherwise(() => !1), Dn = (e) => p(e).with({ type: "negation" }, () => !0).otherwise(() => !1), Gn = (e) => p(e).with({ type: "filter" }, () => !0).otherwise(() => !1), _n = (e) => p(e).with({ type: "bind" }, () => !0).otherwise(() => !1), Vn = (e) => p(e).with({ type: "aggregate" }, () => !0).otherwise(() => !1), jn = (e) => p(e).with({ type: "skolem" }, () => !0).otherwise(() => !1), qn = (e) => p(e).with({ type: "binary" }, () => !0).otherwise(() => !1), Xn = (e) => p(e).with({ type: "unary" }, () => !0).otherwise(() => !1), Hn = (e) => p(e).with({ type: "term" }, () => !0).otherwise(() => !1), Qn = (e) => p(e).with({ type: "function" }, () => !0).otherwise(() => !1), zn = (e) => p(e).with({ type: "triple" }, () => "triple").with({ type: "property" }, () => "property").with({ type: "class" }, () => "class").with({ type: "general" }, () => "general").exhaustive(), Kn = (e) => p(e).with({ type: "variable" }, () => "variable").with({ type: "iri" }, () => "iri").with({ type: "literal" }, () => "literal").with({ type: "blank" }, () => "blank").exhaustive(), Wn = (e) => p(e).with({ type: "binary" }, () => "binary").with({ type: "unary" }, () => "unary").with({ type: "term" }, () => "term").with({ type: "function" }, () => "function").with({ type: "in" }, () => "in").exhaustive(), Pr = (e) => p(e).with({ type: "triple" }, (t) => [t.subject, t.predicate, t.object].filter(I)).with({ type: "property" }, (t) => [t.subject, t.object].filter(I)).with({ type: "class" }, (t) => [t.instance].filter(I)).with({ type: "general" }, (t) => t.terms.filter(I)).exhaustive(), kr = (e) => {
-  const t = Pr(e), r = "graph" in e ? e.graph : void 0;
-  return r && I(r) ? [...t, r] : t;
-}, Yn = (e) => e.function, Zn = (e) => p(e).with(u.union("+", "-", "*", "/", "<", ">", "<=", ">="), () => !0).with(u.union("=", "!=", "||", "&&"), () => !1).exhaustive(), Jn = (e) => p(e).with(u.union("||", "&&", "=", "!=", "<", ">", "<=", ">="), () => !0).with(u.union("+", "-", "*", "/"), () => !1).exhaustive(), Ke = '[^\\s<>"{}|^`\\\\]', $r = new RegExp(`^[a-z][a-z0-9+.-]*:${Ke}*$`, "i");
-function ts(e) {
-  return $r.test(e);
-}
-function We(e) {
+import { match as p, P as l } from "ts-pattern";
+import Ce from "decimal.js";
+import { GeneratorBuilder as Rr, ParserBuilder as F } from "@traqula/core";
+import { sparql11GeneratorBuilder as It } from "@traqula/generator-sparql-1-1";
+import { AstFactory as br, lex as Qe, completeGeneratorContext as Or, gram as n, MinimalSparqlParser as xr, sparqlCodepointEscape as vr } from "@traqula/rules-sparql-1-1";
+import { createToken as c, Lexer as Mt, CstParser as Cr, EOF as Ir } from "chevrotain";
+import { z as j } from "zod";
+const xn = (e) => p(e).with({ type: "triple" }, () => !0).otherwise(() => !1), vn = (e) => p(e).with({ type: "property" }, () => !0).otherwise(() => !1), Cn = (e) => p(e).with({ type: "class" }, () => !0).otherwise(() => !1), In = (e) => p(e).with({ type: "general" }, () => !0).otherwise(() => !1), v = (e) => p(e).with({ type: "variable" }, () => !0).otherwise(() => !1), Mn = (e) => p(e).with({ type: "iri" }, () => !0).otherwise(() => !1), Z = (e) => p(e).with({ type: "literal" }, () => !0).otherwise(() => !1), Bn = (e) => p(e).with({ type: "blank" }, () => !0).otherwise(() => !1), Fn = (e) => p(e).with({ type: "negation" }, () => !0).otherwise(() => !1), Pn = (e) => p(e).with({ type: "filter" }, () => !0).otherwise(() => !1), kn = (e) => p(e).with({ type: "bind" }, () => !0).otherwise(() => !1), $n = (e) => p(e).with({ type: "aggregate" }, () => !0).otherwise(() => !1), Dn = (e) => p(e).with({ type: "skolem" }, () => !0).otherwise(() => !1), Gn = (e) => p(e).with({ type: "binary" }, () => !0).otherwise(() => !1), _n = (e) => p(e).with({ type: "unary" }, () => !0).otherwise(() => !1), Vn = (e) => p(e).with({ type: "term" }, () => !0).otherwise(() => !1), jn = (e) => p(e).with({ type: "function" }, () => !0).otherwise(() => !1), qn = (e) => p(e).with({ type: "triple" }, () => "triple").with({ type: "property" }, () => "property").with({ type: "class" }, () => "class").with({ type: "general" }, () => "general").exhaustive(), Xn = (e) => p(e).with({ type: "variable" }, () => "variable").with({ type: "iri" }, () => "iri").with({ type: "literal" }, () => "literal").with({ type: "blank" }, () => "blank").exhaustive(), Hn = (e) => p(e).with({ type: "binary" }, () => "binary").with({ type: "unary" }, () => "unary").with({ type: "term" }, () => "term").with({ type: "function" }, () => "function").with({ type: "in" }, () => "in").exhaustive(), Mr = (e) => p(e).with({ type: "triple" }, (t) => [t.subject, t.predicate, t.object].filter(v)).with({ type: "property" }, (t) => [t.subject, t.object].filter(v)).with({ type: "class" }, (t) => [t.instance].filter(v)).with({ type: "general" }, (t) => t.terms.filter(v)).exhaustive(), Br = (e) => {
+  const t = Mr(e), r = "graph" in e ? e.graph : void 0;
+  return r && v(r) ? [...t, r] : t;
+}, Qn = (e) => e.function, zn = (e) => p(e).with(l.union("+", "-", "*", "/", "<", ">", "<=", ">="), () => !0).with(l.union("=", "!=", "||", "&&"), () => !1).exhaustive(), Kn = (e) => p(e).with(l.union("||", "&&", "=", "!=", "<", ">", "<=", ">="), () => !0).with(l.union("+", "-", "*", "/"), () => !1).exhaustive(), ze = '[^\\s<>"{}|^`\\\\]', Fr = new RegExp(`^[a-z][a-z0-9+.-]*:${ze}*$`, "i");
+function Wn(e) {
+  return Fr.test(e);
+}
+function Ke(e) {
   return e.includes("://");
 }
-const Dr = /^(true|false)$/i, Gr = /^"(true|false)"\^\^<?\S*boolean>?$/i, St = "[eE][+-]?\\d+", _r = new RegExp(
-  `^[+-]?(?:\\d+\\.\\d*(?:${St})|\\d+\\.\\d+|\\.\\d+(?:${St})?|\\d+(?:${St})?)$`
+const Pr = /^(true|false)$/i, kr = /^"(true|false)"\^\^<?\S*boolean>?$/i, Tt = "[eE][+-]?\\d+", $r = new RegExp(
+  `^[+-]?(?:\\d+\\.\\d*(?:${Tt})|\\d+\\.\\d+|\\.\\d+(?:${Tt})?|\\d+(?:${Tt})?)$`
 );
-function Rt(e) {
-  return _r.test(e);
+function Nt(e) {
+  return $r.test(e);
 }
-const Vr = /^([+-]?)(\d*)(?:\.(\d*))?(?:[eE]([+-]?\d+))?$/, jr = 21;
-function qr(e, t) {
+const Dr = /^([+-]?)(\d*)(?:\.(\d*))?(?:[eE]([+-]?\d+))?$/, Gr = 21;
+function _r(e, t) {
   return t <= 0 ? { integer: "0", fraction: "0".repeat(-t) + e } : t >= e.length ? { integer: e + "0".repeat(t - e.length), fraction: "" } : { integer: e.slice(0, t), fraction: e.slice(t) };
 }
-function Xr(e) {
-  const t = Rt(e) ? e.match(Vr) : null;
+function Vr(e) {
+  const t = Nt(e) ? e.match(Dr) : null;
   if (!t) return e;
-  const [, r = "", i = "", s = "", a] = t, o = i + s, l = i.length + Number(a ?? 0);
-  if (o.length + Math.abs(l) > jr) return e;
-  const E = qr(o, l), y = E.integer.replace(/^0+(?=\d)/, ""), S = E.fraction.replace(/0+$/, ""), h = S ? `${y}.${S}` : y;
+  const [, r = "", i = "", s = "", o] = t, a = i + s, u = i.length + Number(o ?? 0);
+  if (a.length + Math.abs(u) > Gr) return e;
+  const f = _r(a, u), y = f.integer.replace(/^0+(?=\d)/, ""), m = f.fraction.replace(/0+$/, ""), h = m ? `${y}.${m}` : y;
   return h === "0" || r === "+" ? h : `${r}${h}`;
 }
-function es(e) {
-  if (Dr.test(e)) return e.toLowerCase() === "true";
-  const t = e.match(Gr);
-  if (t != null && t[1]) return t[1].toLowerCase() === "true";
+function Yn(e) {
+  if (Pr.test(e)) return e.toLowerCase() === "true";
+  const t = e.match(kr);
+  if (t?.[1]) return t[1].toLowerCase() === "true";
 }
-const bt = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type", Ot = "http://www.w3.org/2001/XMLSchema#", j = {
+const Rt = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type", bt = "http://www.w3.org/2001/XMLSchema#", V = {
   integer: "xsd:integer",
   decimal: "xsd:decimal",
   double: "xsd:double",
@@ -49,7 +46,7 @@ const bt = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type", Ot = "http://www.w
   string: "xsd:string",
   date: "xsd:date",
   dateTime: "xsd:dateTime"
-}, Hr = ["integer", "decimal", "double"], Me = {
+}, jr = ["integer", "decimal", "double"], Ie = {
   "||": 1,
   "&&": 2,
   "=": 3,
@@ -62,7 +59,7 @@ const bt = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type", Ot = "http://www.w
   "-": 4,
   "*": 5,
   "/": 5
-}, Ft = {
+}, Bt = {
   "=": "=",
   "!=": "!=",
   "<": ">",
@@ -70,30 +67,30 @@ const bt = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type", Ot = "http://www.w
   ">": "<",
   ">=": "<="
 };
-function Be(e) {
-  return p(e).with({ type: u.union("triple", "property", "class", "general") }, () => !0).otherwise(() => !1);
+function Me(e) {
+  return p(e).with({ type: l.union("triple", "property", "class", "general") }, () => !0).otherwise(() => !1);
 }
-function B(e) {
-  return p(e).with({ type: "binary" }, ({ left: t, right: r }) => B(t) || B(r)).with({ type: "unary" }, ({ operand: t }) => B(t)).with({ type: "term" }, () => !1).with(
+function M(e) {
+  return p(e).with({ type: "binary" }, ({ left: t, right: r }) => M(t) || M(r)).with({ type: "unary" }, ({ operand: t }) => M(t)).with({ type: "term" }, () => !1).with(
     { type: "function" },
-    ({ name: t, args: r }) => t.toUpperCase() === "SKOLEM" || r.some(B)
+    ({ name: t, args: r }) => t.toUpperCase() === "SKOLEM" || r.some(M)
   ).with(
     { type: "in" },
-    ({ expression: t, list: r }) => B(t) || r.some(B)
+    ({ expression: t, list: r }) => M(t) || r.some(M)
   ).exhaustive();
 }
-function xt(e) {
-  return p(e).with({ type: "skolem" }, () => !0).with({ type: u.union("filter", "bind") }, ({ expression: t }) => B(t)).with({ type: "negation" }, ({ formulas: t }) => t.some(xt)).with(
+function Ot(e) {
+  return p(e).with({ type: "skolem" }, () => !0).with({ type: l.union("filter", "bind") }, ({ expression: t }) => M(t)).with({ type: "negation" }, ({ formulas: t }) => t.some(Ot)).with(
     { type: "aggregate" },
-    ({ atoms: t, bindings: r }) => t.some(xt) || ((r == null ? void 0 : r.some(
-      ({ expression: i, secondExpression: s }) => i !== "*" && B(i) || s !== void 0 && B(s)
-    )) ?? !1)
-  ).with({ type: u.union("triple", "property", "class", "general") }, () => !1).exhaustive();
+    ({ atoms: t, bindings: r }) => t.some(Ot) || (r?.some(
+      ({ expression: i, secondExpression: s }) => i !== "*" && M(i) || s !== void 0 && M(s)
+    ) ?? !1)
+  ).with({ type: l.union("triple", "property", "class", "general") }, () => !1).exhaustive();
 }
-function Ye(e) {
-  return e.some((t) => t.type !== "negation" && xt(t));
+function We(e) {
+  return e.some((t) => t.type !== "negation" && Ot(t));
 }
-function Ze(e) {
+function Ye(e) {
   return p(e).with({ type: "class" }, (t) => ({
     className: t.className,
     instance: t.instance,
@@ -101,7 +98,7 @@ function Ze(e) {
   })).with(
     {
       type: "property",
-      predicate: u.union("a", "rdf:type", bt),
+      predicate: l.union("a", "rdf:type", Rt),
       object: { type: "iri" }
     },
     (t) => ({
@@ -112,7 +109,7 @@ function Ze(e) {
   ).with(
     {
       type: "triple",
-      predicate: { type: "iri", value: u.union("a", "rdf:type", bt) },
+      predicate: { type: "iri", value: l.union("a", "rdf:type", Rt) },
       object: { type: "iri" }
     },
     (t) => ({
@@ -122,14 +119,14 @@ function Ze(e) {
     })
   ).otherwise(() => null);
 }
-function Je(e) {
+function Ze(e) {
   return p(e).with({ type: "property" }, (t) => ({
     predicate: t.predicate,
     subject: t.subject,
     object: t.object,
     graph: t.graph
   })).with(
-    { type: "triple", predicate: { type: "iri", value: u.not(u.union("a", "rdf:type", bt)) } },
+    { type: "triple", predicate: { type: "iri", value: l.not(l.union("a", "rdf:type", Rt)) } },
     (t) => ({
       predicate: t.predicate.value,
       subject: t.subject,
@@ -138,320 +135,318 @@ function Je(e) {
     })
   ).otherwise(() => null);
 }
-function rs(e) {
-  return e in Ft;
+function Zn(e) {
+  return e in Bt;
 }
-function is(e) {
-  return Ft[e];
+function Jn(e) {
+  return Bt[e];
 }
-function it(e, t) {
-  return e === j[t] || e === `${Ot}${t}`;
+function et(e, t) {
+  return e === V[t] || e === `${bt}${t}`;
 }
-function Fe(e) {
+function Be(e) {
   const { datatype: t } = e;
-  if (!(!t || it(t, "string")))
-    return t.startsWith(Ot) ? `xsd:${t.slice(Ot.length)}` : t;
+  if (!(!t || et(t, "string")))
+    return t.startsWith(bt) ? `xsd:${t.slice(bt.length)}` : t;
 }
-function tr(e, t) {
-  return p([e, t]).with([{ type: "literal" }, { type: "literal" }], ([r, i]) => Q(r) && Q(i) && Rt(r.value) && Rt(i.value) ? new Ie(r.value).equals(new Ie(i.value)) : r.value === i.value && r.language === i.language && Fe(r) === Fe(i)).with([{ type: "iri" }, { type: "iri" }], ([r, i]) => r.value === i.value).with([{ type: "blank" }, { type: "blank" }], ([r, i]) => r.label === i.label).with([{ type: "variable" }, { type: "variable" }], ([r, i]) => r.name === i.name).otherwise(() => !1);
+function Je(e, t) {
+  return p([e, t]).with([{ type: "literal" }, { type: "literal" }], ([r, i]) => H(r) && H(i) && Nt(r.value) && Nt(i.value) ? new Ce(r.value).equals(new Ce(i.value)) : r.value === i.value && r.language === i.language && Be(r) === Be(i)).with([{ type: "iri" }, { type: "iri" }], ([r, i]) => r.value === i.value).with([{ type: "blank" }, { type: "blank" }], ([r, i]) => r.label === i.label).with([{ type: "variable" }, { type: "variable" }], ([r, i]) => r.name === i.name).otherwise(() => !1);
 }
-function Q(e) {
-  return Hr.some((t) => it(e.datatype, t));
+function H(e) {
+  return jr.some((t) => et(e.datatype, t));
 }
-function ns(e) {
-  return !Q(e) || !e.termSpan || !e.valueSpan ? !1 : e.termSpan.start === e.valueSpan.start && e.termSpan.end === e.valueSpan.end;
+function ts(e) {
+  return !H(e) || !e.termSpan || !e.valueSpan ? !1 : e.termSpan.start === e.valueSpan.start && e.termSpan.end === e.valueSpan.end;
 }
-function ss(e) {
-  return tt(e) && Q(e);
+function es(e) {
+  return Z(e) && H(e);
 }
-function er(e) {
-  return it(e.datatype, "boolean");
+function tr(e) {
+  return et(e.datatype, "boolean");
 }
-function Qr(e) {
-  return it(e.datatype, "date");
+function qr(e) {
+  return et(e.datatype, "date");
 }
-function zr(e) {
-  return it(e.datatype, "dateTime");
+function Xr(e) {
+  return et(e.datatype, "dateTime");
 }
-function as(e) {
-  return Q(e) ? Xr(e.value) : er(e) || Qr(e) ? e.value : zr(e) ? e.value.replace("T", " ") : JSON.stringify(e.value);
+function rs(e) {
+  return H(e) ? Vr(e.value) : tr(e) || qr(e) ? e.value : Xr(e) ? e.value.replace("T", " ") : JSON.stringify(e.value);
 }
-function os(e) {
-  return Kr(e.expression);
+function is(e) {
+  return Hr(e.expression);
 }
-function Kr(e) {
+function Hr(e) {
   return p(e).with(
-    { type: "binary", operator: u.union("=", "!=", "<", ">", "<=", ">=") },
+    { type: "binary", operator: l.union("=", "!=", "<", ">", "<=", ">=") },
     (t) => {
-      const r = G(t.left), i = G(t.right);
-      return !r || !i ? null : I(r) && tt(i) ? { variableName: r.name, operator: t.operator, literal: i } : tt(r) && I(i) ? {
+      const r = D(t.left), i = D(t.right);
+      return !r || !i ? null : v(r) && Z(i) ? { variableName: r.name, operator: t.operator, literal: i } : Z(r) && v(i) ? {
         variableName: i.name,
-        operator: Ft[t.operator],
+        operator: Bt[t.operator],
         literal: r
       } : null;
     }
   ).otherwise(() => null);
 }
-function Wr(e) {
+function Qr(e) {
   return p(e).returnType().with(
     { type: "binary", operator: "=" },
-    (t) => p([G(t.left), G(t.right)]).returnType().with([u.not(u.nullish), { type: "literal" }], ([r, i]) => ({ subject: r, literal: i })).with([{ type: "literal" }, u.not(u.nullish)], ([r, i]) => ({ subject: i, literal: r })).otherwise(() => null)
+    (t) => p([D(t.left), D(t.right)]).returnType().with([l.not(l.nullish), { type: "literal" }], ([r, i]) => ({ subject: r, literal: i })).with([{ type: "literal" }, l.not(l.nullish)], ([r, i]) => ({ subject: i, literal: r })).otherwise(() => null)
   ).otherwise(() => null);
 }
-function ls(e) {
-  var s;
+function ns(e) {
   if (e.type === "in") {
-    const a = G(e.expression), o = e.list.flatMap((l) => {
-      const E = ti(l);
-      return E ? [E] : [];
+    const s = D(e.expression), o = e.list.flatMap((a) => {
+      const u = Yr(a);
+      return u ? [u] : [];
     });
-    return a && o.length > 0 && o.length === e.list.length ? { subject: a, literals: o, negated: e.negated } : null;
+    return s && o.length > 0 && o.length === e.list.length ? { subject: s, literals: o, negated: e.negated } : null;
   }
-  const t = vt(e, "||");
+  const t = xt(e, "||");
   if (t.length < 2) return null;
-  const r = t.flatMap((a) => {
-    const o = Wr(a);
+  const r = t.flatMap((s) => {
+    const o = Qr(s);
     return o ? [o] : [];
   });
   if (r.length !== t.length) return null;
-  const i = (s = r[0]) == null ? void 0 : s.subject;
-  return !i || !r.every((a) => tr(a.subject, i)) ? null : {
+  const i = r[0]?.subject;
+  return !i || !r.every((s) => Je(s.subject, i)) ? null : {
     subject: i,
-    literals: r.map((a) => a.literal),
+    literals: r.map((s) => s.literal),
     negated: !1
   };
 }
-function Yr(e) {
-  const t = G(e);
-  return t && I(t) ? t.name : null;
+function zr(e) {
+  const t = D(e);
+  return t && v(t) ? t.name : null;
 }
-function Zr(e) {
+function Kr(e) {
   return p(e).with({ type: "skolem" }, (t) => {
     const r = t.args.at(-1);
-    return r ? Yr(r) : null;
+    return r ? zr(r) : null;
   }).with({ type: "bind", expression: { type: "function", name: "SKOLEM" } }, (t) => t.variable).otherwise(() => null);
 }
-function us(e) {
-  const t = /* @__PURE__ */ new Set(), r = (a) => {
-    T(a).forEach((o) => t.add(o));
-  }, i = (a) => {
-    nt(a).forEach((o) => t.add(o));
-  }, s = (a) => {
-    p(a).with({ type: u.union("triple", "property", "class", "general") }, i).with({ type: "negation" }, (o) => o.formulas.forEach(s)).with({ type: "filter" }, (o) => r(o.expression)).with({ type: "bind" }, (o) => {
-      r(o.expression), t.add(o.variable);
-    }).with({ type: "aggregate" }, (o) => {
-      var l, E;
-      o.atoms.forEach(s), (l = o.onVars) == null || l.forEach((y) => t.add(y)), (E = o.bindings) == null || E.forEach((y) => {
-        t.add(y.variable), y.expression !== "*" && r(y.expression), y.secondExpression && r(y.secondExpression);
+function ss(e) {
+  const t = /* @__PURE__ */ new Set(), r = (o) => {
+    w(o).forEach((a) => t.add(a));
+  }, i = (o) => {
+    rt(o).forEach((a) => t.add(a));
+  }, s = (o) => {
+    p(o).with({ type: l.union("triple", "property", "class", "general") }, i).with({ type: "negation" }, (a) => a.formulas.forEach(s)).with({ type: "filter" }, (a) => r(a.expression)).with({ type: "bind" }, (a) => {
+      r(a.expression), t.add(a.variable);
+    }).with({ type: "aggregate" }, (a) => {
+      a.atoms.forEach(s), a.onVars?.forEach((u) => t.add(u)), a.bindings?.forEach((u) => {
+        t.add(u.variable), u.expression !== "*" && r(u.expression), u.secondExpression && r(u.secondExpression);
       });
-    }).with({ type: "skolem" }, (o) => o.args.forEach(r)).exhaustive();
+    }).with({ type: "skolem" }, (a) => a.args.forEach(r)).exhaustive();
   };
   return e.head.forEach(i), e.body.forEach(s), Array.from(t);
 }
-function cs(e, t) {
-  const r = /* @__PURE__ */ new Set(), i = (o) => {
-    o.includes(t) && o.forEach((l) => r.add(l));
-  }, s = (o) => {
-    i(nt(o));
-  }, a = (o) => {
-    p(o).with({ type: u.union("triple", "property", "class", "general") }, s).with({ type: "negation" }, (l) => l.formulas.forEach(a)).with({ type: "filter" }, (l) => i(T(l.expression))).with(
+function as(e, t) {
+  const r = /* @__PURE__ */ new Set(), i = (a) => {
+    a.includes(t) && a.forEach((u) => r.add(u));
+  }, s = (a) => {
+    i(rt(a));
+  }, o = (a) => {
+    p(a).with({ type: l.union("triple", "property", "class", "general") }, s).with({ type: "negation" }, (u) => u.formulas.forEach(o)).with({ type: "filter" }, (u) => i(w(u.expression))).with(
       { type: "bind" },
-      (l) => i([...T(l.expression), l.variable])
-    ).with({ type: "aggregate" }, (l) => {
-      l.atoms.forEach(a);
-      const E = [
-        ...l.onVars ?? [],
-        ...(l.bindings ?? []).flatMap((y) => [
+      (u) => i([...w(u.expression), u.variable])
+    ).with({ type: "aggregate" }, (u) => {
+      u.atoms.forEach(o);
+      const f = [
+        ...u.onVars ?? [],
+        ...(u.bindings ?? []).flatMap((y) => [
           y.variable,
-          ...y.expression === "*" ? [] : T(y.expression),
-          ...y.secondExpression ? T(y.secondExpression) : []
+          ...y.expression === "*" ? [] : w(y.expression),
+          ...y.secondExpression ? w(y.secondExpression) : []
         ])
       ];
-      i(E);
+      i(f);
     }).with(
       { type: "skolem" },
-      (l) => i(l.args.flatMap((E) => T(E)))
+      (u) => i(u.args.flatMap((f) => w(f)))
     ).exhaustive();
   };
-  return e.head.forEach(s), e.body.forEach(a), r;
+  return e.head.forEach(s), e.body.forEach(o), r;
 }
-function nt(e) {
-  return kr(e).map((t) => t.name);
+function rt(e) {
+  return Br(e).map((t) => t.name);
 }
-function Jr(e) {
-  return e && I(e) ? [e.name] : [];
+function Wr(e) {
+  return e && v(e) ? [e.name] : [];
 }
-function T(e) {
+function w(e) {
   return p(e).with({ type: "binary" }, (t) => [
-    ...T(t.left),
-    ...T(t.right)
-  ]).with({ type: "unary" }, (t) => T(t.operand)).with({ type: "term" }, (t) => Jr(t.term)).with({ type: "function" }, (t) => t.args.flatMap(T)).with({ type: "in" }, (t) => [
-    ...T(t.expression),
-    ...t.list.flatMap(T)
+    ...w(t.left),
+    ...w(t.right)
+  ]).with({ type: "unary" }, (t) => w(t.operand)).with({ type: "term" }, (t) => Wr(t.term)).with({ type: "function" }, (t) => t.args.flatMap(w)).with({ type: "in" }, (t) => [
+    ...w(t.expression),
+    ...t.list.flatMap(w)
   ]).exhaustive();
 }
-function ti(e) {
-  const t = G(e);
-  return t && tt(t) ? t : null;
+function Yr(e) {
+  const t = D(e);
+  return t && Z(t) ? t : null;
 }
-function vt(e, t) {
+function xt(e, t) {
   return e.type !== "binary" || e.operator !== t ? [e] : [
-    ...vt(e.left, t),
-    ...vt(e.right, t)
+    ...xt(e.left, t),
+    ...xt(e.right, t)
   ];
 }
-function rr(e) {
-  return We(e) ? `<${e}>` : e;
+function er(e) {
+  return Ke(e) ? `<${e}>` : e;
 }
-function x(e, t = {}) {
+function b(e, t = {}) {
   return p(e).with({ type: "variable" }, (r) => `?${r.name}`).with({ type: "iri" }, (r) => r.prefixed ? r.value : `<${r.value}>`).with({ type: "literal" }, (r) => {
-    const i = t.stripSimpleLiteralDatatypes && Pe(r) ? r.value : JSON.stringify(r.value);
-    return r.language ? `${i}@${r.language}` : r.datatype ? t.stripSimpleLiteralDatatypes && Pe(r) ? i : `${i}^^${rr(r.datatype)}` : i;
+    const i = t.stripSimpleLiteralDatatypes && Fe(r) ? r.value : JSON.stringify(r.value);
+    return r.language ? `${i}@${r.language}` : r.datatype ? t.stripSimpleLiteralDatatypes && Fe(r) ? i : `${i}^^${er(r.datatype)}` : i;
   }).with({ type: "blank" }, (r) => `_:${r.label}`).exhaustive();
 }
-function ps(e, t = {}) {
-  const r = "graph" in e && e.graph ? ` ${x(e.graph, t)}` : "";
+function os(e, t = {}) {
+  const r = "graph" in e && e.graph ? ` ${b(e.graph, t)}` : "";
   return p(e).with(
     { type: "property" },
-    (i) => `${i.predicate}[${x(i.subject, t)}, ${x(i.object, t)}]${r}`
+    (i) => `${i.predicate}[${b(i.subject, t)}, ${b(i.object, t)}]${r}`
   ).with(
     { type: "triple" },
-    (i) => `[${x(i.subject, t)}, ${x(i.predicate, t)}, ${x(i.object, t)}]${r}`
+    (i) => `[${b(i.subject, t)}, ${b(i.predicate, t)}, ${b(i.object, t)}]${r}`
   ).with(
     { type: "class" },
-    (i) => `${i.className}[${x(i.instance, t)}]${r}`
+    (i) => `${i.className}[${b(i.instance, t)}]${r}`
   ).with(
     { type: "general" },
-    (i) => `${i.tableName}(${i.terms.map((s) => x(s, t)).join(", ")})`
+    (i) => `${i.tableName}(${i.terms.map((s) => b(s, t)).join(", ")})`
   ).exhaustive();
 }
-function Pe(e) {
-  return Q(e) || er(e);
+function Fe(e) {
+  return H(e) || tr(e);
 }
-function hs(e, t = {}) {
-  return si(H(e, t));
+function ls(e, t = {}) {
+  return ri(X(e, t));
 }
-function H(e, t = {}) {
+function X(e, t = {}) {
   return p(e).with({ type: "binary" }, (r) => [
-    ...ke(r.left, r.operator, "left", t),
-    C(` ${r.operator} `),
-    ...ke(r.right, r.operator, "right", t)
-  ]).with({ type: "unary" }, (r) => [C(r.operator), ...ii(r.operand, t)]).with({ type: "term" }, (r) => ni(r.term, t)).with({ type: "function" }, (r) => [
-    C(`${r.name}(`),
-    ...$e(
-      r.args.map((i) => H(i, t)),
+    ...Pe(r.left, r.operator, "left", t),
+    x(` ${r.operator} `),
+    ...Pe(r.right, r.operator, "right", t)
+  ]).with({ type: "unary" }, (r) => [x(r.operator), ...ti(r.operand, t)]).with({ type: "term" }, (r) => ei(r.term, t)).with({ type: "function" }, (r) => [
+    x(`${r.name}(`),
+    ...ke(
+      r.args.map((i) => X(i, t)),
       ", "
     ),
-    C(")")
+    x(")")
   ]).with({ type: "in" }, (r) => [
-    ...H(r.expression, t),
-    C(` ${r.negated ? "NOT IN" : "IN"} (`),
-    ...$e(
-      r.list.map((i) => H(i, t)),
+    ...X(r.expression, t),
+    x(` ${r.negated ? "NOT IN" : "IN"} (`),
+    ...ke(
+      r.list.map((i) => X(i, t)),
       ", "
     ),
-    C(")")
+    x(")")
   ]).exhaustive();
 }
-function ei(e, t, r) {
+function Zr(e, t, r) {
   if (e.type !== "binary") return !1;
-  const i = Me[e.operator], s = Me[t];
+  const i = Ie[e.operator], s = Ie[t];
   return i < s || r === "right" && i === s && (t === "-" || t === "/");
 }
-function ri(e) {
+function Jr(e) {
   return e.type === "binary" || e.type === "in";
 }
-function ke(e, t, r, i) {
-  const s = H(e, i);
-  return ei(e, t, r) ? ir(s) : s;
+function Pe(e, t, r, i) {
+  const s = X(e, i);
+  return Zr(e, t, r) ? rr(s) : s;
 }
-function ii(e, t) {
-  const r = H(e, t);
-  return ri(e) ? ir(r) : r;
+function ti(e, t) {
+  const r = X(e, t);
+  return Jr(e) ? rr(r) : r;
 }
-function ni(e, t) {
-  return I(e) ? [ai(e.name)] : tt(e) ? [oi(e, t)] : [C(x(e, t))];
+function ei(e, t) {
+  return v(e) ? [ii(e.name)] : Z(e) ? [ni(e, t)] : [x(b(e, t))];
 }
-function ir(e) {
-  return [C("("), ...e, C(")")];
+function rr(e) {
+  return [x("("), ...e, x(")")];
 }
-function $e(e, t) {
-  return e.flatMap((r, i) => i === 0 ? r : [C(t), ...r]);
+function ke(e, t) {
+  return e.flatMap((r, i) => i === 0 ? r : [x(t), ...r]);
 }
-function si(e) {
+function ri(e) {
   return e.map((t) => t.type === "variable" ? `?${t.name}` : t.text).join("");
 }
-function C(e) {
+function x(e) {
   return { type: "text", text: e };
 }
-function ai(e) {
+function ii(e) {
   return { type: "variable", name: e };
 }
-function oi(e, t) {
-  return { type: "literal", literal: e, text: x(e, t) };
+function ni(e, t) {
+  return { type: "literal", literal: e, text: b(e, t) };
 }
-function G(e) {
+function D(e) {
   return e.type === "term" ? e.term : null;
 }
-const li = "Cannot translate grounded Datalog rules to SPARQL.";
-function nr(e) {
-  if (e.some(Ct)) throw new Error(li);
+const si = "Cannot translate grounded Datalog rules to SPARQL.";
+function ir(e) {
+  if (e.some(vt)) throw new Error(si);
 }
-function Ct(e) {
+function vt(e) {
   return p(e).with({ type: "bind" }, ({ groundedTarget: t }) => t !== void 0).with(
     { type: "aggregate" },
-    ({ groundedOnTargets: t, bindings: r, atoms: i }) => t !== void 0 || ((r == null ? void 0 : r.some((s) => s.groundedTarget !== void 0)) ?? !1) || i.some(Ct)
-  ).with({ type: "negation" }, ({ formulas: t }) => t.some(Ct)).with({ type: u.union("triple", "property", "class", "general", "filter", "skolem") }, () => !1).exhaustive();
+    ({ groundedOnTargets: t, bindings: r, atoms: i }) => t !== void 0 || (r?.some((s) => s.groundedTarget !== void 0) ?? !1) || i.some(vt)
+  ).with({ type: "negation" }, ({ formulas: t }) => t.some(vt)).with({ type: l.union("triple", "property", "class", "general", "filter", "skolem") }, () => !1).exhaustive();
 }
-const g = new vr(), m = g.gen(), De = Mt.getRule("aggregate"), Ge = Mt.getRule("expression"), ui = {
-  ...De,
+const E = new br(), g = E.gen(), $e = It.getRule("aggregate"), De = It.getRule("expression"), ai = {
+  ...$e,
   gImpl: (e) => (t, r) => {
     const i = t.secondExpression;
     if (!i)
-      return De.gImpl(e)(t, r);
-    const { PRINT_WORD: s, SUBRULE: a } = e, o = t.expression[0], l = r.astFactory;
-    if (l.isWildcard(o))
+      return $e.gImpl(e)(t, r);
+    const { PRINT_WORD: s, SUBRULE: o } = e, a = t.expression[0], u = r.astFactory;
+    if (u.isWildcard(a))
       throw new Error(`Aggregate ${t.aggregation.toUpperCase()} cannot combine * with a second expression.`);
-    l.printFilter(t, () => {
+    u.printFilter(t, () => {
       s(t.aggregation.toUpperCase(), "("), t.distinct && s("DISTINCT");
-    }), a(Ge, o), l.printFilter(t, () => s(",")), a(Ge, i), l.printFilter(t, () => s(")"));
+    }), o(De, a), u.printFilter(t, () => s(",")), o(De, i), u.printFilter(t, () => s(")"));
   }
-}, ci = xr.create(Mt).patchRule(ui).build(), pi = /* @__PURE__ */ new Set(["MIN_ARGMIN", "MAX_ARGMIN", "MIN_ARGMAX", "MAX_ARGMAX"]), hi = new Map(
-  Object.entries(ze.builtIn).filter(([e]) => e !== "BuiltInCalls" && e !== "allBuiltInCalls").filter(([, e]) => e && typeof e == "object" && "LABEL" in e).map(([, e]) => {
+}, oi = Rr.create(It).patchRule(ai).build(), li = /* @__PURE__ */ new Set(["MIN_ARGMIN", "MAX_ARGMIN", "MIN_ARGMAX", "MAX_ARGMAX"]), ui = new Map(
+  Object.entries(Qe.builtIn).filter(([e]) => e !== "BuiltInCalls" && e !== "allBuiltInCalls").filter(([, e]) => e && typeof e == "object" && "LABEL" in e).map(([, e]) => {
     const t = e;
     return [t.LABEL.toLowerCase(), t.LABEL];
   })
 );
-function D(e) {
+function $(e) {
   if (e.includes("://") || e.startsWith("urn:") || e.startsWith("mailto:") || e.startsWith("tel:") || e.startsWith("data:"))
-    return g.termNamed(m, e);
+    return E.termNamed(g, e);
   const r = e.indexOf(":");
-  return r >= 0 ? g.termNamed(m, e.slice(r + 1), e.slice(0, r)) : g.termNamed(m, e);
+  return r >= 0 ? E.termNamed(g, e.slice(r + 1), e.slice(0, r)) : E.termNamed(g, e);
 }
-function ot(e, t) {
-  return g.expressionOperation(e, t, m);
+function st(e, t) {
+  return E.expressionOperation(e, t, g);
 }
-function di(e, t) {
-  const { function: r, expression: i, secondExpression: s } = e, a = pi.has(r), o = s !== void 0;
-  if (a && s == null)
+function ci(e, t) {
+  const { function: r, expression: i, secondExpression: s } = e, o = li.has(r), a = s !== void 0;
+  if (o && s == null)
     throw new Error(`Aggregate ${r} requires two expressions.`);
-  if (a && i === "*")
+  if (o && i === "*")
     throw new Error(`Aggregate ${r} cannot use * as an expression.`);
-  if (!a && o)
+  if (!o && a)
     throw new Error(`Aggregate ${r} accepts only one expression.`);
-  const l = i === "*" ? g.wildcard(m) : O(i, t), E = g.aggregate(
+  const u = i === "*" ? E.wildcard(g) : R(i, t), f = E.aggregate(
     r.toLowerCase(),
     e.distinct || !1,
-    l,
+    u,
     void 0,
-    m
+    g
   );
-  return o ? {
-    ...E,
-    secondExpression: O(s, t)
-  } : E;
+  return a ? {
+    ...f,
+    secondExpression: R(s, t)
+  } : f;
 }
-function $(e, t, r = void 0) {
+function P(e, t, r = void 0) {
   return p(r).with("predicate", () => {
     if (e.type !== "variable" && e.type !== "iri")
       throw new Error(`Invalid predicate term: ${e.type}. RDF predicates cannot be ${e.type} nodes.`);
@@ -461,137 +456,136 @@ function $(e, t, r = void 0) {
   }).with("graph", () => {
     if (e.type !== "variable" && e.type !== "iri")
       throw new Error(`Invalid graph name term: ${e.type}. Graph names can only be variables or IRIs.`);
-  }).with(u.nullish, () => {
-  }).exhaustive(), r === "predicate" && e.type === "iri" && e.value === "a" ? D("rdf:type") : p(e).with({ type: "variable" }, (i) => (t.add(i.name), g.termVariable(i.name, m))).with({ type: "iri", prefixed: !0 }, (i) => D(i.value)).with({ type: "iri", prefixed: !1 }, (i) => g.termNamed(m, i.value)).with(
-    { type: "literal", language: u.string },
-    (i) => g.termLiteral(m, i.value, i.language)
-  ).with({ type: "literal", datatype: u.string }, (i) => {
-    const s = D(i.datatype);
-    return g.termLiteral(m, i.value, s);
-  }).with({ type: "literal" }, (i) => g.termLiteral(m, i.value)).with({ type: "blank" }, (i) => g.termBlank(i.label, m)).exhaustive();
-}
-function Ei(e, t) {
-  const r = e.args.map((a) => O(a, t)), i = hi.get(e.name.toLowerCase());
+  }).with(l.nullish, () => {
+  }).exhaustive(), r === "predicate" && e.type === "iri" && e.value === "a" ? $("rdf:type") : p(e).with({ type: "variable" }, (i) => (t.add(i.name), E.termVariable(i.name, g))).with({ type: "iri", prefixed: !0 }, (i) => $(i.value)).with({ type: "iri", prefixed: !1 }, (i) => E.termNamed(g, i.value)).with(
+    { type: "literal", language: l.string },
+    (i) => E.termLiteral(g, i.value, i.language)
+  ).with({ type: "literal", datatype: l.string }, (i) => {
+    const s = $(i.datatype);
+    return E.termLiteral(g, i.value, s);
+  }).with({ type: "literal" }, (i) => E.termLiteral(g, i.value)).with({ type: "blank" }, (i) => E.termBlank(i.label, g)).exhaustive();
+}
+function pi(e, t) {
+  const r = e.args.map((o) => R(o, t)), i = ui.get(e.name.toLowerCase());
   if (i)
-    return ot(i.toLowerCase(), r);
-  const s = D(e.name);
-  return g.expressionFunctionCall(s, r, !1, m);
+    return st(i.toLowerCase(), r);
+  const s = $(e.name);
+  return E.expressionFunctionCall(s, r, !1, g);
 }
-function O(e, t) {
+function R(e, t) {
   return p(e).with(
     { type: "binary" },
-    (r) => ot(r.operator, [
-      O(r.left, t),
-      O(r.right, t)
+    (r) => st(r.operator, [
+      R(r.left, t),
+      R(r.right, t)
     ])
   ).with(
     { type: "unary" },
-    (r) => ot(r.operator, [O(r.operand, t)])
-  ).with({ type: "term" }, (r) => $(r.term, t, "expression")).with({ type: "function" }, (r) => Ei(r, t)).with(
+    (r) => st(r.operator, [R(r.operand, t)])
+  ).with({ type: "term" }, (r) => P(r.term, t, "expression")).with({ type: "function" }, (r) => pi(r, t)).with(
     { type: "in" },
-    (r) => ot(r.negated ? "notin" : "in", [
-      O(r.expression, t),
-      ...r.list.map((i) => O(i, t))
+    (r) => st(r.negated ? "notin" : "in", [
+      R(r.expression, t),
+      ...r.list.map((i) => R(i, t))
     ])
   ).exhaustive();
 }
-function Pt(e, t) {
+function Ft(e, t) {
   const r = p(e).with(
     { type: "triple" },
-    (i) => g.triple(
-      $(i.subject, t),
-      $(i.predicate, t, "predicate"),
-      $(i.object, t)
+    (i) => E.triple(
+      P(i.subject, t),
+      P(i.predicate, t, "predicate"),
+      P(i.object, t)
     )
   ).with({ type: "property" }, (i) => {
-    const s = D(i.predicate);
-    return g.triple($(i.subject, t), s, $(i.object, t));
+    const s = $(i.predicate);
+    return E.triple(P(i.subject, t), s, P(i.object, t));
   }).with({ type: "class" }, (i) => {
-    const s = D("rdf:type"), a = D(i.className);
-    return g.triple($(i.instance, t), s, a);
+    const s = $("rdf:type"), o = $(i.className);
+    return E.triple(P(i.instance, t), s, o);
   }).with({ type: "general" }, () => {
     throw new Error("General formulas are not supported as triple patterns.");
   }).exhaustive();
   if (!r) return { triples: [] };
   if ("graph" in e && e.graph) {
-    const i = g.patternBgp([r], m);
-    return { graph: g.patternGraph(
-      $(e.graph, t, "graph"),
+    const i = E.patternBgp([r], g);
+    return { graph: E.patternGraph(
+      P(e.graph, t, "graph"),
       [i],
-      m
+      g
     ) };
   }
   return { triples: [r] };
 }
-function fi(e, t) {
+function hi(e, t) {
   return e.formulas.filter((r) => "type" in r).flatMap(
-    (r) => p(r).with({ type: u.union("triple", "property", "class") }, (i) => Pt(i, t).triples || []).with({ type: "general" }, () => {
+    (r) => p(r).with({ type: l.union("triple", "property", "class") }, (i) => Ft(i, t).triples || []).with({ type: "general" }, () => {
       throw new Error("General formulas are not supported in negation patterns.");
     }).exhaustive()
   );
 }
-function gi(e, t) {
+function di(e, t) {
   return e.reduce(
-    (r, i) => "type" in i ? p(i).with({ type: u.union("triple", "property", "class") }, (s) => {
-      const a = Pt(s, t);
-      return a.graph ? { ...r, graphPatterns: [...r.graphPatterns, a.graph] } : a.triples ? { ...r, triples: [...r.triples, ...a.triples] } : r;
+    (r, i) => "type" in i ? p(i).with({ type: l.union("triple", "property", "class") }, (s) => {
+      const o = Ft(s, t);
+      return o.graph ? { ...r, graphPatterns: [...r.graphPatterns, o.graph] } : o.triples ? { ...r, triples: [...r.triples, ...o.triples] } : r;
     }).with({ type: "filter" }, (s) => {
-      const a = O(s.expression, t), o = g.patternFilter(a, m);
-      return { ...r, filters: [...r.filters, o] };
+      const o = R(s.expression, t), a = E.patternFilter(o, g);
+      return { ...r, filters: [...r.filters, a] };
     }).with({ type: "bind" }, (s) => {
       t.add(s.variable);
-      const a = O(s.expression, t), o = g.termVariable(s.variable, m), l = g.patternBind(a, o, m);
-      return { ...r, binds: [...r.binds, l] };
+      const o = R(s.expression, t), a = E.termVariable(s.variable, g), u = E.patternBind(o, a, g);
+      return { ...r, binds: [...r.binds, u] };
     }).with({ type: "general" }, () => {
       throw new Error("General formulas are not supported in atom processing.");
     }).exhaustive() : r,
     { triples: [], filters: [], binds: [], graphPatterns: [] }
   );
 }
-function mi(e, t) {
-  var S;
-  const { triples: r, filters: i, binds: s, graphPatterns: a } = gi(e.atoms, t), o = e.onVars || [], l = o.map((h) => (t.add(h), g.termVariable(h, m))), E = [], y = [];
-  return (S = e.bindings) == null || S.forEach((h) => {
-    if (t.add(h.variable), h.expression === void 0) {
-      const W = h.function !== void 0 ? `Aggregate ${h.function}` : "Expression-only aggregate binding";
-      throw new Error(`${W} requires an expression.`);
+function Ei(e, t) {
+  const { triples: r, filters: i, binds: s, graphPatterns: o } = di(e.atoms, t), a = e.onVars || [], u = a.map((m) => (t.add(m), E.termVariable(m, g))), f = [], y = [];
+  return e.bindings?.forEach((m) => {
+    if (t.add(m.variable), m.expression === void 0) {
+      const k = m.function !== void 0 ? `Aggregate ${m.function}` : "Expression-only aggregate binding";
+      throw new Error(`${k} requires an expression.`);
     }
-    if (h.function === void 0 && h.secondExpression !== void 0)
+    if (m.function === void 0 && m.secondExpression !== void 0)
       throw new Error("Expression-only aggregate bindings cannot have a second expression.");
-    const R = h.function !== void 0, L = R ? di(h, t) : O(h.expression, t), A = g.termVariable(h.variable, m), k = g.patternBind(L, A, m);
-    R ? E.push(k) : y.push(k);
+    const h = m.function !== void 0, C = h ? ci(m, t) : R(m.expression, t), T = E.termVariable(m.variable, g), A = E.patternBind(C, T, g);
+    h ? f.push(A) : y.push(A);
   }), {
     triples: r,
     filters: i,
     binds: [...s, ...y],
-    graphPatterns: a,
-    selectVars: [...l, ...E],
-    groupBy: o
+    graphPatterns: o,
+    selectVars: [...u, ...f],
+    groupBy: a
   };
 }
-function yi(e, t) {
-  nr(e);
+function fi(e, t) {
+  ir(e);
   const r = /* @__PURE__ */ new Set(), i = e.reduce(
-    (h, R) => p(R).with({ type: u.union("triple", "property", "class", "general") }, (L) => {
-      const A = Pt(L, r);
+    (h, C) => p(C).with({ type: l.union("triple", "property", "class", "general") }, (T) => {
+      const A = Ft(T, r);
       return A.graph ? { ...h, graphPatterns: [...h.graphPatterns, A.graph] } : A.triples ? { ...h, triples: [...h.triples, ...A.triples] } : h;
-    }).with({ type: "filter" }, (L) => {
-      const A = O(L.expression, r), k = g.patternFilter(A, m);
+    }).with({ type: "filter" }, (T) => {
+      const A = R(T.expression, r), k = E.patternFilter(A, g);
       return { ...h, filters: [...h.filters, k] };
-    }).with({ type: "bind" }, (L) => {
-      const A = O(L.expression, r);
-      r.add(L.variable);
-      const k = g.termVariable(L.variable, m), W = g.patternBind(A, k, m);
-      return { ...h, binds: [...h.binds, W] };
-    }).with({ type: "negation" }, (L) => {
-      const A = fi(L, r);
+    }).with({ type: "bind" }, (T) => {
+      const A = R(T.expression, r);
+      r.add(T.variable);
+      const k = E.termVariable(T.variable, g), At = E.patternBind(A, k, g);
+      return { ...h, binds: [...h.binds, At] };
+    }).with({ type: "negation" }, (T) => {
+      const A = hi(T, r);
       if (A.length > 0) {
-        const k = g.patternBgp(A, m), W = g.patternGroup([k], m), Nr = g.expressionPatternOperation("notexists", W, m), Rr = g.patternFilter(Nr, m);
-        return { ...h, filters: [...h.filters, Rr] };
+        const k = E.patternBgp(A, g), At = E.patternGroup([k], g), Sr = E.expressionPatternOperation("notexists", At, g), Nr = E.patternFilter(Sr, g);
+        return { ...h, filters: [...h.filters, Nr] };
       }
       return h;
-    }).with({ type: "aggregate" }, (L) => {
-      const A = mi(L, r);
+    }).with({ type: "aggregate" }, (T) => {
+      const A = Ei(T, r);
       return {
         triples: [...h.triples, ...A.triples],
         filters: [...h.filters, ...A.filters],
@@ -612,139 +606,140 @@ function yi(e, t) {
       aggregateSelectVars: []
     }
   ), s = [
-    ...i.triples.length > 0 ? [g.patternBgp(i.triples, m)] : [],
+    ...i.triples.length > 0 ? [E.patternBgp(i.triples, g)] : [],
     ...i.graphPatterns,
     ...i.filters,
     ...i.binds
-  ], a = i.aggregateSelectVars.length > 0 ? i.aggregateSelectVars : r.size > 0 ? Array.from(r).map((h) => g.termVariable(h, m)) : [g.wildcard(m)], o = i.groupByVars.length > 0 ? {
-    group: g.solutionModifierGroup(
-      i.groupByVars.map((h) => g.termVariable(h, m)),
-      m
+  ], o = i.aggregateSelectVars.length > 0 ? i.aggregateSelectVars : r.size > 0 ? Array.from(r).map((h) => E.termVariable(h, g)) : [E.wildcard(g)], a = i.groupByVars.length > 0 ? {
+    group: E.solutionModifierGroup(
+      i.groupByVars.map((h) => E.termVariable(h, g)),
+      g
     )
-  } : {}, l = t ? Object.entries(t).map(([h, R]) => {
-    const L = g.termNamed(m, R);
-    return g.contextDefinitionPrefix(m, h, L);
-  }) : [], E = g.querySelect(
+  } : {}, u = t ? Object.entries(t).map(([h, C]) => {
+    const T = E.termNamed(g, C);
+    return E.contextDefinitionPrefix(g, h, T);
+  }) : [], f = E.querySelect(
     {
-      context: l,
+      context: u,
       // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/ban-ts-comment
-      variables: a,
+      variables: o,
       // @ts-ignore - Fails in CI for some reason
-      where: g.patternGroup(s, m),
-      datasets: g.datasetClauses([], m),
-      solutionModifiers: o
+      where: E.patternGroup(s, g),
+      datasets: E.datasetClauses([], g),
+      solutionModifiers: a
     },
-    m
-  ), y = ci.queryOrUpdate(E, Cr({ indentInc: 2 })).trim(), S = i.aggregateSelectVars.length > 0 ? i.aggregateSelectVars.map((h) => "value" in h && typeof h.value == "string" ? h.value : "variable" in h && h.variable && "value" in h.variable ? h.variable.value : null).filter((h) => h !== null) : Array.from(r);
+    g
+  ), y = oi.queryOrUpdate(f, Or({ indentInc: 2 })).trim(), m = i.aggregateSelectVars.length > 0 ? i.aggregateSelectVars.map((h) => "value" in h && typeof h.value == "string" ? h.value : "variable" in h && h.variable && "value" in h.variable ? h.variable.value : null).filter((h) => h !== null) : Array.from(r);
   return {
     query: y,
-    variables: S
+    variables: m
   };
 }
-const kt = c({ name: "RULE_ARROW", pattern: /:-/ }), lt = c({ name: "NOT", pattern: /NOT/ }), $t = c({ name: "EXISTS", pattern: /EXISTS?/ }), Z = c({ name: "IN", pattern: /IN/ }), Dt = c({ name: "FILTER", pattern: /FILTER/ }), z = c({ name: "BIND", pattern: /BIND/ }), K = c({ name: "AS", pattern: /AS/ }), wt = c({ name: "AGGREGATE", pattern: /AGGREGATE/ }), At = c({ name: "ON", pattern: /ON/ }), Gt = c({ name: "COUNT", pattern: /COUNT/ }), _t = c({ name: "MIN", pattern: /MIN/ }), Vt = c({ name: "MAX", pattern: /MAX/ }), jt = c({ name: "SUM", pattern: /SUM/ }), qt = c({ name: "MUL", pattern: /MUL/ }), Xt = c({ name: "AVG", pattern: /AVG/ }), Ht = c({ name: "COUNT_MIN", pattern: /COUNT_MIN/ }), Qt = c({ name: "COUNT_MAX", pattern: /COUNT_MAX/ }), zt = c({ name: "MIN_ARGMIN", pattern: /MIN_ARGMIN/ }), Kt = c({ name: "MAX_ARGMIN", pattern: /MAX_ARGMIN/ }), Wt = c({ name: "MIN_ARGMAX", pattern: /MIN_ARGMAX/ }), Yt = c({ name: "MAX_ARGMAX", pattern: /MAX_ARGMAX/ }), ut = c({ name: "DISTINCT", pattern: /DISTINCT/ }), Zt = c({ name: "CONCAT", pattern: /CONCAT/ }), Jt = c({ name: "STR", pattern: /STR/ }), te = c({ name: "IF", pattern: /IF/ }), ee = c({ name: "IRI", pattern: /IRI/ }), ct = c({ name: "SKOLEM", pattern: /SKOLEM/ }), re = c({ name: "ROUND", pattern: /ROUND/ }), ie = c({ name: "REGEX", pattern: /REGEX/ }), ne = c({ name: "TRUE", pattern: /true/ }), se = c({ name: "FALSE", pattern: /false/ }), ae = c({ name: "EQUALS", pattern: /=/ }), oe = c({ name: "NOT_EQUALS", pattern: /!=/ }), le = c({ name: "LESS_THAN", pattern: /</ }), ue = c({ name: "LESS_THAN_OR_EQUAL", pattern: /<=/ }), ce = c({ name: "GREATER_THAN", pattern: />/ }), pe = c({ name: "GREATER_THAN_OR_EQUAL", pattern: />=/ }), he = c({ name: "AND", pattern: /&&/ }), de = c({ name: "OR", pattern: /\|\|/ }), pt = c({ name: "PLUS", pattern: /\+/ }), ht = c({ name: "MINUS", pattern: /-/ }), dt = c({ name: "STAR", pattern: /\*/ }), Ee = c({ name: "SLASH", pattern: /\// }), fe = c({ name: "EXCLAMATION", pattern: /!/ }), ge = c({ name: "DOT", pattern: /\./ }), N = c({ name: "COMMA", pattern: /,/ }), U = c({ name: "LPAREN", pattern: /\(/ }), w = c({ name: "RPAREN", pattern: /\)/ }), Et = c({ name: "LBRACKET", pattern: /\[/ }), ft = c({ name: "RBRACKET", pattern: /\]/ }), sr = c({ name: "AT", pattern: /@/ }), gt = c({ name: "HAT", pattern: /\^/ }), ar = c({ name: "COLON", pattern: /:/ }), b = c({ name: "VARIABLE", pattern: /\?[a-zA-Z_][a-zA-Z0-9_]*/ }), me = c({ name: "IRI_REF", pattern: new RegExp(`<${Ke}*>`) }), ye = c({ name: "INTERNAL_FUNCTION", pattern: /<internal:[^>]+>/ }), et = c({ name: "BLANK_NODE", pattern: /_:[\w](?:[\w.-]*[\w-])?/ }), Le = "%[0-9a-fA-F]{2}|\\\\[-_~.!$&'()*+,;=/?#@%]", Li = `(?:[\\w:]|${Le})`, Ui = `(?:[\\w:.-]|${Le})`, wi = `(?:[\\w:-]|${Le})`, or = `${Li}(?:${Ui}*${wi})?`, st = c({
+const Pt = c({ name: "RULE_ARROW", pattern: /:-/ }), at = c({ name: "NOT", pattern: /NOT/ }), kt = c({ name: "EXISTS", pattern: /EXISTS?/ }), W = c({ name: "IN", pattern: /IN/ }), $t = c({ name: "FILTER", pattern: /FILTER/ }), Q = c({ name: "BIND", pattern: /BIND/ }), z = c({ name: "AS", pattern: /AS/ }), Lt = c({ name: "AGGREGATE", pattern: /AGGREGATE/ }), Ut = c({ name: "ON", pattern: /ON/ }), Dt = c({ name: "COUNT", pattern: /COUNT/ }), Gt = c({ name: "MIN", pattern: /MIN/ }), _t = c({ name: "MAX", pattern: /MAX/ }), Vt = c({ name: "SUM", pattern: /SUM/ }), jt = c({ name: "MUL", pattern: /MUL/ }), qt = c({ name: "AVG", pattern: /AVG/ }), Xt = c({ name: "COUNT_MIN", pattern: /COUNT_MIN/ }), Ht = c({ name: "COUNT_MAX", pattern: /COUNT_MAX/ }), Qt = c({ name: "MIN_ARGMIN", pattern: /MIN_ARGMIN/ }), zt = c({ name: "MAX_ARGMIN", pattern: /MAX_ARGMIN/ }), Kt = c({ name: "MIN_ARGMAX", pattern: /MIN_ARGMAX/ }), Wt = c({ name: "MAX_ARGMAX", pattern: /MAX_ARGMAX/ }), ot = c({ name: "DISTINCT", pattern: /DISTINCT/ }), Yt = c({ name: "CONCAT", pattern: /CONCAT/ }), Zt = c({ name: "STR", pattern: /STR/ }), Jt = c({ name: "IF", pattern: /IF/ }), te = c({ name: "IRI", pattern: /IRI/ }), lt = c({ name: "SKOLEM", pattern: /SKOLEM/ }), ee = c({ name: "ROUND", pattern: /ROUND/ }), re = c({ name: "REGEX", pattern: /REGEX/ }), ie = c({ name: "TRUE", pattern: /true/ }), ne = c({ name: "FALSE", pattern: /false/ }), se = c({ name: "EQUALS", pattern: /=/ }), ae = c({ name: "NOT_EQUALS", pattern: /!=/ }), oe = c({ name: "LESS_THAN", pattern: /</ }), le = c({ name: "LESS_THAN_OR_EQUAL", pattern: /<=/ }), ue = c({ name: "GREATER_THAN", pattern: />/ }), ce = c({ name: "GREATER_THAN_OR_EQUAL", pattern: />=/ }), pe = c({ name: "AND", pattern: /&&/ }), he = c({ name: "OR", pattern: /\|\|/ }), ut = c({ name: "PLUS", pattern: /\+/ }), ct = c({ name: "MINUS", pattern: /-/ }), pt = c({ name: "STAR", pattern: /\*/ }), de = c({ name: "SLASH", pattern: /\// }), Ee = c({ name: "EXCLAMATION", pattern: /!/ }), fe = c({ name: "DOT", pattern: /\./ }), S = c({ name: "COMMA", pattern: /,/ }), L = c({ name: "LPAREN", pattern: /\(/ }), U = c({ name: "RPAREN", pattern: /\)/ }), ht = c({ name: "LBRACKET", pattern: /\[/ }), dt = c({ name: "RBRACKET", pattern: /\]/ }), nr = c({ name: "AT", pattern: /@/ }), Et = c({ name: "HAT", pattern: /\^/ }), sr = c({ name: "COLON", pattern: /:/ }), N = c({ name: "VARIABLE", pattern: /\?[a-zA-Z_][a-zA-Z0-9_]*/ }), ge = c({ name: "IRI_REF", pattern: new RegExp(`<${ze}*>`) }), me = c({ name: "INTERNAL_FUNCTION", pattern: /<internal:[^>]+>/ }), J = c({ name: "BLANK_NODE", pattern: /_:[\w](?:[\w.-]*[\w-])?/ }), ye = "%[0-9a-fA-F]{2}|\\\\[-_~.!$&'()*+,;=/?#@%]", gi = `(?:[\\w:]|${ye})`, mi = `(?:[\\w:.-]|${ye})`, yi = `(?:[\\w:-]|${ye})`, ar = `${gi}(?:${mi}*${yi})?`, it = c({
   name: "PREFIXED_NAME",
-  pattern: new RegExp(`[a-zA-Z_][\\w]*:${or}`)
-}), Tt = c({ name: "PREFIX_ONLY", pattern: /[a-zA-Z_][\w]*:/ }), Ue = c({
+  pattern: new RegExp(`[a-zA-Z_][\\w]*:${ar}`)
+}), wt = c({ name: "PREFIX_ONLY", pattern: /[a-zA-Z_][\w]*:/ }), Le = c({
   name: "DEFAULT_NS_IRI",
-  pattern: new RegExp(`:${or}`)
-}), we = c({ name: "INTEGER", pattern: /[+-]?\d+/ }), Ae = c({ name: "DECIMAL", pattern: /[+-]?\d*\.\d+/ }), Te = c({
+  pattern: new RegExp(`:${ar}`)
+}), Ue = c({ name: "INTEGER", pattern: /[+-]?\d+/ }), we = c({ name: "DECIMAL", pattern: /[+-]?\d*\.\d+/ }), Ae = c({
   name: "DOUBLE",
   pattern: /[+-]?(\d+\.\d*[eE][+-]?\d+|\.\d+[eE][+-]?\d+|\d+[eE][+-]?\d+)/
-}), Se = c({
+}), Te = c({
   name: "STRING_LITERAL_LONG",
   pattern: /"""(?:[^"\\]|\\.|"(?!""))*"""|'''(?:[^'\\]|\\.|'(?!''))*'''/
-}), mt = c({
+}), ft = c({
   name: "STRING_LITERAL",
   pattern: /"([^"\\]|\\.)*"|'([^'\\]|\\.)*'/
-}), Ne = c({ name: "LANGTAG", pattern: /@[a-zA-Z]+(-[a-zA-Z0-9]+)*/ }), rt = c({
+}), Se = c({ name: "LANGTAG", pattern: /@[a-zA-Z]+(-[a-zA-Z0-9]+)*/ }), tt = c({
   name: "IDENTIFIER",
   pattern: /[a-zA-Z_][a-zA-Z0-9_]*/,
-  longer_alt: st
-}), Ai = c({
+  longer_alt: it
+}), Li = c({
   name: "COMMENT",
   pattern: /#[^\r\n]*/,
-  group: Bt.SKIPPED
-}), Ti = c({
+  group: Mt.SKIPPED
+}), Ui = c({
   name: "WHITESPACE",
   pattern: /\s+/,
-  group: Bt.SKIPPED
-}), lr = [
+  group: Mt.SKIPPED
+}), or = [
   // Whitespace and comments (skipped)
-  Ti,
-  Ai,
+  Ui,
+  Li,
   // Multi-character operators (before single-char)
-  kt,
-  oe,
-  ue,
+  Pt,
+  ae,
+  le,
+  ce,
   pe,
   he,
-  de,
-  gt,
+  Et,
   // Keywords (before identifiers)
-  lt,
+  at,
+  kt,
+  W,
   $t,
-  Z,
-  Dt,
+  Q,
   z,
-  K,
-  wt,
-  At,
+  Lt,
+  Ut,
+  Qt,
   zt,
   Kt,
   Wt,
-  Yt,
+  Xt,
   Ht,
-  Qt,
+  Dt,
   Gt,
   _t,
   Vt,
   jt,
   qt,
-  Xt,
-  ut,
+  ot,
+  Yt,
   Zt,
   Jt,
   te,
+  lt,
   ee,
-  ct,
   re,
   ie,
   ne,
-  se,
   // Literals (specific patterns before generic)
-  Se,
-  mt,
   Te,
+  ft,
   Ae,
   we,
-  Ne,
+  Ue,
+  Se,
   // Identifiers and names
-  b,
-  ye,
+  N,
   me,
-  et,
-  st,
-  Ue,
-  Tt,
-  rt,
+  ge,
+  J,
+  it,
+  Le,
+  wt,
+  tt,
   // Single character tokens
-  ae,
-  le,
-  ce,
+  se,
+  oe,
+  ue,
+  ut,
+  ct,
   pt,
-  ht,
-  dt,
+  de,
   Ee,
   fe,
-  ge,
-  N,
+  S,
+  L,
   U,
-  w,
-  Et,
-  ft,
-  sr,
-  ar
-], Si = /* @__PURE__ */ new Set([lt, $t, Z, Dt, z, K, wt, At, ut]), Ni = /* @__PURE__ */ new Set([
+  ht,
+  dt,
+  nr,
+  sr
+], wi = /* @__PURE__ */ new Set([at, kt, W, $t, Q, z, Lt, Ut, ot]), Ai = /* @__PURE__ */ new Set([
+  Dt,
   Gt,
   _t,
   Vt,
@@ -760,12 +755,12 @@ const kt = c({ name: "RULE_ARROW", pattern: /:-/ }), lt = c({ name: "NOT", patte
   Zt,
   Jt,
   te,
+  lt,
   ee,
-  ct,
-  re,
-  ie
-]), Ri = /* @__PURE__ */ new Set([ne, se]), ds = /* @__PURE__ */ new Set([we, Ae, Te]), bi = /* @__PURE__ */ new Set([mt, Se]), Es = /* @__PURE__ */ new Set([me, ye, st, Tt, Ue]), fs = /* @__PURE__ */ new Set([
-  kt,
+  re
+]), Ti = /* @__PURE__ */ new Set([ie, ne]), us = /* @__PURE__ */ new Set([Ue, we, Ae]), Si = /* @__PURE__ */ new Set([ft, Te]), cs = /* @__PURE__ */ new Set([ge, me, it, wt, Le]), ps = /* @__PURE__ */ new Set([
+  Pt,
+  se,
   ae,
   oe,
   le,
@@ -773,31 +768,29 @@ const kt = c({ name: "RULE_ARROW", pattern: /:-/ }), lt = c({ name: "NOT", patte
   ce,
   pe,
   he,
-  de,
+  ut,
+  ct,
   pt,
-  ht,
-  dt,
-  Ee,
-  fe
-]), gs = /* @__PURE__ */ new Set([ge, N, U, w, Et, ft, sr, gt, ar]), ms = /* @__PURE__ */ new Set([b, et, Ne, rt]);
-for (const e of [...Si, ...Ni, ...Ri])
-  e.LONGER_ALT = [st, Tt, rt];
-let Oi;
-function Re(e) {
-  return (Oi ?? (Oi = new Bt(lr))).tokenize(e);
-}
-function J(e, t, r, i) {
-  var o;
-  const a = e.slice(0, t).split(/\r\n|\r|\n/);
+  de,
+  Ee
+]), hs = /* @__PURE__ */ new Set([fe, S, L, U, ht, dt, nr, Et, sr]), ds = /* @__PURE__ */ new Set([N, J, Se, tt]);
+for (const e of [...wi, ...Ai, ...Ti])
+  e.LONGER_ALT = [it, wt, tt];
+let Ni;
+function Ne(e) {
+  return (Ni ??= new Mt(or)).tokenize(e);
+}
+function Y(e, t, r, i) {
+  const o = e.slice(0, t).split(/\r\n|\r|\n/);
   return {
     message: i,
-    line: a.length,
-    column: (((o = a.at(-1)) == null ? void 0 : o.length) ?? 0) + 1,
+    line: o.length,
+    column: (o.at(-1)?.length ?? 0) + 1,
     offset: t,
     endOffset: t + r
   };
 }
-function be(e) {
+function Re(e) {
   for (let t = 0; t < e.length; t++) {
     const r = e.charCodeAt(t);
     if (r >= 55296 && r <= 56319) {
@@ -806,15 +799,15 @@ function be(e) {
         t++;
         continue;
       }
-      return J(e, t, 1, "Unpaired high surrogate is not a valid Unicode scalar value");
+      return Y(e, t, 1, "Unpaired high surrogate is not a valid Unicode scalar value");
     }
     if (r >= 56320 && r <= 57343)
-      return J(e, t, 1, "Unpaired low surrogate is not a valid Unicode scalar value");
+      return Y(e, t, 1, "Unpaired low surrogate is not a valid Unicode scalar value");
   }
 }
-function Oe(e, t) {
+function be(e, t) {
   for (const r of t)
-    if (bi.has(r.tokenType))
+    if (Si.has(r.tokenType))
       for (let i = 0; i < r.image.length; i++) {
         if (r.image[i] !== "\\") continue;
         const s = r.image[i + 1];
@@ -822,416 +815,416 @@ function Oe(e, t) {
           i++;
           continue;
         }
-        const a = s === "u" ? 4 : 8, o = a + 2, l = r.image.slice(i, i + o), E = r.image.slice(i + 2, i + o), y = r.startOffset + i;
-        if (E.length !== a || !/^[0-9a-fA-F]+$/.test(E))
-          return J(
+        const o = s === "u" ? 4 : 8, a = o + 2, u = r.image.slice(i, i + a), f = r.image.slice(i + 2, i + a), y = r.startOffset + i;
+        if (f.length !== o || !/^[0-9a-fA-F]+$/.test(f))
+          return Y(
             e,
             y,
-            l.length,
-            `Unicode escape \\${s} must contain ${a} hexadecimal digits`
+            u.length,
+            `Unicode escape \\${s} must contain ${o} hexadecimal digits`
           );
-        const S = Number.parseInt(E, 16);
-        if (S >= 55296 && S <= 57343)
-          return J(e, y, o, `Unicode escape ${l} denotes a surrogate code point`);
-        if (S > 1114111)
-          return J(e, y, o, `Unicode escape ${l} is outside the Unicode range`);
-        i += o - 1;
+        const m = Number.parseInt(f, 16);
+        if (m >= 55296 && m <= 57343)
+          return Y(e, y, a, `Unicode escape ${u} denotes a surrogate code point`);
+        if (m > 1114111)
+          return Y(e, y, a, `Unicode escape ${u} is outside the Unicode range`);
+        i += a - 1;
       }
 }
-class xe extends Br {
-  constructor(r = {}) {
-    super(lr);
-    // Rule := RuleHead ':-' RuleBody '.'
-    d(this, "rule", this.RULE("rule", () => {
-      this.SUBRULE(this.ruleHead), this.CONSUME(kt), this.OPTION(() => {
-        this.SUBRULE(this.ruleBody);
-      }), this.CONSUME(ge);
-    }));
-    // RuleHead := TupleTableAtom (',' TupleTableAtom)*
-    d(this, "ruleHead", this.RULE("ruleHead", () => {
-      this.SUBRULE(this.tupleTableAtom), this.MANY(() => {
-        this.CONSUME(N), this.SUBRULE2(this.tupleTableAtom);
-      });
-    }));
-    // RuleBody := BodyFormula (',' BodyFormula)*
-    d(this, "ruleBody", this.RULE("ruleBody", () => {
-      this.SUBRULE(this.bodyFormula), this.MANY(() => {
-        this.CONSUME(N), this.SUBRULE2(this.bodyFormula);
-      });
-    }));
-    // BodyFormula := Negation | FilterAtom | BindAtom | Aggregate | SkolemAtom | TupleTableAtom
-    d(this, "bodyFormula", this.RULE("bodyFormula", () => {
-      this.OR([
-        { ALT: () => this.SUBRULE(this.negation) },
-        { ALT: () => this.SUBRULE(this.filterAtom) },
-        { ALT: () => this.SUBRULE(this.bindAtom) },
-        { ALT: () => this.SUBRULE(this.aggregate) },
-        { ALT: () => this.SUBRULE(this.skolemAtom) },
-        { ALT: () => this.SUBRULE(this.tupleTableAtom) }
-      ]);
-    }));
-    // TupleTableAtom := (DefaultGraphAtom Graph?) | GeneralAtom
-    // NamedGraphAtom := DefaultGraphAtom Graph
-    // Graph := Term (IRI or Variable)
-    d(this, "tupleTableAtom", this.RULE("tupleTableAtom", () => {
-      this.OR([{ ALT: () => this.SUBRULE(this.defaultGraphAtom) }, { ALT: () => this.SUBRULE(this.generalAtom) }]), this.OPTION(() => {
-        this.SUBRULE(this.graphName, { LABEL: "graph" });
-      });
-    }));
-    // Graph name for named graph atoms - can be IRI or Variable
-    d(this, "graphName", this.RULE("graphName", () => {
-      this.OR([{ ALT: () => this.CONSUME(b) }, { ALT: () => this.SUBRULE(this.iri) }]);
-    }));
-    // DefaultGraphAtom := TripleAtom | PropertyAtom | ClassAtom
-    d(this, "defaultGraphAtom", this.RULE("defaultGraphAtom", () => {
-      this.OR([
-        // TripleAtom: [term, term, term]
-        {
-          ALT: () => {
-            this.CONSUME(Et), this.SUBRULE(this.term, { LABEL: "subject" }), this.CONSUME(N), this.SUBRULE2(this.term, { LABEL: "predicate" }), this.CONSUME2(N), this.SUBRULE3(this.term, { LABEL: "object" }), this.CONSUME(ft);
-          }
-        },
-        // PropertyAtom: predicate[term, term] or ClassAtom: class[term]
+class Oe extends Cr {
+  constructor(t = {}) {
+    super(or);
+    const { selfAnalysis: r = !0 } = t;
+    r && this.performSelfAnalysis();
+  }
+  // Chevrotain only reports leftover input for the rule it was entered on, so
+  // callers entering on a nested rule have to reject trailing tokens themselves.
+  get atEndOfInput() {
+    return this.LA(1).tokenType === Ir;
+  }
+  // Rule := RuleHead ':-' RuleBody '.'
+  rule = this.RULE("rule", () => {
+    this.SUBRULE(this.ruleHead), this.CONSUME(Pt), this.OPTION(() => {
+      this.SUBRULE(this.ruleBody);
+    }), this.CONSUME(fe);
+  });
+  // RuleHead := TupleTableAtom (',' TupleTableAtom)*
+  ruleHead = this.RULE("ruleHead", () => {
+    this.SUBRULE(this.tupleTableAtom), this.MANY(() => {
+      this.CONSUME(S), this.SUBRULE2(this.tupleTableAtom);
+    });
+  });
+  // RuleBody := BodyFormula (',' BodyFormula)*
+  ruleBody = this.RULE("ruleBody", () => {
+    this.SUBRULE(this.bodyFormula), this.MANY(() => {
+      this.CONSUME(S), this.SUBRULE2(this.bodyFormula);
+    });
+  });
+  // BodyFormula := Negation | FilterAtom | BindAtom | Aggregate | SkolemAtom | TupleTableAtom
+  bodyFormula = this.RULE("bodyFormula", () => {
+    this.OR([
+      { ALT: () => this.SUBRULE(this.negation) },
+      { ALT: () => this.SUBRULE(this.filterAtom) },
+      { ALT: () => this.SUBRULE(this.bindAtom) },
+      { ALT: () => this.SUBRULE(this.aggregate) },
+      { ALT: () => this.SUBRULE(this.skolemAtom) },
+      { ALT: () => this.SUBRULE(this.tupleTableAtom) }
+    ]);
+  });
+  // TupleTableAtom := (DefaultGraphAtom Graph?) | GeneralAtom
+  // NamedGraphAtom := DefaultGraphAtom Graph
+  // Graph := Term (IRI or Variable)
+  tupleTableAtom = this.RULE("tupleTableAtom", () => {
+    this.OR([{ ALT: () => this.SUBRULE(this.defaultGraphAtom) }, { ALT: () => this.SUBRULE(this.generalAtom) }]), this.OPTION(() => {
+      this.SUBRULE(this.graphName, { LABEL: "graph" });
+    });
+  });
+  // Graph name for named graph atoms - can be IRI or Variable
+  graphName = this.RULE("graphName", () => {
+    this.OR([{ ALT: () => this.CONSUME(N) }, { ALT: () => this.SUBRULE(this.iri) }]);
+  });
+  // DefaultGraphAtom := TripleAtom | PropertyAtom | ClassAtom
+  defaultGraphAtom = this.RULE("defaultGraphAtom", () => {
+    this.OR([
+      // TripleAtom: [term, term, term]
+      {
+        ALT: () => {
+          this.CONSUME(ht), this.SUBRULE(this.term, { LABEL: "subject" }), this.CONSUME(S), this.SUBRULE2(this.term, { LABEL: "predicate" }), this.CONSUME2(S), this.SUBRULE3(this.term, { LABEL: "object" }), this.CONSUME(dt);
+        }
+      },
+      // PropertyAtom: predicate[term, term] or ClassAtom: class[term]
+      {
+        ALT: () => {
+          this.SUBRULE(this.iri, { LABEL: "predicateOrClass" }), this.CONSUME2(ht), this.SUBRULE4(this.term, { LABEL: "firstTerm" }), this.OPTION(() => {
+            this.CONSUME3(S), this.SUBRULE5(this.term, { LABEL: "secondTerm" });
+          }), this.CONSUME2(dt);
+        }
+      }
+    ]);
+  });
+  // GeneralAtom := tableName(term, ...)
+  generalAtom = this.RULE("generalAtom", () => {
+    this.OR([{ ALT: () => this.CONSUME(tt) }, { ALT: () => this.CONSUME(ft) }]), this.CONSUME(L), this.SUBRULE(this.term), this.MANY(() => {
+      this.CONSUME(S), this.SUBRULE2(this.term);
+    }), this.CONSUME(U);
+  });
+  // Term := Variable | IRI | Literal | BlankNode
+  term = this.RULE("term", () => {
+    this.OR([
+      { ALT: () => this.CONSUME(N) },
+      { ALT: () => this.SUBRULE(this.iri) },
+      { ALT: () => this.SUBRULE(this.literal) },
+      { ALT: () => this.CONSUME(J) }
+    ]);
+  });
+  // IRI := IRI_REF | PrefixedName | DefaultNsIRI | InternalFunction
+  iri = this.RULE("iri", () => {
+    this.OR([
+      { ALT: () => this.CONSUME(ge) },
+      { ALT: () => this.CONSUME(me) },
+      { ALT: () => this.CONSUME(it) },
+      { ALT: () => this.CONSUME(Le) },
+      { ALT: () => this.CONSUME(wt) },
+      { ALT: () => this.CONSUME(tt) }
+    ]);
+  });
+  // Literal := NumericLiteral | BooleanLiteral | StringLiteral
+  literal = this.RULE("literal", () => {
+    this.OR([
+      { ALT: () => this.SUBRULE(this.numericLiteral) },
+      { ALT: () => this.SUBRULE(this.booleanLiteral) },
+      { ALT: () => this.SUBRULE(this.stringLiteral) }
+    ]);
+  });
+  numericLiteral = this.RULE("numericLiteral", () => {
+    this.OR([
+      { ALT: () => this.CONSUME(Ae) },
+      { ALT: () => this.CONSUME(we) },
+      { ALT: () => this.CONSUME(Ue) }
+    ]);
+  });
+  booleanLiteral = this.RULE("booleanLiteral", () => {
+    this.OR([{ ALT: () => this.CONSUME(ie) }, { ALT: () => this.CONSUME(ne) }]);
+  });
+  stringLiteral = this.RULE("stringLiteral", () => {
+    this.OR([
+      { ALT: () => this.CONSUME(Te) },
+      { ALT: () => this.CONSUME(ft) }
+    ]), this.OPTION(() => {
+      this.OR2([
+        { ALT: () => this.CONSUME(Se) },
         {
           ALT: () => {
-            this.SUBRULE(this.iri, { LABEL: "predicateOrClass" }), this.CONSUME2(Et), this.SUBRULE4(this.term, { LABEL: "firstTerm" }), this.OPTION(() => {
-              this.CONSUME3(N), this.SUBRULE5(this.term, { LABEL: "secondTerm" });
-            }), this.CONSUME2(ft);
+            this.CONSUME(Et), this.CONSUME2(Et), this.SUBRULE(this.iri);
           }
         }
       ]);
-    }));
-    // GeneralAtom := tableName(term, ...)
-    d(this, "generalAtom", this.RULE("generalAtom", () => {
-      this.OR([{ ALT: () => this.CONSUME(rt) }, { ALT: () => this.CONSUME(mt) }]), this.CONSUME(U), this.SUBRULE(this.term), this.MANY(() => {
-        this.CONSUME(N), this.SUBRULE2(this.term);
-      }), this.CONSUME(w);
-    }));
-    // Term := Variable | IRI | Literal | BlankNode
-    d(this, "term", this.RULE("term", () => {
-      this.OR([
-        { ALT: () => this.CONSUME(b) },
-        { ALT: () => this.SUBRULE(this.iri) },
-        { ALT: () => this.SUBRULE(this.literal) },
-        { ALT: () => this.CONSUME(et) }
-      ]);
-    }));
-    // IRI := IRI_REF | PrefixedName | DefaultNsIRI | InternalFunction
-    d(this, "iri", this.RULE("iri", () => {
-      this.OR([
-        { ALT: () => this.CONSUME(me) },
-        { ALT: () => this.CONSUME(ye) },
-        { ALT: () => this.CONSUME(st) },
-        { ALT: () => this.CONSUME(Ue) },
-        { ALT: () => this.CONSUME(Tt) },
-        { ALT: () => this.CONSUME(rt) }
-      ]);
-    }));
-    // Literal := NumericLiteral | BooleanLiteral | StringLiteral
-    d(this, "literal", this.RULE("literal", () => {
-      this.OR([
-        { ALT: () => this.SUBRULE(this.numericLiteral) },
-        { ALT: () => this.SUBRULE(this.booleanLiteral) },
-        { ALT: () => this.SUBRULE(this.stringLiteral) }
-      ]);
-    }));
-    d(this, "numericLiteral", this.RULE("numericLiteral", () => {
-      this.OR([
-        { ALT: () => this.CONSUME(Te) },
-        { ALT: () => this.CONSUME(Ae) },
-        { ALT: () => this.CONSUME(we) }
-      ]);
-    }));
-    d(this, "booleanLiteral", this.RULE("booleanLiteral", () => {
-      this.OR([{ ALT: () => this.CONSUME(ne) }, { ALT: () => this.CONSUME(se) }]);
-    }));
-    d(this, "stringLiteral", this.RULE("stringLiteral", () => {
+    });
+  });
+  // Negation := 'NOT' ExistsClause? (Atom | '(' BodyFormulaList ')')
+  negation = this.RULE("negation", () => {
+    this.CONSUME(at), this.OPTION(() => {
+      this.SUBRULE(this.existsClause);
+    }), this.OR([
+      {
+        ALT: () => {
+          this.CONSUME(L), this.SUBRULE(this.bodyFormulaList), this.CONSUME(U);
+        }
+      },
+      { ALT: () => this.SUBRULE(this.tupleTableAtom) }
+    ]);
+  });
+  // ExistsClause := 'EXISTS' variable (',' variable)* 'IN'
+  existsClause = this.RULE("existsClause", () => {
+    this.CONSUME(kt), this.CONSUME(N), this.MANY(() => {
+      this.CONSUME(S), this.CONSUME2(N);
+    }), this.CONSUME(W);
+  });
+  // AtomList := Atom (',' Atom)*
+  atomList = this.RULE("atomList", () => {
+    this.SUBRULE(this.atom), this.MANY(() => {
+      this.CONSUME(S), this.SUBRULE2(this.atom);
+    });
+  });
+  // Atom := TupleTableAtom | FilterAtom | BindAtom
+  atom = this.RULE("atom", () => {
+    this.OR([
+      { ALT: () => this.SUBRULE(this.tupleTableAtom) },
+      { ALT: () => this.SUBRULE(this.filterAtom) },
+      { ALT: () => this.SUBRULE(this.bindAtom) }
+    ]);
+  });
+  // BodyFormulaList := BodyFormula (',' BodyFormula)*
+  bodyFormulaList = this.RULE("bodyFormulaList", () => {
+    this.SUBRULE(this.bodyFormula), this.MANY(() => {
+      this.CONSUME(S), this.SUBRULE2(this.bodyFormula);
+    });
+  });
+  // FilterAtom := 'FILTER' '(' Expression ')'
+  filterAtom = this.RULE("filterAtom", () => {
+    this.CONSUME($t), this.CONSUME(L), this.SUBRULE(this.expression), this.CONSUME(U);
+  });
+  // BindAtom := 'BIND' '(' Expression 'AS' variable ')'
+  bindAtom = this.RULE("bindAtom", () => {
+    this.CONSUME(Q), this.CONSUME(L), this.SUBRULE(this.expression), this.CONSUME(z), this.CONSUME(N), this.CONSUME(U);
+  });
+  // SkolemAtom := 'SKOLEM' '(' ArgumentList ')'
+  skolemAtom = this.RULE("skolemAtom", () => {
+    this.CONSUME(lt), this.CONSUME(L), this.SUBRULE(this.argumentList), this.CONSUME(U);
+  });
+  // Aggregate := 'AGGREGATE' '(' AtomList OnClause? AggregateBind* ')'
+  aggregate = this.RULE("aggregate", () => {
+    this.CONSUME(Lt), this.CONSUME(L), this.SUBRULE(this.atomList), this.OPTION(() => {
+      this.SUBRULE(this.onClause);
+    }), this.MANY(() => {
+      this.SUBRULE(this.aggregateBind);
+    }), this.CONSUME(U);
+  });
+  // OnClause := 'ON' variable+
+  onClause = this.RULE("onClause", () => {
+    this.CONSUME(Ut), this.CONSUME(N), this.MANY(() => {
+      this.CONSUME2(N);
+    });
+  });
+  // AggregateBind := ('BIND' AggregateFunction | AggregateFunction) 'AS' variable
+  aggregateBind = this.RULE("aggregateBind", () => {
+    this.OPTION(() => {
+      this.CONSUME(Q);
+    }), this.SUBRULE(this.aggregateFunction), this.CONSUME(z), this.CONSUME(N);
+  });
+  // AggregateFunction := AggregateFunction1 | AggregateFunction2
+  aggregateFunction = this.RULE("aggregateFunction", () => {
+    this.OR([
+      { ALT: () => this.SUBRULE(this.aggregateFunction1) },
+      { ALT: () => this.SUBRULE(this.aggregateFunction2) }
+    ]);
+  });
+  // AggregateFunction1 := (SUM | MUL | AVG | MIN | COUNT_MIN | MAX | COUNT_MAX | COUNT) '(' DISTINCT? (STAR | Expression) ')'
+  aggregateFunction1 = this.RULE("aggregateFunction1", () => {
+    this.OR([
+      { ALT: () => this.CONSUME(Xt) },
+      { ALT: () => this.CONSUME(Ht) },
+      { ALT: () => this.CONSUME(Dt) },
+      { ALT: () => this.CONSUME(Gt) },
+      { ALT: () => this.CONSUME(_t) },
+      { ALT: () => this.CONSUME(Vt) },
+      { ALT: () => this.CONSUME(jt) },
+      { ALT: () => this.CONSUME(qt) }
+    ]), this.CONSUME(L), this.OPTION(() => {
+      this.CONSUME(ot);
+    }), this.OR2([{ ALT: () => this.CONSUME(pt) }, { ALT: () => this.SUBRULE(this.expression) }]), this.CONSUME(U);
+  });
+  // AggregateFunction2 := (MIN_ARGMIN | MAX_ARGMIN | MIN_ARGMAX | MAX_ARGMAX) '(' DISTINCT? Expression ',' Expression ')'
+  aggregateFunction2 = this.RULE("aggregateFunction2", () => {
+    this.OR([
+      { ALT: () => this.CONSUME(Qt) },
+      { ALT: () => this.CONSUME(zt) },
+      { ALT: () => this.CONSUME(Kt) },
+      { ALT: () => this.CONSUME(Wt) }
+    ]), this.CONSUME(L), this.OPTION(() => {
+      this.CONSUME(ot);
+    }), this.SUBRULE(this.expression, { LABEL: "firstExpr" }), this.CONSUME(S), this.SUBRULE2(this.expression, { LABEL: "secondExpr" }), this.CONSUME(U);
+  });
+  // Expression (simplified for now)
+  expression = this.RULE("expression", () => {
+    this.SUBRULE(this.conditionalOrExpression);
+  });
+  conditionalOrExpression = this.RULE("conditionalOrExpression", () => {
+    this.SUBRULE(this.conditionalAndExpression), this.MANY(() => {
+      this.CONSUME(he), this.SUBRULE2(this.conditionalAndExpression);
+    });
+  });
+  conditionalAndExpression = this.RULE("conditionalAndExpression", () => {
+    this.SUBRULE(this.relationalExpression), this.MANY(() => {
+      this.CONSUME(pe), this.SUBRULE2(this.relationalExpression);
+    });
+  });
+  relationalExpression = this.RULE("relationalExpression", () => {
+    this.SUBRULE(this.additiveExpression), this.OPTION(() => {
       this.OR([
-        { ALT: () => this.CONSUME(Se) },
-        { ALT: () => this.CONSUME(mt) }
-      ]), this.OPTION(() => {
-        this.OR2([
-          { ALT: () => this.CONSUME(Ne) },
-          {
-            ALT: () => {
-              this.CONSUME(gt), this.CONSUME2(gt), this.SUBRULE(this.iri);
-            }
-          }
-        ]);
-      });
-    }));
-    // Negation := 'NOT' ExistsClause? (Atom | '(' BodyFormulaList ')')
-    d(this, "negation", this.RULE("negation", () => {
-      this.CONSUME(lt), this.OPTION(() => {
-        this.SUBRULE(this.existsClause);
-      }), this.OR([
         {
           ALT: () => {
-            this.CONSUME(U), this.SUBRULE(this.bodyFormulaList), this.CONSUME(w);
+            this.OR2([
+              { ALT: () => this.CONSUME(se) },
+              { ALT: () => this.CONSUME(ae) },
+              { ALT: () => this.CONSUME(oe) },
+              { ALT: () => this.CONSUME(ue) },
+              { ALT: () => this.CONSUME(le) },
+              { ALT: () => this.CONSUME(ce) }
+            ]), this.SUBRULE2(this.additiveExpression);
           }
         },
-        { ALT: () => this.SUBRULE(this.tupleTableAtom) }
-      ]);
-    }));
-    // ExistsClause := 'EXISTS' variable (',' variable)* 'IN'
-    d(this, "existsClause", this.RULE("existsClause", () => {
-      this.CONSUME($t), this.CONSUME(b), this.MANY(() => {
-        this.CONSUME(N), this.CONSUME2(b);
-      }), this.CONSUME(Z);
-    }));
-    // AtomList := Atom (',' Atom)*
-    d(this, "atomList", this.RULE("atomList", () => {
-      this.SUBRULE(this.atom), this.MANY(() => {
-        this.CONSUME(N), this.SUBRULE2(this.atom);
-      });
-    }));
-    // Atom := TupleTableAtom | FilterAtom | BindAtom
-    d(this, "atom", this.RULE("atom", () => {
-      this.OR([
-        { ALT: () => this.SUBRULE(this.tupleTableAtom) },
-        { ALT: () => this.SUBRULE(this.filterAtom) },
-        { ALT: () => this.SUBRULE(this.bindAtom) }
-      ]);
-    }));
-    // BodyFormulaList := BodyFormula (',' BodyFormula)*
-    d(this, "bodyFormulaList", this.RULE("bodyFormulaList", () => {
-      this.SUBRULE(this.bodyFormula), this.MANY(() => {
-        this.CONSUME(N), this.SUBRULE2(this.bodyFormula);
-      });
-    }));
-    // FilterAtom := 'FILTER' '(' Expression ')'
-    d(this, "filterAtom", this.RULE("filterAtom", () => {
-      this.CONSUME(Dt), this.CONSUME(U), this.SUBRULE(this.expression), this.CONSUME(w);
-    }));
-    // BindAtom := 'BIND' '(' Expression 'AS' variable ')'
-    d(this, "bindAtom", this.RULE("bindAtom", () => {
-      this.CONSUME(z), this.CONSUME(U), this.SUBRULE(this.expression), this.CONSUME(K), this.CONSUME(b), this.CONSUME(w);
-    }));
-    // SkolemAtom := 'SKOLEM' '(' ArgumentList ')'
-    d(this, "skolemAtom", this.RULE("skolemAtom", () => {
-      this.CONSUME(ct), this.CONSUME(U), this.SUBRULE(this.argumentList), this.CONSUME(w);
-    }));
-    // Aggregate := 'AGGREGATE' '(' AtomList OnClause? AggregateBind* ')'
-    d(this, "aggregate", this.RULE("aggregate", () => {
-      this.CONSUME(wt), this.CONSUME(U), this.SUBRULE(this.atomList), this.OPTION(() => {
-        this.SUBRULE(this.onClause);
-      }), this.MANY(() => {
-        this.SUBRULE(this.aggregateBind);
-      }), this.CONSUME(w);
-    }));
-    // OnClause := 'ON' variable+
-    d(this, "onClause", this.RULE("onClause", () => {
-      this.CONSUME(At), this.CONSUME(b), this.MANY(() => {
-        this.CONSUME2(b);
-      });
-    }));
-    // AggregateBind := ('BIND' AggregateFunction | AggregateFunction) 'AS' variable
-    d(this, "aggregateBind", this.RULE("aggregateBind", () => {
-      this.OPTION(() => {
-        this.CONSUME(z);
-      }), this.SUBRULE(this.aggregateFunction), this.CONSUME(K), this.CONSUME(b);
-    }));
-    // AggregateFunction := AggregateFunction1 | AggregateFunction2
-    d(this, "aggregateFunction", this.RULE("aggregateFunction", () => {
-      this.OR([
-        { ALT: () => this.SUBRULE(this.aggregateFunction1) },
-        { ALT: () => this.SUBRULE(this.aggregateFunction2) }
-      ]);
-    }));
-    // AggregateFunction1 := (SUM | MUL | AVG | MIN | COUNT_MIN | MAX | COUNT_MAX | COUNT) '(' DISTINCT? (STAR | Expression) ')'
-    d(this, "aggregateFunction1", this.RULE("aggregateFunction1", () => {
-      this.OR([
-        { ALT: () => this.CONSUME(Ht) },
-        { ALT: () => this.CONSUME(Qt) },
-        { ALT: () => this.CONSUME(Gt) },
-        { ALT: () => this.CONSUME(_t) },
-        { ALT: () => this.CONSUME(Vt) },
-        { ALT: () => this.CONSUME(jt) },
-        { ALT: () => this.CONSUME(qt) },
-        { ALT: () => this.CONSUME(Xt) }
-      ]), this.CONSUME(U), this.OPTION(() => {
-        this.CONSUME(ut);
-      }), this.OR2([{ ALT: () => this.CONSUME(dt) }, { ALT: () => this.SUBRULE(this.expression) }]), this.CONSUME(w);
-    }));
-    // AggregateFunction2 := (MIN_ARGMIN | MAX_ARGMIN | MIN_ARGMAX | MAX_ARGMAX) '(' DISTINCT? Expression ',' Expression ')'
-    d(this, "aggregateFunction2", this.RULE("aggregateFunction2", () => {
-      this.OR([
-        { ALT: () => this.CONSUME(zt) },
-        { ALT: () => this.CONSUME(Kt) },
-        { ALT: () => this.CONSUME(Wt) },
-        { ALT: () => this.CONSUME(Yt) }
-      ]), this.CONSUME(U), this.OPTION(() => {
-        this.CONSUME(ut);
-      }), this.SUBRULE(this.expression, { LABEL: "firstExpr" }), this.CONSUME(N), this.SUBRULE2(this.expression, { LABEL: "secondExpr" }), this.CONSUME(w);
-    }));
-    // Expression (simplified for now)
-    d(this, "expression", this.RULE("expression", () => {
-      this.SUBRULE(this.conditionalOrExpression);
-    }));
-    d(this, "conditionalOrExpression", this.RULE("conditionalOrExpression", () => {
-      this.SUBRULE(this.conditionalAndExpression), this.MANY(() => {
-        this.CONSUME(de), this.SUBRULE2(this.conditionalAndExpression);
-      });
-    }));
-    d(this, "conditionalAndExpression", this.RULE("conditionalAndExpression", () => {
-      this.SUBRULE(this.relationalExpression), this.MANY(() => {
-        this.CONSUME(he), this.SUBRULE2(this.relationalExpression);
-      });
-    }));
-    d(this, "relationalExpression", this.RULE("relationalExpression", () => {
-      this.SUBRULE(this.additiveExpression), this.OPTION(() => {
-        this.OR([
-          {
-            ALT: () => {
-              this.OR2([
-                { ALT: () => this.CONSUME(ae) },
-                { ALT: () => this.CONSUME(oe) },
-                { ALT: () => this.CONSUME(le) },
-                { ALT: () => this.CONSUME(ce) },
-                { ALT: () => this.CONSUME(ue) },
-                { ALT: () => this.CONSUME(pe) }
-              ]), this.SUBRULE2(this.additiveExpression);
-            }
-          },
-          // Handle IN
-          {
-            ALT: () => {
-              this.CONSUME(Z), this.CONSUME2(U), this.SUBRULE(this.argumentList), this.CONSUME3(w);
-            }
-          },
-          // Handle NOT IN
-          {
-            ALT: () => {
-              this.CONSUME(lt), this.CONSUME2(Z), this.CONSUME4(U), this.SUBRULE2(this.argumentList), this.CONSUME5(w);
-            }
+        // Handle IN
+        {
+          ALT: () => {
+            this.CONSUME(W), this.CONSUME2(L), this.SUBRULE(this.argumentList), this.CONSUME3(U);
           }
-        ]);
-      });
-    }));
-    d(this, "additiveExpression", this.RULE("additiveExpression", () => {
-      this.SUBRULE(this.multiplicativeExpression), this.MANY(() => {
-        this.OR([{ ALT: () => this.CONSUME(pt) }, { ALT: () => this.CONSUME(ht) }]), this.SUBRULE2(this.multiplicativeExpression);
-      });
-    }));
-    d(this, "multiplicativeExpression", this.RULE("multiplicativeExpression", () => {
-      this.SUBRULE(this.unaryExpression), this.MANY(() => {
-        this.OR([{ ALT: () => this.CONSUME(dt) }, { ALT: () => this.CONSUME(Ee) }]), this.SUBRULE2(this.unaryExpression);
-      });
-    }));
-    d(this, "unaryExpression", this.RULE("unaryExpression", () => {
-      this.OPTION(() => {
-        this.OR([
-          { ALT: () => this.CONSUME(fe) },
-          { ALT: () => this.CONSUME(pt) },
-          { ALT: () => this.CONSUME(ht) }
-        ]);
-      }), this.SUBRULE(this.primaryExpression);
-    }));
-    // Function calls
-    d(this, "functionCall", this.RULE("functionCall", () => {
-      this.OR([
-        // Built-in functions
-        { ALT: () => this.SUBRULE(this.concatFunction) },
-        { ALT: () => this.SUBRULE(this.strFunction) },
-        { ALT: () => this.SUBRULE(this.ifFunction) },
-        { ALT: () => this.SUBRULE(this.iriFunction) },
-        { ALT: () => this.SUBRULE(this.skolemFunction) },
-        { ALT: () => this.SUBRULE(this.roundFunction) },
-        { ALT: () => this.SUBRULE(this.regexFunction) },
-        // Generic function call (IRI followed by arguments)
+        },
+        // Handle NOT IN
         {
           ALT: () => {
-            this.SUBRULE(this.iri), this.CONSUME(U), this.OPTION(() => {
-              this.SUBRULE(this.argumentList);
-            }), this.CONSUME(w);
+            this.CONSUME(at), this.CONSUME2(W), this.CONSUME4(L), this.SUBRULE2(this.argumentList), this.CONSUME5(U);
           }
         }
       ]);
-    }));
-    // CONCAT function
-    d(this, "concatFunction", this.RULE("concatFunction", () => {
-      this.CONSUME(Zt), this.CONSUME(U), this.SUBRULE(this.argumentList), this.CONSUME(w);
-    }));
-    // STR function
-    d(this, "strFunction", this.RULE("strFunction", () => {
-      this.CONSUME(Jt), this.CONSUME(U), this.SUBRULE(this.expression), this.CONSUME(w);
-    }));
-    // IF function
-    d(this, "ifFunction", this.RULE("ifFunction", () => {
-      this.CONSUME(te), this.CONSUME(U), this.SUBRULE(this.expression, { LABEL: "condition" }), this.CONSUME(N), this.SUBRULE2(this.expression, { LABEL: "thenExpr" }), this.CONSUME2(N), this.SUBRULE3(this.expression, { LABEL: "elseExpr" }), this.CONSUME(w);
-    }));
-    // IRI function
-    d(this, "iriFunction", this.RULE("iriFunction", () => {
-      this.CONSUME(ee), this.CONSUME(U), this.SUBRULE(this.expression, { LABEL: "iriExpr" }), this.OPTION(() => {
-        this.CONSUME(N), this.SUBRULE2(this.expression, { LABEL: "baseIri" });
-      }), this.CONSUME(w);
-    }));
-    // SKOLEM function
-    d(this, "skolemFunction", this.RULE("skolemFunction", () => {
-      this.CONSUME(ct), this.CONSUME(U), this.SUBRULE(this.argumentList), this.CONSUME(w);
-    }));
-    // ROUND function
-    d(this, "roundFunction", this.RULE("roundFunction", () => {
-      this.CONSUME(re), this.CONSUME(U), this.SUBRULE(this.expression), this.CONSUME(w);
-    }));
-    // REGEX function
-    d(this, "regexFunction", this.RULE("regexFunction", () => {
-      this.CONSUME(ie), this.CONSUME(U), this.SUBRULE(this.expression, { LABEL: "textExpr" }), this.CONSUME(N), this.SUBRULE2(this.expression, { LABEL: "patternExpr" }), this.OPTION(() => {
-        this.CONSUME2(N), this.SUBRULE3(this.expression, { LABEL: "flagsExpr" });
-      }), this.CONSUME(w);
-    }));
-    // Argument list
-    d(this, "argumentList", this.RULE("argumentList", () => {
-      this.SUBRULE(this.expression), this.MANY(() => {
-        this.CONSUME(N), this.SUBRULE2(this.expression);
-      });
-    }));
-    d(this, "primaryExpression", this.RULE("primaryExpression", () => {
+    });
+  });
+  additiveExpression = this.RULE("additiveExpression", () => {
+    this.SUBRULE(this.multiplicativeExpression), this.MANY(() => {
+      this.OR([{ ALT: () => this.CONSUME(ut) }, { ALT: () => this.CONSUME(ct) }]), this.SUBRULE2(this.multiplicativeExpression);
+    });
+  });
+  multiplicativeExpression = this.RULE("multiplicativeExpression", () => {
+    this.SUBRULE(this.unaryExpression), this.MANY(() => {
+      this.OR([{ ALT: () => this.CONSUME(pt) }, { ALT: () => this.CONSUME(de) }]), this.SUBRULE2(this.unaryExpression);
+    });
+  });
+  unaryExpression = this.RULE("unaryExpression", () => {
+    this.OPTION(() => {
       this.OR([
-        {
-          ALT: () => {
-            this.CONSUME(U), this.SUBRULE(this.expression), this.CONSUME(w);
-          }
-        },
-        { ALT: () => this.SUBRULE(this.functionCall) },
-        { ALT: () => this.SUBRULE(this.literal) },
-        { ALT: () => this.CONSUME(b) },
-        { ALT: () => this.SUBRULE(this.iri) }
+        { ALT: () => this.CONSUME(Ee) },
+        { ALT: () => this.CONSUME(ut) },
+        { ALT: () => this.CONSUME(ct) }
       ]);
-    }));
-    const { selfAnalysis: i = !0 } = r;
-    i && this.performSelfAnalysis();
-  }
-  // Chevrotain only reports leftover input for the rule it was entered on, so
-  // callers entering on a nested rule have to reject trailing tokens themselves.
-  get atEndOfInput() {
-    return this.LA(1).tokenType === Fr;
-  }
+    }), this.SUBRULE(this.primaryExpression);
+  });
+  // Function calls
+  functionCall = this.RULE("functionCall", () => {
+    this.OR([
+      // Built-in functions
+      { ALT: () => this.SUBRULE(this.concatFunction) },
+      { ALT: () => this.SUBRULE(this.strFunction) },
+      { ALT: () => this.SUBRULE(this.ifFunction) },
+      { ALT: () => this.SUBRULE(this.iriFunction) },
+      { ALT: () => this.SUBRULE(this.skolemFunction) },
+      { ALT: () => this.SUBRULE(this.roundFunction) },
+      { ALT: () => this.SUBRULE(this.regexFunction) },
+      // Generic function call (IRI followed by arguments)
+      {
+        ALT: () => {
+          this.SUBRULE(this.iri), this.CONSUME(L), this.OPTION(() => {
+            this.SUBRULE(this.argumentList);
+          }), this.CONSUME(U);
+        }
+      }
+    ]);
+  });
+  // CONCAT function
+  concatFunction = this.RULE("concatFunction", () => {
+    this.CONSUME(Yt), this.CONSUME(L), this.SUBRULE(this.argumentList), this.CONSUME(U);
+  });
+  // STR function
+  strFunction = this.RULE("strFunction", () => {
+    this.CONSUME(Zt), this.CONSUME(L), this.SUBRULE(this.expression), this.CONSUME(U);
+  });
+  // IF function
+  ifFunction = this.RULE("ifFunction", () => {
+    this.CONSUME(Jt), this.CONSUME(L), this.SUBRULE(this.expression, { LABEL: "condition" }), this.CONSUME(S), this.SUBRULE2(this.expression, { LABEL: "thenExpr" }), this.CONSUME2(S), this.SUBRULE3(this.expression, { LABEL: "elseExpr" }), this.CONSUME(U);
+  });
+  // IRI function
+  iriFunction = this.RULE("iriFunction", () => {
+    this.CONSUME(te), this.CONSUME(L), this.SUBRULE(this.expression, { LABEL: "iriExpr" }), this.OPTION(() => {
+      this.CONSUME(S), this.SUBRULE2(this.expression, { LABEL: "baseIri" });
+    }), this.CONSUME(U);
+  });
+  // SKOLEM function
+  skolemFunction = this.RULE("skolemFunction", () => {
+    this.CONSUME(lt), this.CONSUME(L), this.SUBRULE(this.argumentList), this.CONSUME(U);
+  });
+  // ROUND function
+  roundFunction = this.RULE("roundFunction", () => {
+    this.CONSUME(ee), this.CONSUME(L), this.SUBRULE(this.expression), this.CONSUME(U);
+  });
+  // REGEX function
+  regexFunction = this.RULE("regexFunction", () => {
+    this.CONSUME(re), this.CONSUME(L), this.SUBRULE(this.expression, { LABEL: "textExpr" }), this.CONSUME(S), this.SUBRULE2(this.expression, { LABEL: "patternExpr" }), this.OPTION(() => {
+      this.CONSUME2(S), this.SUBRULE3(this.expression, { LABEL: "flagsExpr" });
+    }), this.CONSUME(U);
+  });
+  // Argument list
+  argumentList = this.RULE("argumentList", () => {
+    this.SUBRULE(this.expression), this.MANY(() => {
+      this.CONSUME(S), this.SUBRULE2(this.expression);
+    });
+  });
+  primaryExpression = this.RULE("primaryExpression", () => {
+    this.OR([
+      {
+        ALT: () => {
+          this.CONSUME(L), this.SUBRULE(this.expression), this.CONSUME(U);
+        }
+      },
+      { ALT: () => this.SUBRULE(this.functionCall) },
+      { ALT: () => this.SUBRULE(this.literal) },
+      { ALT: () => this.CONSUME(N) },
+      { ALT: () => this.SUBRULE(this.iri) }
+    ]);
+  });
 }
-let xi;
-function ve() {
-  return xi ?? (xi = new xe());
+let Ri;
+function xe() {
+  return Ri ??= new Oe();
 }
-function ur(e, t) {
-  const r = be(t);
+function lr(e, t) {
+  const r = Re(t);
   if (r) throw new Error(r.message);
-  const i = Re(t);
+  const i = Ne(t);
   if (i.errors.length > 0)
-    throw new Error(`Lexer errors: ${i.errors.map((o) => o.message).join(", ")}`);
-  const s = Oe(t, i.tokens);
+    throw new Error(`Lexer errors: ${i.errors.map((a) => a.message).join(", ")}`);
+  const s = be(t, i.tokens);
   if (s) throw new Error(s.message);
   e.input = i.tokens;
-  const a = e.rule();
+  const o = e.rule();
   if (e.errors.length > 0)
-    throw new Error(`Parser errors: ${e.errors.map((o) => o.message).join(", ")}`);
-  return a;
+    throw new Error(`Parser errors: ${e.errors.map((a) => a.message).join(", ")}`);
+  return o;
 }
-function cr(e) {
-  return ur(ve(), e);
+function ur(e) {
+  return lr(xe(), e);
 }
-function ys(e) {
+function Es(e) {
   try {
-    return cr(e), { valid: !0 };
+    return ur(e), { valid: !0 };
   } catch (t) {
     return {
       valid: !1,
@@ -1239,137 +1232,136 @@ function ys(e) {
     };
   }
 }
-class vi extends xe {
+class bi extends Oe {
   constructor() {
-    super({ selfAnalysis: !1 });
-    // `term` cannot be used directly as the alternative to a variable: its own
-    // first alternative is VARIABLE, which would make the enclosing OR ambiguous.
-    d(this, "groundedAsTarget", this.RULE("groundedAsTarget", () => {
-      this.OR([
-        { ALT: () => this.SUBRULE(this.iri) },
-        { ALT: () => this.SUBRULE(this.literal) },
-        { ALT: () => this.CONSUME(et) }
-      ]);
-    }));
-    // OnClause := 'ON' (variable | GroundedAsTarget)*
-    // Grounding substitutes the grouping variables as well, and an aggregate
-    // over the whole store comes back with a bare 'ON', so both are accepted.
-    d(this, "expandedOnClause", this.OVERRIDE_RULE("onClause", () => {
-      this.CONSUME(At), this.MANY(() => {
-        this.variableOrGroundedTarget();
-      });
-    }));
-    // BindAtom := 'BIND' '(' Expression 'AS' (variable | GroundedAsTarget) ')'
-    d(this, "expandedBindAtom", this.OVERRIDE_RULE("bindAtom", () => {
-      this.CONSUME(z), this.CONSUME(U), this.SUBRULE(this.expression), this.CONSUME(K), this.variableOrGroundedTarget(), this.CONSUME(w);
-    }));
-    // Aggregate := 'AGGREGATE' '(' AtomList? OnClause? AggregateBind* ')'
-    // atomList is optional so engine-emitted atom-free forms parse; empty
-    // `AGGREGATE()` / `AGGREGATE(ON ?x)` are rejected after parse (visitor).
-    d(this, "expandedAggregate", this.OVERRIDE_RULE("aggregate", () => {
-      this.CONSUME(wt), this.CONSUME(U), this.OPTION(() => {
-        this.SUBRULE(this.atomList);
-      }), this.OPTION2(() => {
-        this.SUBRULE(this.onClause);
-      }), this.MANY(() => {
-        this.SUBRULE(this.aggregateBind);
-      }), this.CONSUME(w);
-    }));
-    // AggregateBind := 'BIND'? (AggregateFunction | Expression) 'AS' (variable | GroundedAsTarget)
-    d(this, "expandedAggregateBind", this.OVERRIDE_RULE("aggregateBind", () => {
-      this.OPTION(() => {
-        this.CONSUME(z);
-      }), this.OR2([{ ALT: () => this.SUBRULE(this.aggregateFunction) }, { ALT: () => this.SUBRULE(this.expression) }]), this.CONSUME(K), this.variableOrGroundedTarget();
-    }));
-    // Grounding substitutes SKOLEM outputs into expression positions as blank
-    // nodes, so the expanded grammar accepts them as primary expressions.
-    d(this, "expandedPrimaryExpression", this.OVERRIDE_RULE("primaryExpression", () => {
-      this.OR([
-        {
-          ALT: () => {
-            this.CONSUME(U), this.SUBRULE(this.expression), this.CONSUME(w);
-          }
-        },
-        { ALT: () => this.SUBRULE(this.functionCall) },
-        { ALT: () => this.SUBRULE(this.literal) },
-        { ALT: () => this.CONSUME(b) },
-        { ALT: () => this.CONSUME(et) },
-        { ALT: () => this.SUBRULE(this.iri) }
-      ]);
-    }));
-    this.performSelfAnalysis();
-  }
+    super({ selfAnalysis: !1 }), this.performSelfAnalysis();
+  }
+  // `term` cannot be used directly as the alternative to a variable: its own
+  // first alternative is VARIABLE, which would make the enclosing OR ambiguous.
+  groundedAsTarget = this.RULE("groundedAsTarget", () => {
+    this.OR([
+      { ALT: () => this.SUBRULE(this.iri) },
+      { ALT: () => this.SUBRULE(this.literal) },
+      { ALT: () => this.CONSUME(J) }
+    ]);
+  });
   // Each rule below records this once, so the default occurrence index is unambiguous.
   variableOrGroundedTarget() {
-    this.OR([{ ALT: () => this.CONSUME(b) }, { ALT: () => this.SUBRULE(this.groundedAsTarget) }]);
-  }
+    this.OR([{ ALT: () => this.CONSUME(N) }, { ALT: () => this.SUBRULE(this.groundedAsTarget) }]);
+  }
+  // OnClause := 'ON' (variable | GroundedAsTarget)*
+  // Grounding substitutes the grouping variables as well, and an aggregate
+  // over the whole store comes back with a bare 'ON', so both are accepted.
+  expandedOnClause = this.OVERRIDE_RULE("onClause", () => {
+    this.CONSUME(Ut), this.MANY(() => {
+      this.variableOrGroundedTarget();
+    });
+  });
+  // BindAtom := 'BIND' '(' Expression 'AS' (variable | GroundedAsTarget) ')'
+  expandedBindAtom = this.OVERRIDE_RULE("bindAtom", () => {
+    this.CONSUME(Q), this.CONSUME(L), this.SUBRULE(this.expression), this.CONSUME(z), this.variableOrGroundedTarget(), this.CONSUME(U);
+  });
+  // Aggregate := 'AGGREGATE' '(' AtomList? OnClause? AggregateBind* ')'
+  // atomList is optional so engine-emitted atom-free forms parse; empty
+  // `AGGREGATE()` / `AGGREGATE(ON ?x)` are rejected after parse (visitor).
+  expandedAggregate = this.OVERRIDE_RULE("aggregate", () => {
+    this.CONSUME(Lt), this.CONSUME(L), this.OPTION(() => {
+      this.SUBRULE(this.atomList);
+    }), this.OPTION2(() => {
+      this.SUBRULE(this.onClause);
+    }), this.MANY(() => {
+      this.SUBRULE(this.aggregateBind);
+    }), this.CONSUME(U);
+  });
+  // AggregateBind := 'BIND'? (AggregateFunction | Expression) 'AS' (variable | GroundedAsTarget)
+  expandedAggregateBind = this.OVERRIDE_RULE("aggregateBind", () => {
+    this.OPTION(() => {
+      this.CONSUME(Q);
+    }), this.OR2([{ ALT: () => this.SUBRULE(this.aggregateFunction) }, { ALT: () => this.SUBRULE(this.expression) }]), this.CONSUME(z), this.variableOrGroundedTarget();
+  });
+  // Grounding substitutes SKOLEM outputs into expression positions as blank
+  // nodes, so the expanded grammar accepts them as primary expressions.
+  expandedPrimaryExpression = this.OVERRIDE_RULE("primaryExpression", () => {
+    this.OR([
+      {
+        ALT: () => {
+          this.CONSUME(L), this.SUBRULE(this.expression), this.CONSUME(U);
+        }
+      },
+      { ALT: () => this.SUBRULE(this.functionCall) },
+      { ALT: () => this.SUBRULE(this.literal) },
+      { ALT: () => this.CONSUME(N) },
+      { ALT: () => this.CONSUME(J) },
+      { ALT: () => this.SUBRULE(this.iri) }
+    ]);
+  });
 }
-let Ci;
-function Ii() {
-  return Ci ?? (Ci = new vi());
+let Oi;
+function xi() {
+  return Oi ??= new bi();
 }
-function Mi(e) {
-  return ur(Ii(), e);
+function vi(e) {
+  return lr(xi(), e);
 }
-function Bi(e) {
-  nr(e.body);
-  const t = e.body.filter((s) => s.type !== "negation"), r = Ye(e.body) ? t.filter(
-    (s) => p(s).with({ type: u.union("triple", "property", "class") }, () => !0).otherwise(() => !1)
-  ) : t, { query: i } = yi(r);
+function Ci(e) {
+  ir(e.body);
+  const t = e.body.filter((s) => s.type !== "negation"), r = We(e.body) ? t.filter(
+    (s) => p(s).with({ type: l.union("triple", "property", "class") }, () => !0).otherwise(() => !1)
+  ) : t, { query: i } = fi(r);
   return `${i}
 LIMIT 1`;
 }
-function Ls(e) {
-  return p(e).with({ type: "variable" }, (t) => `?${t.name}`).with({ type: "iri", value: "a" }, () => "rdf:type").with({ type: "iri", prefixed: !0 }, (t) => t.value).with({ type: "iri", prefixed: !1 }, (t) => `<${t.value}>`).with({ type: "literal", language: u.string }, (t) => `"${t.value}"@${t.language}`).with({ type: "literal", datatype: u.string }, (t) => `"${t.value}"^^${rr(t.datatype)}`).with({ type: "literal" }, (t) => `"${t.value}"`).with({ type: "blank" }, (t) => `_:${t.label}`).exhaustive();
+function fs(e) {
+  return p(e).with({ type: "variable" }, (t) => `?${t.name}`).with({ type: "iri", value: "a" }, () => "rdf:type").with({ type: "iri", prefixed: !0 }, (t) => t.value).with({ type: "iri", prefixed: !1 }, (t) => `<${t.value}>`).with({ type: "literal", language: l.string }, (t) => `"${t.value}"@${t.language}`).with({ type: "literal", datatype: l.string }, (t) => `"${t.value}"^^${er(t.datatype)}`).with({ type: "literal" }, (t) => `"${t.value}"`).with({ type: "blank" }, (t) => `_:${t.label}`).exhaustive();
 }
-function Fi(e) {
+function Ii(e) {
   const t = e.head[0];
   return t ? p(t).with({ type: "triple" }, (r) => ({
-    subject: _(r.subject),
-    predicate: _(r.predicate),
-    object: _(r.object)
+    subject: G(r.subject),
+    predicate: G(r.predicate),
+    object: G(r.object)
   })).with({ type: "property" }, (r) => ({
-    subject: _(r.subject),
+    subject: G(r.subject),
     predicate: r.predicate,
-    object: _(r.object)
+    object: G(r.object)
   })).with({ type: "class" }, (r) => ({
-    subject: _(r.instance),
+    subject: G(r.instance),
     predicate: "rdf:type",
     object: r.className
   })).with({ type: "general" }, () => null).exhaustive() : null;
 }
-function _(e) {
-  return p(e).with({ type: "variable" }, (t) => `:test_${t.name}`).with({ type: "iri", prefixed: !0 }, (t) => t.value).with({ type: "iri", prefixed: !1 }, (t) => `<${t.value}>`).with({ type: "literal", datatype: u.string }, (t) => `"${t.value}"^^${t.datatype}`).with({ type: "literal" }, (t) => `"${t.value}"`).with({ type: "blank" }, (t) => `_:${t.label}`).exhaustive();
+function G(e) {
+  return p(e).with({ type: "variable" }, (t) => `:test_${t.name}`).with({ type: "iri", prefixed: !0 }, (t) => t.value).with({ type: "iri", prefixed: !1 }, (t) => `<${t.value}>`).with({ type: "literal", datatype: l.string }, (t) => `"${t.value}"^^${t.datatype}`).with({ type: "literal" }, (t) => `"${t.value}"`).with({ type: "blank" }, (t) => `_:${t.label}`).exhaustive();
 }
-const Pi = q.object({
-  results: q.object({
-    bindings: q.array(q.unknown())
+const Mi = j.object({
+  results: j.object({
+    bindings: j.array(j.unknown())
   })
-}), ki = q.object({
-  boolean: q.boolean()
+}), Bi = j.object({
+  boolean: j.boolean()
 });
-async function Us(e, t, r, i, s) {
-  if (Ye(e.body) && !s)
+async function gs(e, t, r, i, s) {
+  if (We(e.body) && !s)
     return {
       verified: !1,
       error: "Rules containing SKOLEM require a concrete test triple for inference verification"
     };
   try {
-    const o = s || Fi(e);
-    if (!o)
+    const a = s || Ii(e);
+    if (!a)
       return {
         verified: !1,
         error: "Could not generate test triple from rule head"
       };
-    const l = Bi(e), E = await $i(l, t, r, i);
-    if (E)
+    const u = Ci(e), f = await Fi(u, t, r, i);
+    if (f)
       return {
         verified: !1,
-        testTriple: o,
-        candidateQuery: l,
-        error: E
+        testTriple: a,
+        candidateQuery: u,
+        error: f
       };
-    const y = Di(o), S = new URL(`datastores/${r}/sparql`, t), h = await fetch(S.toString(), {
+    const y = Pi(a), m = new URL(`datastores/${r}/sparql`, t), h = await fetch(m.toString(), {
       method: "POST",
       headers: {
         Authorization: i,
@@ -1381,22 +1373,22 @@ async function Us(e, t, r, i, s) {
     if (!h.ok)
       throw new Error(`SPARQL query failed: ${h.status} - ${await h.text()}`);
     return {
-      verified: ki.parse(await h.json()).boolean,
-      testTriple: o,
+      verified: Bi.parse(await h.json()).boolean,
+      testTriple: a,
       sparqlQuery: y,
-      candidateQuery: l
+      candidateQuery: u
     };
-  } catch (o) {
+  } catch (a) {
     return {
       verified: !1,
       testTriple: s,
-      error: o instanceof Error ? o.message : "Unknown error during inference verification"
+      error: a instanceof Error ? a.message : "Unknown error during inference verification"
     };
   }
 }
-async function $i(e, t, r, i) {
+async function Fi(e, t, r, i) {
   try {
-    const s = new URL(`datastores/${r}/sparql`, t), a = await fetch(s.toString(), {
+    const s = new URL(`datastores/${r}/sparql`, t), o = await fetch(s.toString(), {
       method: "POST",
       headers: {
         Authorization: i,
@@ -1405,21 +1397,21 @@ async function $i(e, t, r, i) {
       },
       body: e
     });
-    if (!a.ok) {
-      let l = "";
+    if (!o.ok) {
+      let u = "";
       try {
-        l = await a.text();
+        u = await o.text();
       } catch {
       }
-      const E = l || a.statusText;
-      return `Candidate query failed: ${a.status}${E ? ` - ${E}` : ""}`;
+      const f = u || o.statusText;
+      return `Candidate query failed: ${o.status}${f ? ` - ${f}` : ""}`;
     }
-    return Pi.parse(await a.json()).results.bindings.length > 0 ? void 0 : "No candidate variable bindings found for rule body - rule cannot fire";
+    return Mi.parse(await o.json()).results.bindings.length > 0 ? void 0 : "No candidate variable bindings found for rule body - rule cannot fire";
   } catch (s) {
     return `Candidate query failed: ${s instanceof Error ? s.message : "Unknown error"}`;
   }
 }
-function Di(e) {
+function Pi(e) {
   return `
     ASK WHERE {
       ${e.subject} ${e.predicate} ${e.object} .
@@ -1429,8 +1421,8 @@ function Di(e) {
     }
   `.trim();
 }
-function ws(e) {
-  return p(e).with({ verified: !0 }, () => "Inference verification succeeded").with({ error: u.string }, (t) => t.error).with({ testTriple: u.nullish }, () => "Could not determine what triple should be inferred by this rule").with({ testTriple: u.not(u.nullish) }, (t) => {
+function ms(e) {
+  return p(e).with({ verified: !0 }, () => "Inference verification succeeded").with({ error: l.string }, (t) => t.error).with({ testTriple: l.nullish }, () => "Could not determine what triple should be inferred by this rule").with({ testTriple: l.not(l.nullish) }, (t) => {
     const { subject: r, predicate: i, object: s } = t.testTriple;
     return `Expected inference was not produced:
 
@@ -1449,48 +1441,48 @@ To debug:
 4. Test rule components individually`;
   }).exhaustive();
 }
-const Gi = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type";
-function pr() {
+const ki = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type";
+function cr() {
   return { classes: [], predicates: [] };
 }
-function yt(e) {
+function gt(e) {
   return {
     classes: e.flatMap(({ classes: t }) => t),
     predicates: e.flatMap(({ predicates: t }) => t)
   };
 }
-function _i(e) {
-  return e === "a" || e === "rdf:type" || e === Gi;
+function $i(e) {
+  return e === "a" || e === "rdf:type" || e === ki;
 }
-function hr(e) {
-  const t = Ze(e);
+function pr(e) {
+  const t = Ye(e);
   if (t)
     return {
       classes: [{ term: t.className, graph: t.graph }],
       predicates: []
     };
-  const r = Je(e);
-  return r && !_i(r.predicate) ? {
+  const r = Ze(e);
+  return r && !$i(r.predicate) ? {
     classes: [],
     predicates: [{ term: r.predicate, graph: r.graph }]
-  } : pr();
+  } : cr();
 }
-function It(e) {
-  return p(e).with({ type: u.union("triple", "property", "class", "general") }, hr).with(
+function Ct(e) {
+  return p(e).with({ type: l.union("triple", "property", "class", "general") }, pr).with(
     { type: "negation" },
-    ({ formulas: t }) => yt(t.map(It))
+    ({ formulas: t }) => gt(t.map(Ct))
   ).with(
     { type: "aggregate" },
-    ({ atoms: t }) => yt(t.map(It))
-  ).with({ type: u.union("filter", "bind", "skolem") }, pr).exhaustive();
+    ({ atoms: t }) => gt(t.map(Ct))
+  ).with({ type: l.union("filter", "bind", "skolem") }, cr).exhaustive();
 }
-function Vi(e) {
+function Di(e) {
   return {
-    head: yt(e.head.map(hr)),
-    body: yt(e.body.map(It))
+    head: gt(e.head.map(pr)),
+    body: gt(e.body.map(Ct))
   };
 }
-const ji = [
+const Gi = [
   n.expression,
   n.conditionalOrExpression,
   n.conditionalAndExpression,
@@ -1530,10 +1522,10 @@ const ji = [
   n.builtInUcase,
   n.builtInLcase,
   n.builtInEncode_for_uri
-], qi = {
+], _i = {
   name: "builtInCall",
   impl: ({ OR: e, SUBRULE: t }) => () => e(n.builtInCallList(t).slice(0, -2))
-}, Xi = P.create(ji).addMany(n.builtInContains, n.builtInStrstarts, n.builtInStrends, n.builtInStrbefore, n.builtInStrafter, n.builtInYear, n.builtInMonth, n.builtInDay, n.builtInHours, n.builtInMinutes, n.builtInSeconds, n.builtInTimezone, n.builtInTz, n.builtInNow, n.builtInUuid, n.builtInStruuid, n.builtInMd5, n.builtInSha1, n.builtInSha256, n.builtInSha384, n.builtInSha512, n.builtInCoalesce, n.builtInIf, n.builtInStrlang, n.builtInStrdt, n.builtInSameterm, n.builtInIsiri, n.builtInIsuri, n.builtInIsblank, n.builtInIsliteral, n.builtInIsnumeric, n.regexExpression, n.substringExpression, n.strReplaceExpression, n.aggregateCount, n.aggregateSum, n.aggregateMin, n.aggregateMax, n.aggregateAvg, n.aggregateSample, n.aggregateGroup_concat, n.aggregate, n.iri, n.prefixedName, n.argList, n.string).addRule(qi), Hi = [
+}, Vi = F.create(Gi).addMany(n.builtInContains, n.builtInStrstarts, n.builtInStrends, n.builtInStrbefore, n.builtInStrafter, n.builtInYear, n.builtInMonth, n.builtInDay, n.builtInHours, n.builtInMinutes, n.builtInSeconds, n.builtInTimezone, n.builtInTz, n.builtInNow, n.builtInUuid, n.builtInStruuid, n.builtInMd5, n.builtInSha1, n.builtInSha256, n.builtInSha384, n.builtInSha512, n.builtInCoalesce, n.builtInIf, n.builtInStrlang, n.builtInStrdt, n.builtInSameterm, n.builtInIsiri, n.builtInIsuri, n.builtInIsblank, n.builtInIsliteral, n.builtInIsnumeric, n.regexExpression, n.substringExpression, n.strReplaceExpression, n.aggregateCount, n.aggregateSum, n.aggregateMin, n.aggregateMax, n.aggregateAvg, n.aggregateSample, n.aggregateGroup_concat, n.aggregate, n.iri, n.prefixedName, n.argList, n.string).addRule(_i), ji = [
   n.objectList,
   n.object,
   n.graphNode,
@@ -1559,7 +1551,7 @@ const ji = [
   n.numericLiteralUnsigned,
   n.numericLiteralPositive,
   n.numericLiteralNegative
-], dr = P.create(Hi), Qi = P.create([
+], hr = F.create(ji), qi = F.create([
   n.triplesBlock,
   n.triplesSameSubjectPath,
   // VarOrTerm is included in the required ObjectList rule
@@ -1570,7 +1562,7 @@ const ji = [
   n.verbPath,
   n.verbSimple,
   n.objectListPath
-]).merge(dr, []).addMany(
+]).merge(hr, []).addMany(
   n.path,
   n.pathAlternative,
   n.pathSequence,
@@ -1585,13 +1577,13 @@ const ji = [
   n.graphNodePath,
   n.collectionPath,
   n.blankNodePropertyListPath
-), zi = [
+), Xi = [
   n.subSelect,
   n.selectClause,
   n.whereClause,
   n.solutionModifier,
   n.valuesClause
-], Er = P.create(zi).merge(Xi, []).patchRule(n.builtInCall).addMany(n.existsFunc, n.notExistsFunc, n.groupGraphPattern, n.groupGraphPatternSub).merge(Qi, []).addMany(
+], dr = F.create(Xi).merge(Vi, []).patchRule(n.builtInCall).addMany(n.existsFunc, n.notExistsFunc, n.groupGraphPattern, n.groupGraphPatternSub).merge(qi, []).addMany(
   n.graphPatternNotTriples,
   n.groupOrUnionGraphPattern,
   n.optionalGraphPattern,
@@ -1617,7 +1609,7 @@ const ji = [
   n.orderCondition,
   n.limitClause,
   n.offsetClause
-), Ki = [
+), Hi = [
   n.triplesTemplate,
   n.triplesSameSubject,
   n.varOrTerm,
@@ -1645,7 +1637,7 @@ const ji = [
   n.collection,
   n.blankNodePropertyList,
   n.graphNode
-], fr = P.create(Ki), Wi = [
+], Er = F.create(Hi), Qi = [
   n.queryUnit,
   n.query,
   n.prologue,
@@ -1656,7 +1648,7 @@ const ji = [
   n.valuesClause,
   n.baseDecl,
   n.prefixDecl
-], Yi = P.create(Wi).merge(Er, []).addRule(n.datasetClause).addRule(n.datasetClauseStar).addRule(n.defaultGraphClause).addRule(n.namedGraphClause).addRule(n.sourceSelector).addRule(n.constructTemplate).merge(fr, []).addRule(n.constructTriples), Zi = {
+], zi = F.create(Qi).merge(dr, []).addRule(n.datasetClause).addRule(n.datasetClauseStar).addRule(n.defaultGraphClause).addRule(n.namedGraphClause).addRule(n.sourceSelector).addRule(n.constructTemplate).merge(Er, []).addRule(n.constructTriples), Ki = {
   name: "update1",
   impl: ({ SUBRULE: e, OR: t }) => () => t([
     { ALT: () => e(n.load) },
@@ -1671,7 +1663,7 @@ const ji = [
     { ALT: () => e(n.deleteWhere) }
   ]),
   gImpl: n.update1.gImpl
-}, Ji = [
+}, Wi = [
   n.updateUnit,
   n.update,
   n.prologue,
@@ -1695,36 +1687,36 @@ const ji = [
   n.graphOrDefault,
   n.quadData,
   n.quads
-], tn = P.create(Ji).addRule(Zi).merge(fr, []).addRule(n.quadPattern).addRule(n.quadsNotTriples), en = P.create(tn).patchRule(n.update1).addMany(n.modify, n.deleteClause, n.insertClause, n.usingClause, n.defaultGraphClause, n.namedGraphClause, n.sourceSelector, n.usingClauseStar, n.groupGraphPattern).merge(dr, []).merge(Er, []), rn = P.create(Yi).merge(en, []).addRule(n.queryOrUpdate);
-class gr extends Ir {
+], Yi = F.create(Wi).addRule(Ki).merge(Er, []).addRule(n.quadPattern).addRule(n.quadsNotTriples), Zi = F.create(Yi).patchRule(n.update1).addMany(n.modify, n.deleteClause, n.insertClause, n.usingClause, n.defaultGraphClause, n.namedGraphClause, n.sourceSelector, n.usingClauseStar, n.groupGraphPattern).merge(hr, []).merge(dr, []), Ji = F.create(zi).merge(Zi, []).addRule(n.queryOrUpdate);
+class fr extends xr {
   constructor(t = {}) {
-    const r = rn.build({
+    const r = Ji.build({
       ...t,
-      tokenVocabulary: ze.sparql11LexerBuilder.tokenVocabulary,
-      queryPreProcessor: Mr
+      tokenVocabulary: Qe.sparql11LexerBuilder.tokenVocabulary,
+      queryPreProcessor: vr
     });
     super(r, t.defaultContext);
   }
 }
-let Lt;
-function nn(e) {
+let mt;
+function tn(e) {
   return e.type === "query";
 }
-function mr(e) {
+function gr(e) {
   return e.type === "update";
 }
-function yr(e) {
+function mr(e) {
   return e.replace(/\s+EXPLICIT\s+(TRUE|FALSE)\b/gi, "");
 }
-function sn(e) {
-  Lt ?? (Lt = new gr());
+function en(e) {
+  mt ??= new fr();
   try {
-    const t = Lt.parse(yr(e));
-    return mr(t) ? {
+    const t = mt.parse(mr(e));
+    return gr(t) ? {
       valid: !0,
       queryType: "update",
       isReadOnly: !1
-    } : nn(t) ? {
+    } : tn(t) ? {
       valid: !0,
       queryType: t.subType,
       isReadOnly: !0
@@ -1739,19 +1731,19 @@ function sn(e) {
     };
   }
 }
-function As(e) {
-  const t = sn(e);
+function ys(e) {
+  const t = en(e);
   return t.valid ? t.isReadOnly ? { allowed: !0, queryType: t.queryType } : {
     allowed: !1,
     error: "UPDATE operations not allowed. Only SELECT, CONSTRUCT, DESCRIBE, and ASK queries are permitted.",
     queryType: t.queryType
   } : { allowed: !1, error: t.error };
 }
-const an = /* @__PURE__ */ new Set([
+const rn = /* @__PURE__ */ new Set([
   "insertdata",
   "deletedata",
   "modify"
-]), on = {
+]), nn = {
   insertdata: "INSERT DATA",
   deletedata: "DELETE DATA",
   deletewhere: "DELETE WHERE",
@@ -1764,189 +1756,189 @@ const an = /* @__PURE__ */ new Set([
   move: "MOVE",
   copy: "COPY"
 };
-function _e(e) {
-  return an.has(e);
+function Ge(e) {
+  return rn.has(e);
 }
-function Ve(e) {
+function _e(e) {
   return e.type === "term" && e.subType === "variable";
 }
-function ln(e) {
-  return Ve(e.subject) && e.predicate.subType === "variable" && Ve(e.object);
+function sn(e) {
+  return _e(e.subject) && e.predicate.subType === "variable" && _e(e.object);
 }
-function un(e) {
+function an(e) {
   for (const t of e) {
     const r = t.type === "graph" ? t.triples.triples : t.triples;
     for (const i of r)
-      if (i.type === "triple" && ln(i)) return !0;
+      if (i.type === "triple" && sn(i)) return !0;
   }
   return !1;
 }
-function cn(e) {
-  return e.delete.length > 0 && un(e.delete);
+function on(e) {
+  return e.delete.length > 0 && an(e.delete);
 }
-function Ts(e) {
-  Lt ?? (Lt = new gr());
+function Ls(e) {
+  mt ??= new fr();
   let t;
   try {
-    t = Lt.parse(yr(e));
-  } catch (o) {
+    t = mt.parse(mr(e));
+  } catch (a) {
     return {
       allowed: !1,
-      error: o instanceof Error ? o.message : "Failed to parse SPARQL update"
+      error: a instanceof Error ? a.message : "Failed to parse SPARQL update"
     };
   }
-  if (!mr(t))
+  if (!gr(t))
     return {
       allowed: !1,
       error: "Expected a SPARQL UPDATE statement, not a query."
     };
   const r = [];
-  for (const o of t.updates)
-    o.operation && r.push(o.operation);
+  for (const a of t.updates)
+    a.operation && r.push(a.operation);
   if (r.length === 0)
     return { allowed: !1, error: "Empty SPARQL update -- no operations found." };
-  const i = r.filter((o) => !_e(o.subType));
+  const i = r.filter((a) => !Ge(a.subType));
   if (i.length > 0) {
-    const o = i.map((E) => E.subType);
+    const a = i.map((f) => f.subType);
     return {
       allowed: !1,
-      error: `Blocked operations: ${i.map((E) => on[E.subType]).join(", ")}. Only INSERT DATA, DELETE DATA, and DELETE/INSERT WHERE are permitted.`,
-      blockedOperations: o
+      error: `Blocked operations: ${i.map((f) => nn[f.subType]).join(", ")}. Only INSERT DATA, DELETE DATA, and DELETE/INSERT WHERE are permitted.`,
+      blockedOperations: a
     };
   }
   return r.filter(
-    (o) => o.subType === "modify" && cn(o)
+    (a) => a.subType === "modify" && on(a)
   ).length > 0 ? {
     allowed: !1,
     error: "Unscoped DELETE patterns (all-variable triples) are not permitted.",
     blockedOperations: ["modify"]
-  } : { allowed: !0, operationTypes: r.map((o) => o.subType).filter(_e) };
+  } : { allowed: !0, operationTypes: r.map((a) => a.subType).filter(Ge) };
 }
-async function pn(e) {
-  const { endpointUrl: t, datastoreName: r, authorization: i } = e, s = new URL(`datastores/${r}/connections`, t), a = await fetch(s.toString(), {
+async function ln(e) {
+  const { endpointUrl: t, datastoreName: r, authorization: i } = e, s = new URL(`datastores/${r}/connections`, t), o = await fetch(s.toString(), {
     method: "POST",
     headers: {
       Authorization: i
     }
   });
-  if (!a.ok) {
-    const l = await a.text();
-    throw new Error(`Failed to create connection: ${a.status} - ${l}`);
+  if (!o.ok) {
+    const u = await o.text();
+    throw new Error(`Failed to create connection: ${o.status} - ${u}`);
   }
-  const o = a.headers.get("Location");
-  if (!o)
+  const a = o.headers.get("Location");
+  if (!a)
     throw new Error("Connection creation response missing Location header");
-  return o.split("/").pop();
+  return a.split("/").pop();
 }
-async function hn(e) {
-  const { endpointUrl: t, datastoreName: r, connectionId: i, authorization: s } = e, a = new URL(`datastores/${r}/connections/${i}/transaction`, t);
-  a.searchParams.set("operation", "begin-read-write-transaction");
-  const o = await fetch(a.toString(), {
+async function un(e) {
+  const { endpointUrl: t, datastoreName: r, connectionId: i, authorization: s } = e, o = new URL(`datastores/${r}/connections/${i}/transaction`, t);
+  o.searchParams.set("operation", "begin-read-write-transaction");
+  const a = await fetch(o.toString(), {
     method: "PATCH",
     headers: {
       Authorization: s
     }
   });
-  if (!o.ok) {
-    const l = await o.text();
-    throw new Error(`Failed to begin transaction: ${o.status} - ${l}`);
+  if (!a.ok) {
+    const u = await a.text();
+    throw new Error(`Failed to begin transaction: ${a.status} - ${u}`);
   }
 }
-async function dn(e) {
-  const { endpointUrl: t, datastoreName: r, connectionId: i, authorization: s } = e, a = new URL(`datastores/${r}/connections/${i}/transaction`, t);
-  a.searchParams.set("operation", "commit-transaction");
-  const o = await fetch(a.toString(), {
+async function cn(e) {
+  const { endpointUrl: t, datastoreName: r, connectionId: i, authorization: s } = e, o = new URL(`datastores/${r}/connections/${i}/transaction`, t);
+  o.searchParams.set("operation", "commit-transaction");
+  const a = await fetch(o.toString(), {
     method: "PATCH",
     headers: {
       Authorization: s
     }
   });
-  if (!o.ok) {
-    const l = await o.text();
-    throw new Error(`Failed to commit transaction: ${o.status} - ${l}`);
+  if (!a.ok) {
+    const u = await a.text();
+    throw new Error(`Failed to commit transaction: ${a.status} - ${u}`);
   }
 }
-async function En(e) {
-  const { endpointUrl: t, datastoreName: r, connectionId: i, authorization: s } = e, a = new URL(`datastores/${r}/connections/${i}/transaction`, t);
-  a.searchParams.set("operation", "rollback-transaction");
-  const o = await fetch(a.toString(), {
+async function pn(e) {
+  const { endpointUrl: t, datastoreName: r, connectionId: i, authorization: s } = e, o = new URL(`datastores/${r}/connections/${i}/transaction`, t);
+  o.searchParams.set("operation", "rollback-transaction");
+  const a = await fetch(o.toString(), {
     method: "PATCH",
     headers: {
       Authorization: s
     }
   });
-  if (!o.ok) {
-    const l = await o.text();
-    throw new Error(`Failed to rollback transaction: ${o.status} - ${l}`);
+  if (!a.ok) {
+    const u = await a.text();
+    throw new Error(`Failed to rollback transaction: ${a.status} - ${u}`);
   }
 }
-async function fn(e) {
-  const { endpointUrl: t, datastoreName: r, connectionId: i, authorization: s } = e, a = new URL(`datastores/${r}/connections/${i}`, t), o = await fetch(a.toString(), {
+async function hn(e) {
+  const { endpointUrl: t, datastoreName: r, connectionId: i, authorization: s } = e, o = new URL(`datastores/${r}/connections/${i}`, t), a = await fetch(o.toString(), {
     method: "DELETE",
     headers: {
       Authorization: s
     }
   });
-  if (!o.ok) {
-    const l = await o.text();
-    throw new Error(`Failed to delete connection: ${o.status} - ${l}`);
+  if (!a.ok) {
+    const u = await a.text();
+    throw new Error(`Failed to delete connection: ${a.status} - ${u}`);
   }
 }
-async function Ss(e, t) {
-  const r = await pn(e);
+async function Us(e, t) {
+  const r = await ln(e);
   try {
-    await hn({ ...e, connectionId: r });
+    await un({ ...e, connectionId: r });
     const i = await t(r);
-    return await dn({ ...e, connectionId: r }), i;
+    return await cn({ ...e, connectionId: r }), i;
   } catch (i) {
     try {
-      await En({ ...e, connectionId: r });
+      await pn({ ...e, connectionId: r });
     } catch (s) {
       console.error("Failed to rollback transaction:", s);
     }
     throw i;
   } finally {
     try {
-      await fn({ ...e, connectionId: r });
+      await hn({ ...e, connectionId: r });
     } catch (i) {
       console.error("Failed to delete connection:", i);
     }
   }
 }
-function Nt(e) {
+function St(e) {
   return e.type === "variable" ? `?${e.name}` : void 0;
 }
-function Ns(e) {
+function ws(e) {
   const t = /* @__PURE__ */ new Map();
-  function r(a) {
-    let o = t.get(a);
-    return o || (o = { variable: a, predicateEvidence: [] }, t.set(a, o)), o;
-  }
-  function i(a) {
-    const { atom: o, fromBody: l = !1 } = a, E = Ze(o);
-    if (E) {
-      const R = Nt(E.instance);
-      if (R) {
-        const L = r(R);
-        L.classTerm ?? (L.classTerm = E.className), l && (L.bodyClassTerm ?? (L.bodyClassTerm = E.className));
+  function r(o) {
+    let a = t.get(o);
+    return a || (a = { variable: o, predicateEvidence: [] }, t.set(o, a)), a;
+  }
+  function i(o) {
+    const { atom: a, fromBody: u = !1 } = o, f = Ye(a);
+    if (f) {
+      const C = St(f.instance);
+      if (C) {
+        const T = r(C);
+        T.classTerm ??= f.className, u && (T.bodyClassTerm ??= f.className);
       }
       return;
     }
-    const y = Je(o);
+    const y = Ze(a);
     if (!y) return;
-    const S = Nt(y.subject), h = Nt(y.object);
-    S && r(S).predicateEvidence.push({ term: y.predicate, position: "domain" }), h && r(h).predicateEvidence.push({ term: y.predicate, position: "range" });
+    const m = St(y.subject), h = St(y.object);
+    m && r(m).predicateEvidence.push({ term: y.predicate, position: "domain" }), h && r(h).predicateEvidence.push({ term: y.predicate, position: "range" });
   }
-  function s(a) {
-    if (Be(a)) {
-      i({ atom: a, fromBody: !0 });
+  function s(o) {
+    if (Me(o)) {
+      i({ atom: o, fromBody: !0 });
       return;
     }
-    a.type === "aggregate" && a.atoms.filter(Be).forEach((o) => i({ atom: o, fromBody: !0 }));
+    o.type === "aggregate" && o.atoms.filter(Me).forEach((a) => i({ atom: a, fromBody: !0 }));
   }
-  return e.head.forEach((a) => i({ atom: a })), e.body.forEach(s), [...t.values()];
+  return e.head.forEach((o) => i({ atom: o })), e.body.forEach(s), [...t.values()];
 }
-function Rs(e, t) {
+function As(e, t) {
   const r = [];
   for (const i of e) {
     const s = i.bodyClassTerm ?? i.classTerm;
@@ -1954,68 +1946,66 @@ function Rs(e, t) {
       r.push({ variable: i.variable, typeTerm: s, source: "class" });
       continue;
     }
-    const a = gn(i.predicateEvidence, t);
-    a && r.push({ variable: i.variable, ...a });
+    const o = dn(i.predicateEvidence, t);
+    o && r.push({ variable: i.variable, ...o });
   }
   return r;
 }
-function gn(e, t) {
+function dn(e, t) {
   for (const { term: r, position: i } of e) {
-    const s = t(r), a = i === "domain" ? s == null ? void 0 : s.domainIncludes[0] : s == null ? void 0 : s.rangeIncludes[0];
-    if (a) return { typeTerm: a, source: i };
+    const s = t(r), o = i === "domain" ? s?.domainIncludes[0] : s?.rangeIncludes[0];
+    if (o) return { typeTerm: o, source: i };
   }
 }
-const mn = new xe({ selfAnalysis: !1 }).getBaseCstVisitorConstructor();
-function v(e, t) {
+const En = new Oe({ selfAnalysis: !1 }).getBaseCstVisitorConstructor();
+function O(e, t) {
   if (e === void 0)
     throw new Error(t);
   return e;
 }
-function at(e, t, ...r) {
-  var s;
+function nt(e, t, ...r) {
   if (!e)
     throw new Error(`Children is undefined when looking for keys: [${r.join(", ")}]`);
-  for (const a of r)
-    if ((s = e[a]) != null && s[0]) return t(e[a][0]);
+  for (const s of r)
+    if (e[s]?.[0]) return t(e[s][0]);
   const i = Object.keys(e);
   throw new Error(`None of [${r.join(", ")}] found. Available keys: [${i.join(", ")}]`);
 }
-const f = (e) => e != null && e.length > 0;
-function je(e) {
+const d = (e) => e != null && e.length > 0;
+function Ve(e) {
   return e.flatMap(({ arr: t, op: r }) => (t ?? []).map((i) => ({ offset: i.startOffset, op: r }))).sort((t, r) => t.offset - r.offset).map(({ op: t }) => t);
 }
-function Y(e) {
+function K(e) {
   const t = e.startOffset ?? 0, r = e.endOffset ?? t + e.image.length - 1;
   return { start: t, end: r + 1 };
 }
-function V(e, t, r = e.image) {
+function _(e, t, r = e.image) {
   return {
     token: e,
     term: { type: "iri", value: r, prefixed: t }
   };
 }
-function qe(e) {
+function je(e) {
   return p(e).returnType().with(
-    { IRI_REF: u.when(f) },
-    ({ IRI_REF: t }) => V(t[0], !1, t[0].image.slice(1, -1))
-  ).with({ PREFIXED_NAME: u.when(f) }, ({ PREFIXED_NAME: t }) => V(t[0], !0)).with({ PREFIX_ONLY: u.when(f) }, ({ PREFIX_ONLY: t }) => V(t[0], !0)).with({ IDENTIFIER: u.when(f) }, ({ IDENTIFIER: t }) => V(t[0], !1)).with({ DEFAULT_NS_IRI: u.when(f) }, ({ DEFAULT_NS_IRI: t }) => V(t[0], !0)).with(
-    { INTERNAL_FUNCTION: u.when(f) },
-    ({ INTERNAL_FUNCTION: t }) => V(t[0], !1)
+    { IRI_REF: l.when(d) },
+    ({ IRI_REF: t }) => _(t[0], !1, t[0].image.slice(1, -1))
+  ).with({ PREFIXED_NAME: l.when(d) }, ({ PREFIXED_NAME: t }) => _(t[0], !0)).with({ PREFIX_ONLY: l.when(d) }, ({ PREFIX_ONLY: t }) => _(t[0], !0)).with({ IDENTIFIER: l.when(d) }, ({ IDENTIFIER: t }) => _(t[0], !1)).with({ DEFAULT_NS_IRI: l.when(d) }, ({ DEFAULT_NS_IRI: t }) => _(t[0], !0)).with(
+    { INTERNAL_FUNCTION: l.when(d) },
+    ({ INTERNAL_FUNCTION: t }) => _(t[0], !1)
   ).otherwise(() => {
     throw new Error("Unknown IRI type");
   });
 }
-function yn(e, t) {
-  const r = Y(e);
+function fn(e, t) {
+  const r = K(e);
   return {
     start: r.start + t,
     end: r.end - t
   };
 }
-class Ln extends mn {
+class gn extends En {
   rule(t) {
-    var s;
-    const r = this.visit(v(t.ruleHead, "Rule missing head")), i = (s = t.ruleBody) != null && s[0] ? this.visit(t.ruleBody) : [];
+    const r = this.visit(O(t.ruleHead, "Rule missing head")), i = t.ruleBody?.[0] ? this.visit(t.ruleBody) : [];
     return { head: r, body: i };
   }
   ruleHead(t) {
@@ -2025,7 +2015,7 @@ class Ln extends mn {
     return t.bodyFormula.map((r) => this.visit(r));
   }
   bodyFormula(t) {
-    return at(
+    return nt(
       t,
       this.visit.bind(this),
       "negation",
@@ -2037,8 +2027,8 @@ class Ln extends mn {
     );
   }
   tupleTableAtom(t) {
-    const r = at(t, this.visit.bind(this), "defaultGraphAtom", "generalAtom");
-    if (f(t.graph)) {
+    const r = nt(t, this.visit.bind(this), "defaultGraphAtom", "generalAtom");
+    if (d(t.graph)) {
       const i = this.visit(t.graph[0]);
       if (r.type === "triple" || r.type === "property" || r.type === "class")
         return { ...r, graph: i };
@@ -2047,24 +2037,24 @@ class Ln extends mn {
     return r;
   }
   graphName(t) {
-    if (f(t.VARIABLE))
+    if (d(t.VARIABLE))
       return { type: "variable", name: t.VARIABLE[0].image.substring(1) };
-    if (f(t.iri))
+    if (d(t.iri))
       return this.visit(t.iri[0]);
     throw new Error("Unknown graph name type");
   }
   defaultGraphAtom(t) {
     const r = t;
-    if (f(r.subject) && f(r.predicate) && f(r.object))
+    if (d(r.subject) && d(r.predicate) && d(r.object))
       return {
         type: "triple",
         subject: this.visit(r.subject[0]),
         predicate: this.visit(r.predicate[0]),
         object: this.visit(r.object[0])
       };
-    if (f(r.predicateOrClass) && f(r.firstTerm)) {
+    if (d(r.predicateOrClass) && d(r.firstTerm)) {
       const i = this.extractIriValue(r.predicateOrClass[0]), s = this.visit(r.firstTerm[0]);
-      return f(r.secondTerm) ? {
+      return d(r.secondTerm) ? {
         type: "property",
         predicate: i,
         subject: s,
@@ -2081,7 +2071,7 @@ class Ln extends mn {
     const r = t;
     return {
       type: "general",
-      tableName: f(r.IDENTIFIER) ? r.IDENTIFIER[0].image : f(r.STRING_LITERAL) ? this.unquoteString(r.STRING_LITERAL[0].image) : (() => {
+      tableName: d(r.IDENTIFIER) ? r.IDENTIFIER[0].image : d(r.STRING_LITERAL) ? this.unquoteString(r.STRING_LITERAL[0].image) : (() => {
         throw new Error("Missing table name");
       })(),
       terms: r.term.map((s) => this.visit(s))
@@ -2089,17 +2079,17 @@ class Ln extends mn {
   }
   term(t) {
     const r = t;
-    if (f(r.VARIABLE)) return { type: "variable", name: r.VARIABLE[0].image.substring(1) };
-    if (f(r.iri)) return this.visit(r.iri[0]);
-    if (f(r.literal)) return this.visit(r.literal[0]);
-    if (f(r.BLANK_NODE)) return { type: "blank", label: r.BLANK_NODE[0].image.substring(2) };
+    if (d(r.VARIABLE)) return { type: "variable", name: r.VARIABLE[0].image.substring(1) };
+    if (d(r.iri)) return this.visit(r.iri[0]);
+    if (d(r.literal)) return this.visit(r.literal[0]);
+    if (d(r.BLANK_NODE)) return { type: "blank", label: r.BLANK_NODE[0].image.substring(2) };
     throw new Error("Unknown term type");
   }
   iri(t) {
-    return qe(t).term;
+    return je(t).term;
   }
   literal(t) {
-    return at(
+    return nt(
       t,
       this.visit.bind(this),
       "numericLiteral",
@@ -2109,38 +2099,36 @@ class Ln extends mn {
   }
   numericLiteral(t) {
     const r = t;
-    if (f(r.INTEGER)) return this.numericTokenLiteral(r.INTEGER[0], j.integer);
-    if (f(r.DECIMAL)) return this.numericTokenLiteral(r.DECIMAL[0], j.decimal);
-    if (f(r.DOUBLE)) return this.numericTokenLiteral(r.DOUBLE[0], j.double);
+    if (d(r.INTEGER)) return this.numericTokenLiteral(r.INTEGER[0], V.integer);
+    if (d(r.DECIMAL)) return this.numericTokenLiteral(r.DECIMAL[0], V.decimal);
+    if (d(r.DOUBLE)) return this.numericTokenLiteral(r.DOUBLE[0], V.double);
     throw new Error("Unknown numeric literal type");
   }
   booleanLiteral(t) {
     const r = t;
-    if (f(r.TRUE)) return { type: "literal", value: "true", datatype: j.boolean };
-    if (f(r.FALSE)) return { type: "literal", value: "false", datatype: j.boolean };
+    if (d(r.TRUE)) return { type: "literal", value: "true", datatype: V.boolean };
+    if (d(r.FALSE)) return { type: "literal", value: "false", datatype: V.boolean };
     throw new Error("Unknown boolean literal type");
   }
   stringLiteral(t) {
-    var h, R, L, A;
-    const r = (h = t.STRING_LITERAL_LONG) == null ? void 0 : h[0], i = (R = t.STRING_LITERAL) == null ? void 0 : R[0], s = r ?? i;
+    const r = t.STRING_LITERAL_LONG?.[0], i = t.STRING_LITERAL?.[0], s = r ?? i;
     if (!s) throw new Error("Unknown string literal format");
-    const a = r ? this.unquoteTripleString(s.image) : this.unquoteString(s.image), o = Y(s), l = (L = t.LANGTAG) == null ? void 0 : L[0], E = (A = t.iri) != null && A[0] ? qe(t.iri[0].children) : void 0, y = l ? Y(l).end : E ? Y(E.token).end : o.end, S = {
+    const o = r ? this.unquoteTripleString(s.image) : this.unquoteString(s.image), a = K(s), u = t.LANGTAG?.[0], f = t.iri?.[0] ? je(t.iri[0].children) : void 0, y = u ? K(u).end : f ? K(f.token).end : a.end, m = {
       type: "literal",
-      value: a,
-      termSpan: { start: o.start, end: y },
-      valueSpan: yn(s, r ? 3 : 1)
+      value: o,
+      termSpan: { start: a.start, end: y },
+      valueSpan: fn(s, r ? 3 : 1)
     };
-    return l ? S.language = l.image.substring(1) : E && (S.datatype = E.term.value), S;
+    return u ? m.language = u.image.substring(1) : f && (m.datatype = f.term.value), m;
   }
   negation(t) {
-    var s, a, o;
     const r = [];
-    if ((s = t.existsClause) != null && s[0]) {
-      const l = this.visit(t.existsClause);
-      r.push(...l);
+    if (t.existsClause?.[0]) {
+      const s = this.visit(t.existsClause);
+      r.push(...s);
     }
     const i = [];
-    return (a = t.bodyFormulaList) != null && a[0] ? i.push(...this.visit(t.bodyFormulaList)) : (o = t.tupleTableAtom) != null && o[0] && i.push(this.visit(t.tupleTableAtom)), {
+    return t.bodyFormulaList?.[0] ? i.push(...this.visit(t.bodyFormulaList)) : t.tupleTableAtom?.[0] && i.push(this.visit(t.tupleTableAtom)), {
       type: "negation",
       formulas: i,
       existentialVars: r.length > 0 ? r : void 0
@@ -2153,7 +2141,7 @@ class Ln extends mn {
     return t.atom ? t.atom.map((r) => this.visit(r)) : [];
   }
   atom(t) {
-    return at(
+    return nt(
       t,
       (r) => this.visit(r),
       "tupleTableAtom",
@@ -2167,24 +2155,23 @@ class Ln extends mn {
   filterAtom(t) {
     return {
       type: "filter",
-      expression: this.visit(v(t.expression, "Filter missing expression"))
+      expression: this.visit(O(t.expression, "Filter missing expression"))
     };
   }
   bindAtom(t) {
     return {
       type: "bind",
-      expression: this.visit(v(t.expression, "Bind missing expression")),
+      expression: this.visit(O(t.expression, "Bind missing expression")),
       ...this.asTarget(t, "Bind missing variable")
     };
   }
   // The expanded grammar accepts a value where a variable belongs, because the engine
   // substitutes the `AS` target when it grounds a rule.
   asTarget(t, r) {
-    var a;
-    const i = (a = t.VARIABLE) == null ? void 0 : a[0];
+    const i = t.VARIABLE?.[0];
     if (i) return { variable: i.image.substring(1) };
-    const s = this.visit(v(t.groundedAsTarget, r));
-    return { variable: x(s, { stripSimpleLiteralDatatypes: !0 }), groundedTarget: s };
+    const s = this.visit(O(t.groundedAsTarget, r));
+    return { variable: b(s, { stripSimpleLiteralDatatypes: !0 }), groundedTarget: s };
   }
   // A variable-free `term`, so it visits identically.
   groundedAsTarget(t) {
@@ -2193,28 +2180,26 @@ class Ln extends mn {
   skolemAtom(t) {
     return {
       type: "skolem",
-      args: this.visit(v(t.argumentList, "Skolem missing argument list"))
+      args: this.visit(O(t.argumentList, "Skolem missing argument list"))
     };
   }
   aggregate(t) {
-    var a;
-    const r = (a = t.atomList) != null && a[0] ? this.visit(t.atomList) : [], i = t.onClause ? this.visit(t.onClause) : void 0, s = t.aggregateBind ? t.aggregateBind.map((o) => this.visit(o)) : void 0;
-    if (r.length === 0 && !(s != null && s.length))
+    const r = t.atomList?.[0] ? this.visit(t.atomList) : [], i = t.onClause ? this.visit(t.onClause) : void 0, s = t.aggregateBind ? t.aggregateBind.map((o) => this.visit(o)) : void 0;
+    if (r.length === 0 && !s?.length)
       throw new Error("AGGREGATE requires at least one atom or binding");
     return {
       type: "aggregate",
       atoms: r,
-      onVars: i == null ? void 0 : i.onVars,
-      groundedOnTargets: i == null ? void 0 : i.groundedOnTargets,
+      onVars: i?.onVars,
+      groundedOnTargets: i?.groundedOnTargets,
       bindings: s
     };
   }
   // The engine grounds every grouping variable or none of them, so listing the
   // variables ahead of any substituted values preserves source order in practice.
   onClause(t) {
-    var a, o;
-    const r = ((a = t.VARIABLE) == null ? void 0 : a.map((l) => l.image.substring(1))) ?? [], i = ((o = t.groundedAsTarget) == null ? void 0 : o.map((l) => this.visit(l))) ?? [], s = i.map(
-      (l) => x(l, { stripSimpleLiteralDatatypes: !0 })
+    const r = t.VARIABLE?.map((o) => o.image.substring(1)) ?? [], i = t.groundedAsTarget?.map((o) => this.visit(o)) ?? [], s = i.map(
+      (o) => b(o, { stripSimpleLiteralDatatypes: !0 })
     );
     return {
       onVars: [...r, ...s],
@@ -2222,73 +2207,70 @@ class Ln extends mn {
     };
   }
   aggregateBind(t) {
-    var i;
     const r = this.asTarget(t, "AggregateBind missing variable");
-    return (i = t.aggregateFunction) != null && i[0] ? { ...this.visit(t.aggregateFunction), ...r } : {
-      expression: this.visit(v(t.expression, "AggregateBind missing expression")),
+    return t.aggregateFunction?.[0] ? { ...this.visit(t.aggregateFunction), ...r } : {
+      expression: this.visit(O(t.expression, "AggregateBind missing expression")),
       ...r
     };
   }
   aggregateFunction(t) {
-    return p(t).with({ aggregateFunction1: u.when(f) }, (r) => this.visit(r.aggregateFunction1[0])).with({ aggregateFunction2: u.when(f) }, (r) => this.visit(r.aggregateFunction2[0])).otherwise(() => {
+    return p(t).with({ aggregateFunction1: l.when(d) }, (r) => this.visit(r.aggregateFunction1[0])).with({ aggregateFunction2: l.when(d) }, (r) => this.visit(r.aggregateFunction2[0])).otherwise(() => {
       throw new Error("Unknown aggregate function arity");
     });
   }
   aggregateFunction1(t) {
-    var i;
     return {
       function: p(t).when(
-        (s) => !!s.COUNT_MIN,
+        (i) => !!i.COUNT_MIN,
         () => "COUNT_MIN"
       ).when(
-        (s) => !!s.COUNT_MAX,
+        (i) => !!i.COUNT_MAX,
         () => "COUNT_MAX"
       ).when(
-        (s) => !!s.COUNT,
+        (i) => !!i.COUNT,
         () => "COUNT"
       ).when(
-        (s) => !!s.MIN,
+        (i) => !!i.MIN,
         () => "MIN"
       ).when(
-        (s) => !!s.MAX,
+        (i) => !!i.MAX,
         () => "MAX"
       ).when(
-        (s) => !!s.SUM,
+        (i) => !!i.SUM,
         () => "SUM"
       ).when(
-        (s) => !!s.MUL,
+        (i) => !!i.MUL,
         () => "MUL"
       ).when(
-        (s) => !!s.AVG,
+        (i) => !!i.AVG,
         () => "AVG"
       ).otherwise(() => {
         throw new Error("Unknown aggregate function");
       }),
-      expression: t.STAR ? "*" : (i = t.expression) != null && i[0] ? this.visit(t.expression[0]) : { type: "term", term: { type: "literal", value: "", datatype: "xsd:string" } },
+      expression: t.STAR ? "*" : t.expression?.[0] ? this.visit(t.expression[0]) : { type: "term", term: { type: "literal", value: "", datatype: "xsd:string" } },
       ...t.DISTINCT && { distinct: !0 }
     };
   }
   aggregateFunction2(t) {
-    var i, s;
     return {
       function: p(t).when(
-        (a) => !!a.MIN_ARGMIN,
+        (i) => !!i.MIN_ARGMIN,
         () => "MIN_ARGMIN"
       ).when(
-        (a) => !!a.MAX_ARGMIN,
+        (i) => !!i.MAX_ARGMIN,
         () => "MAX_ARGMIN"
       ).when(
-        (a) => !!a.MIN_ARGMAX,
+        (i) => !!i.MIN_ARGMAX,
         () => "MIN_ARGMAX"
       ).when(
-        (a) => !!a.MAX_ARGMAX,
+        (i) => !!i.MAX_ARGMAX,
         () => "MAX_ARGMAX"
       ).otherwise(() => {
         throw new Error("Unknown aggregate function");
       }),
-      expression: this.visit(v((i = t.firstExpr) == null ? void 0 : i[0], "AggregateFunction2 missing first expression")),
+      expression: this.visit(O(t.firstExpr?.[0], "AggregateFunction2 missing first expression")),
       secondExpression: this.visit(
-        v((s = t.secondExpr) == null ? void 0 : s[0], "AggregateFunction2 missing second expression")
+        O(t.secondExpr?.[0], "AggregateFunction2 missing second expression")
       ),
       ...t.DISTINCT && { distinct: !0 }
     };
@@ -2319,33 +2301,32 @@ class Ln extends mn {
     );
   }
   relationalExpression(t) {
-    var i;
     const r = this.visit(t.additiveExpression);
     if (t.IN) {
-      const s = !!t.NOT, a = (i = t.argumentList) == null ? void 0 : i[0], o = a ? this.visit(a) : [];
+      const i = !!t.NOT, s = t.argumentList?.[0], o = s ? this.visit(s) : [];
       return {
         type: "in",
-        negated: s,
+        negated: i,
         expression: r,
         list: o
       };
     }
     return t.additiveExpression.length > 1 ? {
       type: "binary",
-      operator: p(t).with({ EQUALS: u.when(Boolean) }, () => "=").with({ NOT_EQUALS: u.when(Boolean) }, () => "!=").with({ LESS_THAN: u.when(Boolean) }, () => "<").with({ GREATER_THAN: u.when(Boolean) }, () => ">").with({ LESS_THAN_OR_EQUAL: u.when(Boolean) }, () => "<=").with({ GREATER_THAN_OR_EQUAL: u.when(Boolean) }, () => ">=").otherwise(() => "="),
+      operator: p(t).with({ EQUALS: l.when(Boolean) }, () => "=").with({ NOT_EQUALS: l.when(Boolean) }, () => "!=").with({ LESS_THAN: l.when(Boolean) }, () => "<").with({ GREATER_THAN: l.when(Boolean) }, () => ">").with({ LESS_THAN_OR_EQUAL: l.when(Boolean) }, () => "<=").with({ GREATER_THAN_OR_EQUAL: l.when(Boolean) }, () => ">=").otherwise(() => "="),
       left: r,
       right: t.additiveExpression[1] ? this.visit(t.additiveExpression[1]) : r
     } : r;
   }
   additiveExpression(t) {
-    const r = je([
+    const r = Ve([
       { arr: t.PLUS, op: "+" },
       { arr: t.MINUS, op: "-" }
     ]);
     return t.multiplicativeExpression.slice(1).reduce(
-      (i, s, a) => ({
+      (i, s, o) => ({
         type: "binary",
-        operator: r[a] ?? "+",
+        operator: r[o] ?? "+",
         left: i,
         right: this.visit(s)
       }),
@@ -2353,14 +2334,14 @@ class Ln extends mn {
     );
   }
   multiplicativeExpression(t) {
-    const r = je([
+    const r = Ve([
       { arr: t.STAR, op: "*" },
       { arr: t.SLASH, op: "/" }
     ]);
     return t.unaryExpression.slice(1).reduce(
-      (i, s, a) => ({
+      (i, s, o) => ({
         type: "binary",
-        operator: r[a] ?? "*",
+        operator: r[o] ?? "*",
         left: i,
         right: this.visit(s)
       }),
@@ -2369,21 +2350,21 @@ class Ln extends mn {
   }
   unaryExpression(t) {
     return p(t).with(
-      { EXCLAMATION: u.when(Boolean) },
+      { EXCLAMATION: l.when(Boolean) },
       () => ({
         type: "unary",
         operator: "!",
         operand: this.visit(t.primaryExpression)
       })
     ).with(
-      { PLUS: u.when(Boolean) },
+      { PLUS: l.when(Boolean) },
       () => ({
         type: "unary",
         operator: "+",
         operand: this.visit(t.primaryExpression)
       })
     ).with(
-      { MINUS: u.when(Boolean) },
+      { MINUS: l.when(Boolean) },
       () => ({
         type: "unary",
         operator: "-",
@@ -2392,10 +2373,9 @@ class Ln extends mn {
     ).otherwise(() => this.visit(t.primaryExpression));
   }
   functionCall(t) {
-    return p(t).with({ concatFunction: u.when(f) }, (r) => this.visit(r.concatFunction[0])).with({ strFunction: u.when(f) }, (r) => this.visit(r.strFunction[0])).with({ ifFunction: u.when(f) }, (r) => this.visit(r.ifFunction[0])).with({ iriFunction: u.when(f) }, (r) => this.visit(r.iriFunction[0])).with({ skolemFunction: u.when(f) }, (r) => this.visit(r.skolemFunction[0])).with({ roundFunction: u.when(f) }, (r) => this.visit(r.roundFunction[0])).with({ regexFunction: u.when(f) }, (r) => this.visit(r.regexFunction[0])).with({ iri: u.when(f), LPAREN: u.when(f) }, (r) => {
-      var o;
-      const i = r.iri[0] ? this.visit(r.iri[0]) : null, s = i && typeof i == "object" && "type" in i && i.type === "iri" && "value" in i ? String(i.value) : "unknown", a = (o = r.argumentList) != null && o[0] ? this.visit(r.argumentList[0]) : [];
-      return { type: "function", name: s, args: a };
+    return p(t).with({ concatFunction: l.when(d) }, (r) => this.visit(r.concatFunction[0])).with({ strFunction: l.when(d) }, (r) => this.visit(r.strFunction[0])).with({ ifFunction: l.when(d) }, (r) => this.visit(r.ifFunction[0])).with({ iriFunction: l.when(d) }, (r) => this.visit(r.iriFunction[0])).with({ skolemFunction: l.when(d) }, (r) => this.visit(r.skolemFunction[0])).with({ roundFunction: l.when(d) }, (r) => this.visit(r.roundFunction[0])).with({ regexFunction: l.when(d) }, (r) => this.visit(r.regexFunction[0])).with({ iri: l.when(d), LPAREN: l.when(d) }, (r) => {
+      const i = r.iri[0] ? this.visit(r.iri[0]) : null, s = i && typeof i == "object" && "type" in i && i.type === "iri" && "value" in i ? String(i.value) : "unknown", o = r.argumentList?.[0] ? this.visit(r.argumentList[0]) : [];
+      return { type: "function", name: s, args: o };
     }).otherwise(() => {
       throw new Error("Unknown function call type");
     });
@@ -2444,12 +2424,11 @@ class Ln extends mn {
     };
   }
   regexFunction(t) {
-    var i;
     const r = [
-      this.visit(v(t.textExpr, "REGEX missing text expression")),
-      this.visit(v(t.patternExpr, "REGEX missing pattern expression"))
+      this.visit(O(t.textExpr, "REGEX missing text expression")),
+      this.visit(O(t.patternExpr, "REGEX missing pattern expression"))
     ];
-    return (i = t.flagsExpr) != null && i[0] && r.push(this.visit(t.flagsExpr)), {
+    return t.flagsExpr?.[0] && r.push(this.visit(t.flagsExpr)), {
       type: "function",
       name: "REGEX",
       args: r
@@ -2459,13 +2438,13 @@ class Ln extends mn {
     return t.expression.map((r) => this.visit(r));
   }
   primaryExpression(t) {
-    return p(t).with({ expression: u.when(f) }, (r) => this.visit(r.expression[0])).with({ functionCall: u.when(f) }, (r) => this.visit(r.functionCall[0])).with({ literal: u.when(f) }, (r) => ({ type: "term", term: this.visit(r.literal[0]) })).with({ VARIABLE: u.when(f) }, (r) => ({
+    return p(t).with({ expression: l.when(d) }, (r) => this.visit(r.expression[0])).with({ functionCall: l.when(d) }, (r) => this.visit(r.functionCall[0])).with({ literal: l.when(d) }, (r) => ({ type: "term", term: this.visit(r.literal[0]) })).with({ VARIABLE: l.when(d) }, (r) => ({
       type: "term",
       term: { type: "variable", name: r.VARIABLE[0].image.substring(1) }
-    })).with({ BLANK_NODE: u.when(f) }, (r) => ({
+    })).with({ BLANK_NODE: l.when(d) }, (r) => ({
       type: "term",
       term: { type: "blank", label: r.BLANK_NODE[0].image.substring(2) }
-    })).with({ iri: u.when(f) }, (r) => ({ type: "term", term: this.visit(r.iri[0]) })).otherwise(() => {
+    })).with({ iri: l.when(d) }, (r) => ({ type: "term", term: this.visit(r.iri[0]) })).otherwise(() => {
       throw new Error("Unknown primary expression type");
     });
   }
@@ -2473,7 +2452,7 @@ class Ln extends mn {
     return this.visit(t).value;
   }
   numericTokenLiteral(t, r) {
-    const i = Y(t);
+    const i = K(t);
     return {
       type: "literal",
       value: t.image,
@@ -2489,382 +2468,378 @@ class Ln extends mn {
     return t.substring(3, t.length - 3).replace(/\\(.)/g, "$1");
   }
 }
-let Un;
-function Ce() {
-  return Un ?? (Un = new Ln());
+let mn;
+function ve() {
+  return mn ??= new gn();
 }
-function M(e, t) {
+function I(e, t) {
   t.forEach((r) => e.add(r));
 }
-function F(e, t, r) {
+function B(e, t, r) {
   t.forEach((i) => {
     e.has(i) || r.add(i);
   });
 }
-function Ut(e, t) {
-  p(e).with({ type: u.union("triple", "property", "class", "general") }, (r) => {
-    M(t, nt(r));
+function yt(e, t) {
+  p(e).with({ type: l.union("triple", "property", "class", "general") }, (r) => {
+    I(t, rt(r));
   }).with({ type: "filter" }, (r) => {
-    M(t, T(r.expression));
+    I(t, w(r.expression));
   }).with({ type: "bind" }, (r) => {
-    M(t, T(r.expression)), t.add(r.variable);
+    I(t, w(r.expression)), t.add(r.variable);
   }).with({ type: "skolem" }, (r) => {
-    r.args.forEach((i) => M(t, T(i)));
+    r.args.forEach((i) => I(t, w(i)));
   }).with({ type: "negation" }, (r) => {
-    var s;
     const i = /* @__PURE__ */ new Set();
-    r.formulas.forEach((a) => Ut(a, i)), (s = r.existentialVars) == null || s.forEach((a) => i.delete(a)), M(t, [...i]);
+    r.formulas.forEach((s) => yt(s, i)), r.existentialVars?.forEach((s) => i.delete(s)), I(t, [...i]);
   }).with({ type: "aggregate" }, (r) => {
-    var i, s;
-    r.atoms.forEach((a) => Ut(a, t)), (i = r.onVars) == null || i.forEach((a) => t.add(a)), (s = r.bindings) == null || s.forEach((a) => {
-      t.add(a.variable), a.expression !== "*" && M(t, T(a.expression)), a.secondExpression && M(t, T(a.secondExpression));
+    r.atoms.forEach((i) => yt(i, t)), r.onVars?.forEach((i) => t.add(i)), r.bindings?.forEach((i) => {
+      t.add(i.variable), i.expression !== "*" && I(t, w(i.expression)), i.secondExpression && I(t, w(i.secondExpression));
     });
   }).exhaustive();
 }
-function Lr(e, t) {
-  p(e).with({ type: u.union("triple", "property", "class", "general") }, (r) => {
-    M(t, nt(r));
+function yr(e, t) {
+  p(e).with({ type: l.union("triple", "property", "class", "general") }, (r) => {
+    I(t, rt(r));
   }).with({ type: "skolem" }, (r) => {
-    const i = Zr(r);
+    const i = Kr(r);
     i && t.add(i);
-  }).with({ type: u.union("bind", "filter", "negation", "aggregate") }, () => {
+  }).with({ type: l.union("bind", "filter", "negation", "aggregate") }, () => {
   }).exhaustive();
 }
-function wn(e, t, r, i) {
-  F(r, T(t), i), r.add(e);
+function yn(e, t, r, i) {
+  B(r, w(t), i), r.add(e);
 }
-function Ur(e, t, r) {
-  var o;
+function Lr(e, t, r) {
   const i = /* @__PURE__ */ new Set();
-  e.atoms.forEach((l) => Lr(l, i));
+  e.atoms.forEach((a) => yr(a, i));
   const s = e.onVars ?? [];
-  s.forEach((l) => {
-    t.has(l) && i.add(l);
-  }), e.atoms.forEach((l) => Ar(l, i, r));
-  const a = /* @__PURE__ */ new Set();
-  e.atoms.forEach((l) => Ut(l, a)), s.forEach((l) => {
-    a.has(l) && i.has(l) ? t.add(l) : r.add(l);
-  }), (o = e.bindings) == null || o.forEach((l) => {
-    l.expression !== "*" && F(i, T(l.expression), r), l.secondExpression && F(i, T(l.secondExpression), r), t.add(l.variable);
+  s.forEach((a) => {
+    t.has(a) && i.add(a);
+  }), e.atoms.forEach((a) => wr(a, i, r));
+  const o = /* @__PURE__ */ new Set();
+  e.atoms.forEach((a) => yt(a, o)), s.forEach((a) => {
+    o.has(a) && i.has(a) ? t.add(a) : r.add(a);
+  }), e.bindings?.forEach((a) => {
+    a.expression !== "*" && B(i, w(a.expression), r), a.secondExpression && B(i, w(a.secondExpression), r), t.add(a.variable);
   });
 }
-function wr(e, t, r) {
+function Ur(e, t, r) {
   const i = new Set(t);
-  M(i, e.existentialVars ?? []), e.formulas.forEach((s) => {
-    p(s).with({ type: "aggregate" }, (a) => {
-      var o;
-      F(i, a.onVars ?? [], r), F(i, ((o = a.bindings) == null ? void 0 : o.map(({ variable: l }) => l)) ?? [], r), Ur(a, i, r);
-    }).with({ type: "negation" }, (a) => {
-      wr(a, i, r);
-    }).otherwise((a) => {
-      const o = /* @__PURE__ */ new Set();
-      Ut(a, o), F(i, [...o], r);
+  I(i, e.existentialVars ?? []), e.formulas.forEach((s) => {
+    p(s).with({ type: "aggregate" }, (o) => {
+      B(i, o.onVars ?? [], r), B(i, o.bindings?.map(({ variable: a }) => a) ?? [], r), Lr(o, i, r);
+    }).with({ type: "negation" }, (o) => {
+      Ur(o, i, r);
+    }).otherwise((o) => {
+      const a = /* @__PURE__ */ new Set();
+      yt(o, a), B(i, [...a], r);
     });
   });
 }
-function Ar(e, t, r) {
-  p(e).with({ type: u.union("triple", "property", "class", "general") }, () => {
+function wr(e, t, r) {
+  p(e).with({ type: l.union("triple", "property", "class", "general") }, () => {
   }).with({ type: "filter" }, (i) => {
-    F(t, T(i.expression), r);
+    B(t, w(i.expression), r);
   }).with({ type: "bind" }, (i) => {
-    wn(i.variable, i.expression, t, r);
+    yn(i.variable, i.expression, t, r);
   }).with({ type: "skolem" }, (i) => {
-    i.args.slice(0, -1).forEach((s) => F(t, T(s), r));
+    i.args.slice(0, -1).forEach((s) => B(t, w(s), r));
   }).with({ type: "negation" }, (i) => {
-    wr(i, t, r);
-  }).with({ type: "aggregate" }, (i) => {
     Ur(i, t, r);
+  }).with({ type: "aggregate" }, (i) => {
+    Lr(i, t, r);
   }).exhaustive();
 }
-function An(e) {
+function Ln(e) {
   const t = /* @__PURE__ */ new Set(), r = /* @__PURE__ */ new Set();
-  return e.body.forEach((i) => Lr(i, t)), e.body.forEach((i) => Ar(i, t, r)), e.head.forEach((i) => F(t, nt(i), r)), [...r].sort();
+  return e.body.forEach((i) => yr(i, t)), e.body.forEach((i) => wr(i, t, r)), e.head.forEach((i) => B(t, rt(i), r)), [...r].sort();
 }
-function Tr(e, t) {
+function Ar(e, t) {
   const r = t(e);
-  return { ...Ce().visit(r), raw: e };
+  return { ...ve().visit(r), raw: e };
 }
-function Xe(e) {
-  return Tr(e, cr);
+function qe(e) {
+  return Ar(e, ur);
 }
-function bs(e) {
-  return { ...Tr(e, Mi), grounded: !0 };
+function Ts(e) {
+  return { ...Ar(e, vi), grounded: !0 };
 }
-function X(e) {
+function q(e) {
   return e !== void 0 && Number.isFinite(e) ? e : void 0;
 }
-function Tn(e) {
-  const t = X(e.startOffset), r = X(e.endOffset);
+function Un(e) {
+  const t = q(e.startOffset), r = q(e.endOffset);
   return { offset: t, endOffset: r === void 0 ? void 0 : r + 1 };
 }
-function Sr(e) {
-  const t = be(e);
+function Tr(e) {
+  const t = Re(e);
   if (t) return { ok: !1, issues: [t] };
-  const r = Re(e);
+  const r = Ne(e);
   if (r.errors.length > 0)
     return {
       ok: !1,
-      issues: r.errors.map((o) => ({
-        message: o.message,
-        line: X(o.line),
-        column: X(o.column),
-        offset: o.offset,
-        endOffset: o.offset + o.length
+      issues: r.errors.map((a) => ({
+        message: a.message,
+        line: q(a.line),
+        column: q(a.column),
+        offset: a.offset,
+        endOffset: a.offset + a.length
       }))
     };
-  const i = Oe(e, r.tokens);
+  const i = be(e, r.tokens);
   if (i) return { ok: !1, issues: [i] };
-  const s = ve();
+  const s = xe();
   s.input = r.tokens;
-  const a = s.rule();
+  const o = s.rule();
   if (s.errors.length > 0)
     return {
       ok: !1,
-      issues: s.errors.map((o) => ({
-        message: o.message,
-        line: X(o.token.startLine),
-        column: X(o.token.startColumn),
-        ...Tn(o.token)
+      issues: s.errors.map((a) => ({
+        message: a.message,
+        line: q(a.token.startLine),
+        column: q(a.token.startColumn),
+        ...Un(a.token)
       }))
     };
   try {
-    return { ok: !0, rule: { ...Ce().visit(a), raw: e } };
-  } catch (o) {
+    return { ok: !0, rule: { ...ve().visit(o), raw: e } };
+  } catch (a) {
     return {
       ok: !1,
-      issues: [{ message: o instanceof Error ? o.message : "Invalid Datalog rule" }]
+      issues: [{ message: a instanceof Error ? a.message : "Invalid Datalog rule" }]
     };
   }
 }
-function Os(e) {
-  const t = Sr(e);
-  return t.ok ? { ok: !0, vocabulary: Vi(t.rule) } : t;
+function Ss(e) {
+  const t = Tr(e);
+  return t.ok ? { ok: !0, vocabulary: Di(t.rule) } : t;
 }
-function Sn(e) {
-  if (be(e)) return;
-  const t = Re(e);
-  if (t.errors.length > 0 || Oe(e, t.tokens)) return;
-  const r = ve();
+function wn(e) {
+  if (Re(e)) return;
+  const t = Ne(e);
+  if (t.errors.length > 0 || be(e, t.tokens)) return;
+  const r = xe();
   r.input = t.tokens;
   const i = r.term();
   if (!(r.errors.length > 0 || !r.atEndOfInput))
-    return Ce().visit(i);
+    return ve().visit(i);
 }
-function He(e) {
-  const t = Sn(e), r = (t == null ? void 0 : t.type) === "iri" && !t.prefixed && !We(t.value);
+function Xe(e) {
+  const t = wn(e), r = t?.type === "iri" && !t.prefixed && !Ke(t.value);
   return t && !r ? t : void 0;
 }
-function xs(e, t) {
-  const r = He(e), i = He(t);
+function Ns(e, t) {
+  const r = Xe(e), i = Xe(t);
   if (!(!r || !i))
-    return tr(r, i);
+    return Je(r, i);
 }
-function vs(e) {
-  const t = Sr(e);
+function Rs(e) {
+  const t = Tr(e);
   if (!t.ok)
     return {
       valid: !1,
       error: t.issues.map(({ message: s }) => s).join("; ") || "Invalid Datalog rule"
     };
-  const r = An(t.rule);
+  const r = Ln(t.rule);
   return r.length === 0 ? { valid: !0 } : {
     valid: !1,
     error: `Unbound variables ${r.map((s) => `?${s}`).join(", ")}. Bind each variable with a body atom, BIND, AGGREGATE, or SKOLEM, or declare negation-local variables with NOT EXIST ?variable IN (...). AGGREGATE ON variables must also occur in the aggregate body.`
   };
 }
-function Cs(e, t) {
+function bs(e, t) {
   try {
-    const r = Xe(e), i = Xe(t);
-    return r.head.length !== i.head.length ? !1 : Qe(e) === Qe(t);
+    const r = qe(e), i = qe(t);
+    return r.head.length !== i.head.length ? !1 : He(e) === He(t);
   } catch {
     return !1;
   }
 }
-function Qe(e) {
+function He(e) {
   return e.replace(/\s+/g, " ").replace(/\s*([(),[\]])\s*/g, "$1").replace(/\s*:-\s*/g, ":-").trim();
 }
 export {
-  wt as AGGREGATE,
-  he as AND,
-  K as AS,
-  sr as AT,
-  Xt as AVG,
-  z as BIND,
-  et as BLANK_NODE,
-  mn as BaseDatalogVisitor,
-  ar as COLON,
-  N as COMMA,
-  Ai as COMMENT,
-  Zt as CONCAT,
-  Gt as COUNT,
-  Qt as COUNT_MAX,
-  Ht as COUNT_MIN,
-  Ae as DECIMAL,
-  Ue as DEFAULT_NS_IRI,
-  ut as DISTINCT,
-  ge as DOT,
-  Te as DOUBLE,
-  Ln as DatalogAstBuilder,
-  xe as DatalogParser,
-  ae as EQUALS,
-  fe as EXCLAMATION,
-  $t as EXISTS,
-  vi as ExpandedDatalogParser,
-  se as FALSE,
-  Dt as FILTER,
-  ce as GREATER_THAN,
-  pe as GREATER_THAN_OR_EQUAL,
-  gt as HAT,
-  rt as IDENTIFIER,
-  te as IF,
-  Z as IN,
-  we as INTEGER,
-  ye as INTERNAL_FUNCTION,
-  ee as IRI,
-  me as IRI_REF,
-  Ne as LANGTAG,
-  Et as LBRACKET,
-  le as LESS_THAN,
-  ue as LESS_THAN_OR_EQUAL,
-  U as LPAREN,
-  Vt as MAX,
-  Yt as MAX_ARGMAX,
-  Kt as MAX_ARGMIN,
-  _t as MIN,
-  ht as MINUS,
-  Wt as MIN_ARGMAX,
-  zt as MIN_ARGMIN,
-  qt as MUL,
-  lt as NOT,
-  oe as NOT_EQUALS,
-  At as ON,
-  de as OR,
-  pt as PLUS,
-  st as PREFIXED_NAME,
-  Tt as PREFIX_ONLY,
-  ft as RBRACKET,
-  ie as REGEX,
-  re as ROUND,
-  w as RPAREN,
-  kt as RULE_ARROW,
-  ct as SKOLEM,
-  Ee as SLASH,
-  dt as STAR,
-  Jt as STR,
-  mt as STRING_LITERAL,
-  Se as STRING_LITERAL_LONG,
-  jt as SUM,
-  ne as TRUE,
-  b as VARIABLE,
-  Ti as WHITESPACE,
-  lr as allTokens,
-  Cs as areRulesEquivalent,
-  nr as assertNoGroundedTargets,
-  Ce as astBuilder,
-  ps as atomToDatalogText,
-  hn as beginTransaction,
-  ei as binaryOperandNeedsParentheses,
-  Ri as booleanLiteralTokenTypes,
-  Ni as builtinFunctionTokenTypes,
-  Qe as canonicalRuleText,
-  Ze as classAssertionFromAtom,
-  Ns as collectVariableTypeEvidence,
-  dn as commitTransaction,
-  pn as createConnection,
-  yi as datalogBodyToSparqlSelect,
-  rr as datatypeToTermText,
-  fn as deleteConnection,
-  gs as delimiterTokenTypes,
-  Ii as expandedParserInstance,
-  ws as explainInferenceFailure,
-  H as expressionToDatalogParts,
-  hs as expressionToDatalogText,
-  Os as extractRuleVocabulary,
-  Vi as extractRuleVocabularyFromAst,
-  hr as extractRuleVocabularyFromAtom,
-  us as extractVariables,
-  xt as formulaContainsSkolem,
-  Yn as getAggregateFunction,
-  zn as getAtomType,
-  Wn as getExpressionType,
-  cs as getRelatedVariables,
-  Kn as getTermType,
-  Pr as getVariablesFromAtom,
-  kr as getVariablesFromAtomIncludingGraph,
-  is as invertComparisonOperator,
-  Ke as iriBodyCharClass,
-  Es as iriTokenTypes,
-  Vn as isAggregateFormula,
-  ns as isBareNumericLiteral,
-  qn as isBinaryExpression,
-  _n as isBindFormula,
-  $n as isBlankNodeTerm,
-  er as isBooleanLiteral,
-  Fn as isClassAtom,
-  rs as isComparisonOperator,
-  Be as isDatalogAtom,
-  Qr as isDateLiteral,
-  zr as isDateTimeLiteral,
-  Gn as isFilterFormula,
-  We as isFullIri,
-  Qn as isFunctionCallExpression,
-  Pn as isGeneralAtom,
-  kn as isIriTerm,
-  tt as isLiteralTerm,
-  Jn as isLogicalOperator,
-  Dn as isNegationFormula,
-  Q as isNumericLiteral,
-  ss as isNumericLiteralTerm,
-  Zn as isNumericOperator,
-  Rt as isNumericRdfValue,
-  Bn as isPropertyAtom,
-  ts as isQueryableTermIri,
-  As as isReadOnlySparqlQuery,
-  jn as isSkolemFormula,
-  Hn as isTermExpression,
-  Mn as isTripleAtom,
-  Xn as isUnaryExpression,
-  I as isVariableTerm,
-  it as isXsdDatatype,
-  Si as keywordTokenTypes,
-  ls as literalSetComparisonFromExpression,
-  as as literalToDisplayText,
-  ds as numericLiteralTokenTypes,
-  fs as operatorTokenTypes,
-  es as parseBooleanLiteral,
-  Xe as parseDatalogRule,
-  Sr as parseDatalogRuleWithIssues,
-  Sn as parseDatalogTermText,
-  bs as parseGroundedDatalogRule,
-  Mi as parseGroundedRule,
-  cr as parseRule,
-  ur as parseRuleWith,
-  ve as parserInstance,
-  Xr as plainDecimalText,
-  Ye as positiveBodyContainsSkolem,
-  Je as propertyAssertionFromAtom,
-  Rs as resolveVariableTypes,
-  En as rollbackTransaction,
-  Kr as simpleComparisonFromExpression,
-  os as simpleComparisonFromFilter,
-  Zr as skolemMintedVariable,
-  bi as stringLiteralTokenTypes,
-  xs as termTextsEqual,
-  x as termToDatalogText,
-  Ls as termToSparql,
-  ms as termTokenTypes,
-  tr as termsEqual,
-  Re as tokenizeDatalog,
-  ri as unaryOperandNeedsParentheses,
-  G as unwrapTermExpression,
-  Ts as validateDataManipulationUpdate,
-  vs as validateDatalogRule,
-  ys as validateRuleSyntax,
-  sn as validateSparqlQuery,
-  Yr as variableNameFromTermExpression,
-  nt as variableNamesFromAtom,
-  T as variableNamesFromExpression,
-  Us as verifyRuleInference,
-  Ss as withTransaction,
-  j as xsdDatatypes
+  Lt as AGGREGATE,
+  pe as AND,
+  z as AS,
+  nr as AT,
+  qt as AVG,
+  Q as BIND,
+  J as BLANK_NODE,
+  En as BaseDatalogVisitor,
+  sr as COLON,
+  S as COMMA,
+  Li as COMMENT,
+  Yt as CONCAT,
+  Dt as COUNT,
+  Ht as COUNT_MAX,
+  Xt as COUNT_MIN,
+  we as DECIMAL,
+  Le as DEFAULT_NS_IRI,
+  ot as DISTINCT,
+  fe as DOT,
+  Ae as DOUBLE,
+  gn as DatalogAstBuilder,
+  Oe as DatalogParser,
+  se as EQUALS,
+  Ee as EXCLAMATION,
+  kt as EXISTS,
+  bi as ExpandedDatalogParser,
+  ne as FALSE,
+  $t as FILTER,
+  ue as GREATER_THAN,
+  ce as GREATER_THAN_OR_EQUAL,
+  Et as HAT,
+  tt as IDENTIFIER,
+  Jt as IF,
+  W as IN,
+  Ue as INTEGER,
+  me as INTERNAL_FUNCTION,
+  te as IRI,
+  ge as IRI_REF,
+  Se as LANGTAG,
+  ht as LBRACKET,
+  oe as LESS_THAN,
+  le as LESS_THAN_OR_EQUAL,
+  L as LPAREN,
+  _t as MAX,
+  Wt as MAX_ARGMAX,
+  zt as MAX_ARGMIN,
+  Gt as MIN,
+  ct as MINUS,
+  Kt as MIN_ARGMAX,
+  Qt as MIN_ARGMIN,
+  jt as MUL,
+  at as NOT,
+  ae as NOT_EQUALS,
+  Ut as ON,
+  he as OR,
+  ut as PLUS,
+  it as PREFIXED_NAME,
+  wt as PREFIX_ONLY,
+  dt as RBRACKET,
+  re as REGEX,
+  ee as ROUND,
+  U as RPAREN,
+  Pt as RULE_ARROW,
+  lt as SKOLEM,
+  de as SLASH,
+  pt as STAR,
+  Zt as STR,
+  ft as STRING_LITERAL,
+  Te as STRING_LITERAL_LONG,
+  Vt as SUM,
+  ie as TRUE,
+  N as VARIABLE,
+  Ui as WHITESPACE,
+  or as allTokens,
+  bs as areRulesEquivalent,
+  ir as assertNoGroundedTargets,
+  ve as astBuilder,
+  os as atomToDatalogText,
+  un as beginTransaction,
+  Zr as binaryOperandNeedsParentheses,
+  Ti as booleanLiteralTokenTypes,
+  Ai as builtinFunctionTokenTypes,
+  He as canonicalRuleText,
+  Ye as classAssertionFromAtom,
+  ws as collectVariableTypeEvidence,
+  cn as commitTransaction,
+  ln as createConnection,
+  fi as datalogBodyToSparqlSelect,
+  er as datatypeToTermText,
+  hn as deleteConnection,
+  hs as delimiterTokenTypes,
+  xi as expandedParserInstance,
+  ms as explainInferenceFailure,
+  X as expressionToDatalogParts,
+  ls as expressionToDatalogText,
+  Ss as extractRuleVocabulary,
+  Di as extractRuleVocabularyFromAst,
+  pr as extractRuleVocabularyFromAtom,
+  ss as extractVariables,
+  Ot as formulaContainsSkolem,
+  Qn as getAggregateFunction,
+  qn as getAtomType,
+  Hn as getExpressionType,
+  as as getRelatedVariables,
+  Xn as getTermType,
+  Mr as getVariablesFromAtom,
+  Br as getVariablesFromAtomIncludingGraph,
+  Jn as invertComparisonOperator,
+  ze as iriBodyCharClass,
+  cs as iriTokenTypes,
+  $n as isAggregateFormula,
+  ts as isBareNumericLiteral,
+  Gn as isBinaryExpression,
+  kn as isBindFormula,
+  Bn as isBlankNodeTerm,
+  tr as isBooleanLiteral,
+  Cn as isClassAtom,
+  Zn as isComparisonOperator,
+  Me as isDatalogAtom,
+  qr as isDateLiteral,
+  Xr as isDateTimeLiteral,
+  Pn as isFilterFormula,
+  Ke as isFullIri,
+  jn as isFunctionCallExpression,
+  In as isGeneralAtom,
+  Mn as isIriTerm,
+  Z as isLiteralTerm,
+  Kn as isLogicalOperator,
+  Fn as isNegationFormula,
+  H as isNumericLiteral,
+  es as isNumericLiteralTerm,
+  zn as isNumericOperator,
+  Nt as isNumericRdfValue,
+  vn as isPropertyAtom,
+  Wn as isQueryableTermIri,
+  ys as isReadOnlySparqlQuery,
+  Dn as isSkolemFormula,
+  Vn as isTermExpression,
+  xn as isTripleAtom,
+  _n as isUnaryExpression,
+  v as isVariableTerm,
+  et as isXsdDatatype,
+  wi as keywordTokenTypes,
+  ns as literalSetComparisonFromExpression,
+  rs as literalToDisplayText,
+  us as numericLiteralTokenTypes,
+  ps as operatorTokenTypes,
+  Yn as parseBooleanLiteral,
+  qe as parseDatalogRule,
+  Tr as parseDatalogRuleWithIssues,
+  wn as parseDatalogTermText,
+  Ts as parseGroundedDatalogRule,
+  vi as parseGroundedRule,
+  ur as parseRule,
+  lr as parseRuleWith,
+  xe as parserInstance,
+  Vr as plainDecimalText,
+  We as positiveBodyContainsSkolem,
+  Ze as propertyAssertionFromAtom,
+  As as resolveVariableTypes,
+  pn as rollbackTransaction,
+  Hr as simpleComparisonFromExpression,
+  is as simpleComparisonFromFilter,
+  Kr as skolemMintedVariable,
+  Si as stringLiteralTokenTypes,
+  Ns as termTextsEqual,
+  b as termToDatalogText,
+  fs as termToSparql,
+  ds as termTokenTypes,
+  Je as termsEqual,
+  Ne as tokenizeDatalog,
+  Jr as unaryOperandNeedsParentheses,
+  D as unwrapTermExpression,
+  Ls as validateDataManipulationUpdate,
+  Rs as validateDatalogRule,
+  Es as validateRuleSyntax,
+  en as validateSparqlQuery,
+  zr as variableNameFromTermExpression,
+  rt as variableNamesFromAtom,
+  w as variableNamesFromExpression,
+  gs as verifyRuleInference,
+  Us as withTransaction,
+  V as xsdDatatypes
 };