@manta-eu/datalog-parser 0.1.5 → 0.1.6

package/dist/index.js

@@ -1,14 +1,14 @@
-import { match as p, P as l } from "ts-pattern";
+import { match as p, P as u } 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 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), C = (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(C)).with({ type: "property" }, (t) => [t.subject, t.object].filter(C)).with({ type: "class" }, (t) => [t.instance].filter(C)).with({ type: "general" }, (t) => t.terms.filter(C)).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");
+  return r && C(r) ? [...t, r] : t;
+}, Qn = (e) => e.function, zn = (e) => p(e).with(u.union("+", "-", "*", "/", "<", ">", "<=", ">="), () => !0).with(u.union("=", "!=", "||", "&&"), () => !1).exhaustive(), Kn = (e) => p(e).with(u.union("||", "&&", "=", "!=", "<", ">", "<=", ">="), () => !0).with(u.union("+", "-", "*", "/"), () => !1).exhaustive(), ze = '[^\\s<>"{}|^`\\\\]', Fr = new RegExp(`^[a-z][a-z0-9+.-]*:${ze}*$`, "i");
 function Wn(e) {
   return Fr.test(e);
 }
@@ -28,10 +28,10 @@ function _r(e, t) {
 function Vr(e) {
   const t = Nt(e) ? e.match(Dr) : null;
   if (!t) return e;
-  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}`;
+  const [, r = "", i = "", s = "", o] = t, a = i + s, l = i.length + Number(o ?? 0), g = l <= 0 ? -l : Math.max(0, l - a.length);
+  if (a.length + g > Gr) return e;
+  const y = _r(a, l), m = y.integer.replace(/^0+(?=\d)/, ""), h = y.fraction.replace(/0+$/, ""), N = h ? `${m}.${h}` : m;
+  return N === "0" || r === "+" ? N : `${r}${N}`;
 }
 function Yn(e) {
   if (Pr.test(e)) return e.toLowerCase() === "true";
@@ -68,7 +68,7 @@ const Rt = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type", bt = "http://www.w
   ">=": "<="
 };
 function Me(e) {
-  return p(e).with({ type: l.union("triple", "property", "class", "general") }, () => !0).otherwise(() => !1);
+  return p(e).with({ type: u.union("triple", "property", "class", "general") }, () => !0).otherwise(() => !1);
 }
 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(
@@ -80,12 +80,12 @@ function M(e) {
   ).exhaustive();
 }
 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(
+  return p(e).with({ type: "skolem" }, () => !0).with({ type: u.union("filter", "bind") }, ({ expression: t }) => M(t)).with({ type: "negation" }, ({ formulas: t }) => t.some(Ot)).with(
     { type: "aggregate" },
     ({ 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();
+  ).with({ type: u.union("triple", "property", "class", "general") }, () => !1).exhaustive();
 }
 function We(e) {
   return e.some((t) => t.type !== "negation" && Ot(t));
@@ -98,7 +98,7 @@ function Ye(e) {
   })).with(
     {
       type: "property",
-      predicate: l.union("a", "rdf:type", Rt),
+      predicate: u.union("a", "rdf:type", Rt),
       object: { type: "iri" }
     },
     (t) => ({
@@ -109,7 +109,7 @@ function Ye(e) {
   ).with(
     {
       type: "triple",
-      predicate: { type: "iri", value: l.union("a", "rdf:type", Rt) },
+      predicate: { type: "iri", value: u.union("a", "rdf:type", Rt) },
       object: { type: "iri" }
     },
     (t) => ({
@@ -126,7 +126,7 @@ function Ze(e) {
     object: t.object,
     graph: t.graph
   })).with(
-    { type: "triple", predicate: { type: "iri", value: l.not(l.union("a", "rdf:type", Rt)) } },
+    { type: "triple", predicate: { type: "iri", value: u.not(u.union("a", "rdf:type", Rt)) } },
     (t) => ({
       predicate: t.predicate.value,
       subject: t.subject,
@@ -178,10 +178,10 @@ function is(e) {
 }
 function Hr(e) {
   return p(e).with(
-    { type: "binary", operator: l.union("=", "!=", "<", ">", "<=", ">=") },
+    { type: "binary", operator: u.union("=", "!=", "<", ">", "<=", ">=") },
     (t) => {
       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) ? {
+      return !r || !i ? null : C(r) && Z(i) ? { variableName: r.name, operator: t.operator, literal: i } : Z(r) && C(i) ? {
         variableName: i.name,
         operator: Bt[t.operator],
         literal: r
@@ -192,14 +192,14 @@ function Hr(e) {
 function Qr(e) {
   return p(e).returnType().with(
     { type: "binary", operator: "=" },
-    (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)
+    (t) => p([D(t.left), D(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)
   ).otherwise(() => null);
 }
 function ns(e) {
   if (e.type === "in") {
     const s = D(e.expression), o = e.list.flatMap((a) => {
-      const u = Yr(a);
-      return u ? [u] : [];
+      const l = Yr(a);
+      return l ? [l] : [];
     });
     return s && o.length > 0 && o.length === e.list.length ? { subject: s, literals: o, negated: e.negated } : null;
   }
@@ -219,7 +219,7 @@ function ns(e) {
 }
 function zr(e) {
   const t = D(e);
-  return t && v(t) ? t.name : null;
+  return t && C(t) ? t.name : null;
 }
 function Kr(e) {
   return p(e).with({ type: "skolem" }, (t) => {
@@ -233,11 +233,11 @@ function ss(e) {
   }, 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) => {
+    p(o).with({ type: u.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);
+      a.atoms.forEach(s), a.onVars?.forEach((l) => t.add(l)), a.bindings?.forEach((l) => {
+        t.add(l.variable), l.expression !== "*" && r(l.expression), l.secondExpression && r(l.secondExpression);
       });
     }).with({ type: "skolem" }, (a) => a.args.forEach(r)).exhaustive();
   };
@@ -245,27 +245,27 @@ function ss(e) {
 }
 function as(e, t) {
   const r = /* @__PURE__ */ new Set(), i = (a) => {
-    a.includes(t) && a.forEach((u) => r.add(u));
+    a.includes(t) && a.forEach((l) => r.add(l));
   }, 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(
+    p(a).with({ type: u.union("triple", "property", "class", "general") }, s).with({ type: "negation" }, (l) => l.formulas.forEach(o)).with({ type: "filter" }, (l) => i(w(l.expression))).with(
       { type: "bind" },
-      (u) => i([...w(u.expression), u.variable])
-    ).with({ type: "aggregate" }, (u) => {
-      u.atoms.forEach(o);
-      const f = [
-        ...u.onVars ?? [],
-        ...(u.bindings ?? []).flatMap((y) => [
+      (l) => i([...w(l.expression), l.variable])
+    ).with({ type: "aggregate" }, (l) => {
+      l.atoms.forEach(o);
+      const g = [
+        ...l.onVars ?? [],
+        ...(l.bindings ?? []).flatMap((y) => [
           y.variable,
           ...y.expression === "*" ? [] : w(y.expression),
           ...y.secondExpression ? w(y.secondExpression) : []
         ])
       ];
-      i(f);
+      i(g);
     }).with(
       { type: "skolem" },
-      (u) => i(u.args.flatMap((f) => w(f)))
+      (l) => i(l.args.flatMap((g) => w(g)))
     ).exhaustive();
   };
   return e.head.forEach(s), e.body.forEach(o), r;
@@ -274,7 +274,7 @@ function rt(e) {
   return Br(e).map((t) => t.name);
 }
 function Wr(e) {
-  return e && v(e) ? [e.name] : [];
+  return e && C(e) ? [e.name] : [];
 }
 function w(e) {
   return p(e).with({ type: "binary" }, (t) => [
@@ -298,26 +298,26 @@ function xt(e, t) {
 function er(e) {
   return Ke(e) ? `<${e}>` : e;
 }
-function b(e, t = {}) {
+function O(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 && 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 os(e, t = {}) {
-  const r = "graph" in e && e.graph ? ` ${b(e.graph, t)}` : "";
+  const r = "graph" in e && e.graph ? ` ${O(e.graph, t)}` : "";
   return p(e).with(
     { type: "property" },
-    (i) => `${i.predicate}[${b(i.subject, t)}, ${b(i.object, t)}]${r}`
+    (i) => `${i.predicate}[${O(i.subject, t)}, ${O(i.object, t)}]${r}`
   ).with(
     { type: "triple" },
-    (i) => `[${b(i.subject, t)}, ${b(i.predicate, t)}, ${b(i.object, t)}]${r}`
+    (i) => `[${O(i.subject, t)}, ${O(i.predicate, t)}, ${O(i.object, t)}]${r}`
   ).with(
     { type: "class" },
-    (i) => `${i.className}[${b(i.instance, t)}]${r}`
+    (i) => `${i.className}[${O(i.instance, t)}]${r}`
   ).with(
     { type: "general" },
-    (i) => `${i.tableName}(${i.terms.map((s) => b(s, t)).join(", ")})`
+    (i) => `${i.tableName}(${i.terms.map((s) => O(s, t)).join(", ")})`
   ).exhaustive();
 }
 function Fe(e) {
@@ -329,23 +329,23 @@ function ls(e, t = {}) {
 function X(e, t = {}) {
   return p(e).with({ type: "binary" }, (r) => [
     ...Pe(r.left, r.operator, "left", t),
-    x(` ${r.operator} `),
+    v(` ${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}(`),
+  ]).with({ type: "unary" }, (r) => [v(r.operator), ...ti(r.operand, t)]).with({ type: "term" }, (r) => ei(r.term, t)).with({ type: "function" }, (r) => [
+    v(`${r.name}(`),
     ...ke(
       r.args.map((i) => X(i, t)),
       ", "
     ),
-    x(")")
+    v(")")
   ]).with({ type: "in" }, (r) => [
     ...X(r.expression, t),
-    x(` ${r.negated ? "NOT IN" : "IN"} (`),
+    v(` ${r.negated ? "NOT IN" : "IN"} (`),
     ...ke(
       r.list.map((i) => X(i, t)),
       ", "
     ),
-    x(")")
+    v(")")
   ]).exhaustive();
 }
 function Zr(e, t, r) {
@@ -365,25 +365,25 @@ function ti(e, t) {
   return Jr(e) ? rr(r) : r;
 }
 function ei(e, t) {
-  return v(e) ? [ii(e.name)] : Z(e) ? [ni(e, t)] : [x(b(e, t))];
+  return C(e) ? [ii(e.name)] : Z(e) ? [ni(e, t)] : [v(O(e, t))];
 }
 function rr(e) {
-  return [x("("), ...e, x(")")];
+  return [v("("), ...e, v(")")];
 }
 function ke(e, t) {
-  return e.flatMap((r, i) => i === 0 ? r : [x(t), ...r]);
+  return e.flatMap((r, i) => i === 0 ? r : [v(t), ...r]);
 }
 function ri(e) {
   return e.map((t) => t.type === "variable" ? `?${t.name}` : t.text).join("");
 }
-function x(e) {
+function v(e) {
   return { type: "text", text: e };
 }
 function ii(e) {
   return { type: "variable", name: e };
 }
 function ni(e, t) {
-  return { type: "literal", literal: e, text: b(e, t) };
+  return { type: "literal", literal: e, text: O(e, t) };
 }
 function D(e) {
   return e.type === "term" ? e.term : null;
@@ -396,20 +396,20 @@ 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?.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();
+  ).with({ type: "negation" }, ({ formulas: t }) => t.some(vt)).with({ type: u.union("triple", "property", "class", "general", "filter", "skolem") }, () => !1).exhaustive();
 }
-const E = new br(), g = E.gen(), $e = It.getRule("aggregate"), De = It.getRule("expression"), ai = {
+const E = new br(), f = E.gen(), $e = It.getRule("aggregate"), De = It.getRule("expression"), ai = {
   ...$e,
   gImpl: (e) => (t, r) => {
     const i = t.secondExpression;
     if (!i)
       return $e.gImpl(e)(t, r);
-    const { PRINT_WORD: s, SUBRULE: o } = e, a = t.expression[0], u = r.astFactory;
-    if (u.isWildcard(a))
+    const { PRINT_WORD: s, SUBRULE: o } = e, a = t.expression[0], l = r.astFactory;
+    if (l.isWildcard(a))
       throw new Error(`Aggregate ${t.aggregation.toUpperCase()} cannot combine * with a second expression.`);
-    u.printFilter(t, () => {
+    l.printFilter(t, () => {
       s(t.aggregation.toUpperCase(), "("), t.distinct && s("DISTINCT");
-    }), o(De, a), u.printFilter(t, () => s(",")), o(De, i), u.printFilter(t, () => s(")"));
+    }), o(De, a), l.printFilter(t, () => s(",")), o(De, i), l.printFilter(t, () => s(")"));
   }
 }, 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]) => {
@@ -419,12 +419,12 @@ const E = new br(), g = E.gen(), $e = It.getRule("aggregate"), De = It.getRule("
 );
 function $(e) {
   if (e.includes("://") || e.startsWith("urn:") || e.startsWith("mailto:") || e.startsWith("tel:") || e.startsWith("data:"))
-    return E.termNamed(g, e);
+    return E.termNamed(f, e);
   const r = e.indexOf(":");
-  return r >= 0 ? E.termNamed(g, e.slice(r + 1), e.slice(0, r)) : E.termNamed(g, e);
+  return r >= 0 ? E.termNamed(f, e.slice(r + 1), e.slice(0, r)) : E.termNamed(f, e);
 }
 function st(e, t) {
-  return E.expressionOperation(e, t, g);
+  return E.expressionOperation(e, t, f);
 }
 function ci(e, t) {
   const { function: r, expression: i, secondExpression: s } = e, o = li.has(r), a = s !== void 0;
@@ -434,17 +434,17 @@ function ci(e, t) {
     throw new Error(`Aggregate ${r} cannot use * as an expression.`);
   if (!o && a)
     throw new Error(`Aggregate ${r} accepts only one expression.`);
-  const u = i === "*" ? E.wildcard(g) : R(i, t), f = E.aggregate(
+  const l = i === "*" ? E.wildcard(f) : b(i, t), g = E.aggregate(
     r.toLowerCase(),
     e.distinct || !1,
-    u,
+    l,
     void 0,
-    g
+    f
   );
   return a ? {
-    ...f,
-    secondExpression: R(s, t)
-  } : f;
+    ...g,
+    secondExpression: b(s, t)
+  } : g;
 }
 function P(e, t, r = void 0) {
   return p(r).with("predicate", () => {
@@ -456,37 +456,37 @@ function P(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(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) => {
+  }).with(u.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, f))).with({ type: "iri", prefixed: !0 }, (i) => $(i.value)).with({ type: "iri", prefixed: !1 }, (i) => E.termNamed(f, i.value)).with(
+    { type: "literal", language: u.string },
+    (i) => E.termLiteral(f, i.value, i.language)
+  ).with({ type: "literal", datatype: u.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();
+    return E.termLiteral(f, i.value, s);
+  }).with({ type: "literal" }, (i) => E.termLiteral(f, i.value)).with({ type: "blank" }, (i) => E.termBlank(i.label, f)).exhaustive();
 }
 function pi(e, t) {
-  const r = e.args.map((o) => R(o, t)), i = ui.get(e.name.toLowerCase());
+  const r = e.args.map((o) => b(o, t)), i = ui.get(e.name.toLowerCase());
   if (i)
     return st(i.toLowerCase(), r);
   const s = $(e.name);
-  return E.expressionFunctionCall(s, r, !1, g);
+  return E.expressionFunctionCall(s, r, !1, f);
 }
-function R(e, t) {
+function b(e, t) {
   return p(e).with(
     { type: "binary" },
     (r) => st(r.operator, [
-      R(r.left, t),
-      R(r.right, t)
+      b(r.left, t),
+      b(r.right, t)
     ])
   ).with(
     { type: "unary" },
-    (r) => st(r.operator, [R(r.operand, t)])
+    (r) => st(r.operator, [b(r.operand, t)])
   ).with({ type: "term" }, (r) => P(r.term, t, "expression")).with({ type: "function" }, (r) => pi(r, t)).with(
     { type: "in" },
     (r) => st(r.negated ? "notin" : "in", [
-      R(r.expression, t),
-      ...r.list.map((i) => R(i, t))
+      b(r.expression, t),
+      ...r.list.map((i) => b(i, t))
     ])
   ).exhaustive();
 }
@@ -509,34 +509,34 @@ function Ft(e, t) {
   }).exhaustive();
   if (!r) return { triples: [] };
   if ("graph" in e && e.graph) {
-    const i = E.patternBgp([r], g);
+    const i = E.patternBgp([r], f);
     return { graph: E.patternGraph(
       P(e.graph, t, "graph"),
       [i],
-      g
+      f
     ) };
   }
   return { triples: [r] };
 }
 function hi(e, t) {
   return e.formulas.filter((r) => "type" in r).flatMap(
-    (r) => p(r).with({ type: l.union("triple", "property", "class") }, (i) => Ft(i, t).triples || []).with({ type: "general" }, () => {
+    (r) => p(r).with({ type: u.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 di(e, t) {
   return e.reduce(
-    (r, i) => "type" in i ? p(i).with({ type: l.union("triple", "property", "class") }, (s) => {
+    (r, i) => "type" in i ? p(i).with({ type: u.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 o = R(s.expression, t), a = E.patternFilter(o, g);
+      const o = b(s.expression, t), a = E.patternFilter(o, f);
       return { ...r, filters: [...r.filters, a] };
     }).with({ type: "bind" }, (s) => {
       t.add(s.variable);
-      const o = R(s.expression, t), a = E.termVariable(s.variable, g), u = E.patternBind(o, a, g);
-      return { ...r, binds: [...r.binds, u] };
+      const o = b(s.expression, t), a = E.termVariable(s.variable, f), l = E.patternBind(o, a, f);
+      return { ...r, binds: [...r.binds, l] };
     }).with({ type: "general" }, () => {
       throw new Error("General formulas are not supported in atom processing.");
     }).exhaustive() : r,
@@ -544,7 +544,7 @@ function di(e, t) {
   );
 }
 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 = [];
+  const { triples: r, filters: i, binds: s, graphPatterns: o } = di(e.atoms, t), a = e.onVars || [], l = a.map((m) => (t.add(m), E.termVariable(m, f))), g = [], 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";
@@ -552,35 +552,35 @@ function Ei(e, t) {
     }
     if (m.function === void 0 && m.secondExpression !== void 0)
       throw new Error("Expression-only aggregate bindings cannot have a second expression.");
-    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);
+    const h = m.function !== void 0, N = h ? ci(m, t) : b(m.expression, t), T = E.termVariable(m.variable, f), A = E.patternBind(N, T, f);
+    h ? g.push(A) : y.push(A);
   }), {
     triples: r,
     filters: i,
     binds: [...s, ...y],
     graphPatterns: o,
-    selectVars: [...u, ...f],
+    selectVars: [...l, ...g],
     groupBy: a
   };
 }
 function fi(e, t) {
   ir(e);
   const r = /* @__PURE__ */ new Set(), i = e.reduce(
-    (h, C) => p(C).with({ type: l.union("triple", "property", "class", "general") }, (T) => {
+    (h, N) => p(N).with({ type: u.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" }, (T) => {
-      const A = R(T.expression, r), k = E.patternFilter(A, g);
+      const A = b(T.expression, r), k = E.patternFilter(A, f);
       return { ...h, filters: [...h.filters, k] };
     }).with({ type: "bind" }, (T) => {
-      const A = R(T.expression, r);
+      const A = b(T.expression, r);
       r.add(T.variable);
-      const k = E.termVariable(T.variable, g), At = E.patternBind(A, k, g);
+      const k = E.termVariable(T.variable, f), At = E.patternBind(A, k, f);
       return { ...h, binds: [...h.binds, At] };
     }).with({ type: "negation" }, (T) => {
       const A = hi(T, r);
       if (A.length > 0) {
-        const k = E.patternBgp(A, g), At = E.patternGroup([k], g), Sr = E.expressionPatternOperation("notexists", At, g), Nr = E.patternFilter(Sr, g);
+        const k = E.patternBgp(A, f), At = E.patternGroup([k], f), Sr = E.expressionPatternOperation("notexists", At, f), Nr = E.patternFilter(Sr, f);
         return { ...h, filters: [...h.filters, Nr] };
       }
       return h;
@@ -606,36 +606,36 @@ function fi(e, t) {
       aggregateSelectVars: []
     }
   ), s = [
-    ...i.triples.length > 0 ? [E.patternBgp(i.triples, g)] : [],
+    ...i.triples.length > 0 ? [E.patternBgp(i.triples, f)] : [],
     ...i.graphPatterns,
     ...i.filters,
     ...i.binds
-  ], 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 ? {
+  ], o = i.aggregateSelectVars.length > 0 ? i.aggregateSelectVars : r.size > 0 ? Array.from(r).map((h) => E.termVariable(h, f)) : [E.wildcard(f)], a = i.groupByVars.length > 0 ? {
     group: E.solutionModifierGroup(
-      i.groupByVars.map((h) => E.termVariable(h, g)),
-      g
+      i.groupByVars.map((h) => E.termVariable(h, f)),
+      f
     )
-  } : {}, u = t ? Object.entries(t).map(([h, C]) => {
-    const T = E.termNamed(g, C);
-    return E.contextDefinitionPrefix(g, h, T);
-  }) : [], f = E.querySelect(
+  } : {}, l = t ? Object.entries(t).map(([h, N]) => {
+    const T = E.termNamed(f, N);
+    return E.contextDefinitionPrefix(f, h, T);
+  }) : [], g = E.querySelect(
     {
-      context: u,
+      context: l,
       // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/ban-ts-comment
       variables: o,
       // @ts-ignore - Fails in CI for some reason
-      where: E.patternGroup(s, g),
-      datasets: E.datasetClauses([], g),
+      where: E.patternGroup(s, f),
+      datasets: E.datasetClauses([], f),
       solutionModifiers: a
     },
-    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);
+    f
+  ), y = oi.queryOrUpdate(g, 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: m
   };
 }
-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({
+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: /:/ }), R = 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]*:${ar}`)
 }), wt = c({ name: "PREFIX_ONLY", pattern: /[a-zA-Z_][\w]*:/ }), Le = c({
@@ -713,7 +713,7 @@ const Pt = c({ name: "RULE_ARROW", pattern: /:-/ }), at = c({ name: "NOT", patte
   Ue,
   Se,
   // Identifiers and names
-  N,
+  R,
   me,
   ge,
   J,
@@ -773,7 +773,7 @@ const Pt = c({ name: "RULE_ARROW", pattern: /:-/ }), at = c({ name: "NOT", patte
   pt,
   de,
   Ee
-]), hs = /* @__PURE__ */ new Set([fe, S, L, U, ht, dt, nr, Et, sr]), ds = /* @__PURE__ */ new Set([N, J, Se, tt]);
+]), hs = /* @__PURE__ */ new Set([fe, S, L, U, ht, dt, nr, Et, sr]), ds = /* @__PURE__ */ new Set([R, J, Se, tt]);
 for (const e of [...wi, ...Ai, ...Ti])
   e.LONGER_ALT = [it, wt, tt];
 let Ni;
@@ -815,19 +815,19 @@ function be(e, t) {
           i++;
           continue;
         }
-        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))
+        const o = s === "u" ? 4 : 8, a = o + 2, l = r.image.slice(i, i + a), g = r.image.slice(i + 2, i + a), y = r.startOffset + i;
+        if (g.length !== o || !/^[0-9a-fA-F]+$/.test(g))
           return Y(
             e,
             y,
-            u.length,
+            l.length,
             `Unicode escape \\${s} must contain ${o} hexadecimal digits`
           );
-        const m = Number.parseInt(f, 16);
+        const m = Number.parseInt(g, 16);
         if (m >= 55296 && m <= 57343)
-          return Y(e, y, a, `Unicode escape ${u} denotes a surrogate code point`);
+          return Y(e, y, a, `Unicode escape ${l} denotes a surrogate code point`);
         if (m > 1114111)
-          return Y(e, y, a, `Unicode escape ${u} is outside the Unicode range`);
+          return Y(e, y, a, `Unicode escape ${l} is outside the Unicode range`);
         i += a - 1;
       }
 }
@@ -881,7 +881,7 @@ class Oe extends Cr {
   });
   // 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) }]);
+    this.OR([{ ALT: () => this.CONSUME(R) }, { ALT: () => this.SUBRULE(this.iri) }]);
   });
   // DefaultGraphAtom := TripleAtom | PropertyAtom | ClassAtom
   defaultGraphAtom = this.RULE("defaultGraphAtom", () => {
@@ -911,7 +911,7 @@ class Oe extends Cr {
   // Term := Variable | IRI | Literal | BlankNode
   term = this.RULE("term", () => {
     this.OR([
-      { ALT: () => this.CONSUME(N) },
+      { ALT: () => this.CONSUME(R) },
       { ALT: () => this.SUBRULE(this.iri) },
       { ALT: () => this.SUBRULE(this.literal) },
       { ALT: () => this.CONSUME(J) }
@@ -973,8 +973,8 @@ class Oe extends Cr {
   });
   // 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(kt), this.CONSUME(R), this.MANY(() => {
+      this.CONSUME(S), this.CONSUME2(R);
     }), this.CONSUME(W);
   });
   // AtomList := Atom (',' Atom)*
@@ -1003,7 +1003,7 @@ class Oe extends Cr {
   });
   // 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);
+    this.CONSUME(Q), this.CONSUME(L), this.SUBRULE(this.expression), this.CONSUME(z), this.CONSUME(R), this.CONSUME(U);
   });
   // SkolemAtom := 'SKOLEM' '(' ArgumentList ')'
   skolemAtom = this.RULE("skolemAtom", () => {
@@ -1019,15 +1019,15 @@ class Oe extends Cr {
   });
   // OnClause := 'ON' variable+
   onClause = this.RULE("onClause", () => {
-    this.CONSUME(Ut), this.CONSUME(N), this.MANY(() => {
-      this.CONSUME2(N);
+    this.CONSUME(Ut), this.CONSUME(R), this.MANY(() => {
+      this.CONSUME2(R);
     });
   });
   // 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);
+    }), this.SUBRULE(this.aggregateFunction), this.CONSUME(z), this.CONSUME(R);
   });
   // AggregateFunction := AggregateFunction1 | AggregateFunction2
   aggregateFunction = this.RULE("aggregateFunction", () => {
@@ -1195,7 +1195,7 @@ class Oe extends Cr {
       },
       { ALT: () => this.SUBRULE(this.functionCall) },
       { ALT: () => this.SUBRULE(this.literal) },
-      { ALT: () => this.CONSUME(N) },
+      { ALT: () => this.CONSUME(R) },
       { ALT: () => this.SUBRULE(this.iri) }
     ]);
   });
@@ -1246,7 +1246,7 @@ class bi extends Oe {
   });
   // Each rule below records this once, so the default occurrence index is unambiguous.
   variableOrGroundedTarget() {
-    this.OR([{ ALT: () => this.CONSUME(N) }, { ALT: () => this.SUBRULE(this.groundedAsTarget) }]);
+    this.OR([{ ALT: () => this.CONSUME(R) }, { ALT: () => this.SUBRULE(this.groundedAsTarget) }]);
   }
   // OnClause := 'ON' (variable | GroundedAsTarget)*
   // Grounding substitutes the grouping variables as well, and an aggregate
@@ -1289,7 +1289,7 @@ class bi extends Oe {
       },
       { ALT: () => this.SUBRULE(this.functionCall) },
       { ALT: () => this.SUBRULE(this.literal) },
-      { ALT: () => this.CONSUME(N) },
+      { ALT: () => this.CONSUME(R) },
       { ALT: () => this.CONSUME(J) },
       { ALT: () => this.SUBRULE(this.iri) }
     ]);
@@ -1305,13 +1305,13 @@ function vi(e) {
 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)
+    (s) => p(s).with({ type: u.union("triple", "property", "class") }, () => !0).otherwise(() => !1)
   ) : t, { query: i } = fi(r);
   return `${i}
 LIMIT 1`;
 }
 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();
+  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}"^^${er(t.datatype)}`).with({ type: "literal" }, (t) => `"${t.value}"`).with({ type: "blank" }, (t) => `_:${t.label}`).exhaustive();
 }
 function Ii(e) {
   const t = e.head[0];
@@ -1330,7 +1330,7 @@ function Ii(e) {
   })).with({ type: "general" }, () => null).exhaustive() : null;
 }
 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();
+  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();
 }
 const Mi = j.object({
   results: j.object({
@@ -1352,13 +1352,13 @@ async function gs(e, t, r, i, s) {
         verified: !1,
         error: "Could not generate test triple from rule head"
       };
-    const u = Ci(e), f = await Fi(u, t, r, i);
-    if (f)
+    const l = Ci(e), g = await Fi(l, t, r, i);
+    if (g)
       return {
         verified: !1,
         testTriple: a,
-        candidateQuery: u,
-        error: f
+        candidateQuery: l,
+        error: g
       };
     const y = Pi(a), m = new URL(`datastores/${r}/sparql`, t), h = await fetch(m.toString(), {
       method: "POST",
@@ -1375,7 +1375,7 @@ async function gs(e, t, r, i, s) {
       verified: Bi.parse(await h.json()).boolean,
       testTriple: a,
       sparqlQuery: y,
-      candidateQuery: u
+      candidateQuery: l
     };
   } catch (a) {
     return {
@@ -1397,13 +1397,13 @@ async function Fi(e, t, r, i) {
       body: e
     });
     if (!o.ok) {
-      let u = "";
+      let l = "";
       try {
-        u = await o.text();
+        l = await o.text();
       } catch {
       }
-      const f = u || o.statusText;
-      return `Candidate query failed: ${o.status}${f ? ` - ${f}` : ""}`;
+      const g = l || o.statusText;
+      return `Candidate query failed: ${o.status}${g ? ` - ${g}` : ""}`;
     }
     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) {
@@ -1421,7 +1421,7 @@ function Pi(e) {
   `.trim();
 }
 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) => {
+  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) => {
     const { subject: r, predicate: i, object: s } = t.testTriple;
     return `Expected inference was not produced:
 
@@ -1467,13 +1467,13 @@ function pr(e) {
   } : cr();
 }
 function Ct(e) {
-  return p(e).with({ type: l.union("triple", "property", "class", "general") }, pr).with(
+  return p(e).with({ type: u.union("triple", "property", "class", "general") }, pr).with(
     { type: "negation" },
     ({ formulas: t }) => gt(t.map(Ct))
   ).with(
     { type: "aggregate" },
     ({ atoms: t }) => gt(t.map(Ct))
-  ).with({ type: l.union("filter", "bind", "skolem") }, cr).exhaustive();
+  ).with({ type: u.union("filter", "bind", "skolem") }, cr).exhaustive();
 }
 function Di(e) {
   return {
@@ -1798,10 +1798,10 @@ function Ls(e) {
     return { allowed: !1, error: "Empty SPARQL update -- no operations found." };
   const i = r.filter((a) => !Ge(a.subType));
   if (i.length > 0) {
-    const a = i.map((f) => f.subType);
+    const a = i.map((g) => g.subType);
     return {
       allowed: !1,
-      error: `Blocked operations: ${i.map((f) => nn[f.subType]).join(", ")}. Only INSERT DATA, DELETE DATA, and DELETE/INSERT WHERE are permitted.`,
+      error: `Blocked operations: ${i.map((g) => nn[g.subType]).join(", ")}. Only INSERT DATA, DELETE DATA, and DELETE/INSERT WHERE are permitted.`,
       blockedOperations: a
     };
   }
@@ -1821,8 +1821,8 @@ async function ln(e) {
     }
   });
   if (!o.ok) {
-    const u = await o.text();
-    throw new Error(`Failed to create connection: ${o.status} - ${u}`);
+    const l = await o.text();
+    throw new Error(`Failed to create connection: ${o.status} - ${l}`);
   }
   const a = o.headers.get("Location");
   if (!a)
@@ -1839,8 +1839,8 @@ async function un(e) {
     }
   });
   if (!a.ok) {
-    const u = await a.text();
-    throw new Error(`Failed to begin transaction: ${a.status} - ${u}`);
+    const l = await a.text();
+    throw new Error(`Failed to begin transaction: ${a.status} - ${l}`);
   }
 }
 async function cn(e) {
@@ -1853,8 +1853,8 @@ async function cn(e) {
     }
   });
   if (!a.ok) {
-    const u = await a.text();
-    throw new Error(`Failed to commit transaction: ${a.status} - ${u}`);
+    const l = await a.text();
+    throw new Error(`Failed to commit transaction: ${a.status} - ${l}`);
   }
 }
 async function pn(e) {
@@ -1867,8 +1867,8 @@ async function pn(e) {
     }
   });
   if (!a.ok) {
-    const u = await a.text();
-    throw new Error(`Failed to rollback transaction: ${a.status} - ${u}`);
+    const l = await a.text();
+    throw new Error(`Failed to rollback transaction: ${a.status} - ${l}`);
   }
 }
 async function hn(e) {
@@ -1879,8 +1879,8 @@ async function hn(e) {
     }
   });
   if (!a.ok) {
-    const u = await a.text();
-    throw new Error(`Failed to delete connection: ${a.status} - ${u}`);
+    const l = await a.text();
+    throw new Error(`Failed to delete connection: ${a.status} - ${l}`);
   }
 }
 async function Us(e, t) {
@@ -1914,12 +1914,12 @@ function ws(e) {
     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);
+    const { atom: a, fromBody: l = !1 } = o, g = Ye(a);
+    if (g) {
+      const N = St(g.instance);
+      if (N) {
+        const T = r(N);
+        T.classTerm ??= g.className, l && (T.bodyClassTerm ??= g.className);
       }
       return;
     }
@@ -1957,7 +1957,7 @@ function dn(e, t) {
   }
 }
 const En = new Oe({ selfAnalysis: !1 }).getBaseCstVisitorConstructor();
-function O(e, t) {
+function x(e, t) {
   if (e === void 0)
     throw new Error(t);
   return e;
@@ -1986,10 +1986,10 @@ function _(e, t, r = e.image) {
 }
 function je(e) {
   return p(e).returnType().with(
-    { IRI_REF: l.when(d) },
+    { IRI_REF: u.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) },
+  ).with({ PREFIXED_NAME: u.when(d) }, ({ PREFIXED_NAME: t }) => _(t[0], !0)).with({ PREFIX_ONLY: u.when(d) }, ({ PREFIX_ONLY: t }) => _(t[0], !0)).with({ IDENTIFIER: u.when(d) }, ({ IDENTIFIER: t }) => _(t[0], !1)).with({ DEFAULT_NS_IRI: u.when(d) }, ({ DEFAULT_NS_IRI: t }) => _(t[0], !0)).with(
+    { INTERNAL_FUNCTION: u.when(d) },
     ({ INTERNAL_FUNCTION: t }) => _(t[0], !1)
   ).otherwise(() => {
     throw new Error("Unknown IRI type");
@@ -2004,7 +2004,7 @@ function fn(e, t) {
 }
 class gn extends En {
   rule(t) {
-    const r = this.visit(O(t.ruleHead, "Rule missing head")), i = t.ruleBody?.[0] ? this.visit(t.ruleBody) : [];
+    const r = this.visit(x(t.ruleHead, "Rule missing head")), i = t.ruleBody?.[0] ? this.visit(t.ruleBody) : [];
     return { head: r, body: i };
   }
   ruleHead(t) {
@@ -2112,13 +2112,13 @@ class gn extends En {
   stringLiteral(t) {
     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 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 = {
+    const o = r ? this.unquoteTripleString(s.image) : this.unquoteString(s.image), a = K(s), l = t.LANGTAG?.[0], g = t.iri?.[0] ? je(t.iri[0].children) : void 0, y = l ? K(l).end : g ? K(g.token).end : a.end, m = {
       type: "literal",
       value: o,
       termSpan: { start: a.start, end: y },
       valueSpan: fn(s, r ? 3 : 1)
     };
-    return u ? m.language = u.image.substring(1) : f && (m.datatype = f.term.value), m;
+    return l ? m.language = l.image.substring(1) : g && (m.datatype = g.term.value), m;
   }
   negation(t) {
     const r = [];
@@ -2154,13 +2154,13 @@ class gn extends En {
   filterAtom(t) {
     return {
       type: "filter",
-      expression: this.visit(O(t.expression, "Filter missing expression"))
+      expression: this.visit(x(t.expression, "Filter missing expression"))
     };
   }
   bindAtom(t) {
     return {
       type: "bind",
-      expression: this.visit(O(t.expression, "Bind missing expression")),
+      expression: this.visit(x(t.expression, "Bind missing expression")),
       ...this.asTarget(t, "Bind missing variable")
     };
   }
@@ -2169,8 +2169,8 @@ class gn extends En {
   asTarget(t, r) {
     const i = t.VARIABLE?.[0];
     if (i) return { variable: i.image.substring(1) };
-    const s = this.visit(O(t.groundedAsTarget, r));
-    return { variable: b(s, { stripSimpleLiteralDatatypes: !0 }), groundedTarget: s };
+    const s = this.visit(x(t.groundedAsTarget, r));
+    return { variable: O(s, { stripSimpleLiteralDatatypes: !0 }), groundedTarget: s };
   }
   // A variable-free `term`, so it visits identically.
   groundedAsTarget(t) {
@@ -2179,7 +2179,7 @@ class gn extends En {
   skolemAtom(t) {
     return {
       type: "skolem",
-      args: this.visit(O(t.argumentList, "Skolem missing argument list"))
+      args: this.visit(x(t.argumentList, "Skolem missing argument list"))
     };
   }
   aggregate(t) {
@@ -2198,7 +2198,7 @@ class gn extends En {
   // variables ahead of any substituted values preserves source order in practice.
   onClause(t) {
     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 })
+      (o) => O(o, { stripSimpleLiteralDatatypes: !0 })
     );
     return {
       onVars: [...r, ...s],
@@ -2208,12 +2208,12 @@ class gn extends En {
   aggregateBind(t) {
     const r = this.asTarget(t, "AggregateBind missing variable");
     return t.aggregateFunction?.[0] ? { ...this.visit(t.aggregateFunction), ...r } : {
-      expression: this.visit(O(t.expression, "AggregateBind missing expression")),
+      expression: this.visit(x(t.expression, "AggregateBind missing expression")),
       ...r
     };
   }
   aggregateFunction(t) {
-    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(() => {
+    return p(t).with({ aggregateFunction1: u.when(d) }, (r) => this.visit(r.aggregateFunction1[0])).with({ aggregateFunction2: u.when(d) }, (r) => this.visit(r.aggregateFunction2[0])).otherwise(() => {
       throw new Error("Unknown aggregate function arity");
     });
   }
@@ -2267,9 +2267,9 @@ class gn extends En {
       ).otherwise(() => {
         throw new Error("Unknown aggregate function");
       }),
-      expression: this.visit(O(t.firstExpr?.[0], "AggregateFunction2 missing first expression")),
+      expression: this.visit(x(t.firstExpr?.[0], "AggregateFunction2 missing first expression")),
       secondExpression: this.visit(
-        O(t.secondExpr?.[0], "AggregateFunction2 missing second expression")
+        x(t.secondExpr?.[0], "AggregateFunction2 missing second expression")
       ),
       ...t.DISTINCT && { distinct: !0 }
     };
@@ -2312,7 +2312,7 @@ class gn extends En {
     }
     return t.additiveExpression.length > 1 ? {
       type: "binary",
-      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(() => "="),
+      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(() => "="),
       left: r,
       right: t.additiveExpression[1] ? this.visit(t.additiveExpression[1]) : r
     } : r;
@@ -2349,21 +2349,21 @@ class gn extends En {
   }
   unaryExpression(t) {
     return p(t).with(
-      { EXCLAMATION: l.when(Boolean) },
+      { EXCLAMATION: u.when(Boolean) },
       () => ({
         type: "unary",
         operator: "!",
         operand: this.visit(t.primaryExpression)
       })
     ).with(
-      { PLUS: l.when(Boolean) },
+      { PLUS: u.when(Boolean) },
       () => ({
         type: "unary",
         operator: "+",
         operand: this.visit(t.primaryExpression)
       })
     ).with(
-      { MINUS: l.when(Boolean) },
+      { MINUS: u.when(Boolean) },
       () => ({
         type: "unary",
         operator: "-",
@@ -2372,7 +2372,7 @@ class gn extends En {
     ).otherwise(() => this.visit(t.primaryExpression));
   }
   functionCall(t) {
-    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) => {
+    return p(t).with({ concatFunction: u.when(d) }, (r) => this.visit(r.concatFunction[0])).with({ strFunction: u.when(d) }, (r) => this.visit(r.strFunction[0])).with({ ifFunction: u.when(d) }, (r) => this.visit(r.ifFunction[0])).with({ iriFunction: u.when(d) }, (r) => this.visit(r.iriFunction[0])).with({ skolemFunction: u.when(d) }, (r) => this.visit(r.skolemFunction[0])).with({ roundFunction: u.when(d) }, (r) => this.visit(r.roundFunction[0])).with({ regexFunction: u.when(d) }, (r) => this.visit(r.regexFunction[0])).with({ iri: u.when(d), LPAREN: u.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(() => {
@@ -2424,8 +2424,8 @@ class gn extends En {
   }
   regexFunction(t) {
     const r = [
-      this.visit(O(t.textExpr, "REGEX missing text expression")),
-      this.visit(O(t.patternExpr, "REGEX missing pattern expression"))
+      this.visit(x(t.textExpr, "REGEX missing text expression")),
+      this.visit(x(t.patternExpr, "REGEX missing pattern expression"))
     ];
     return t.flagsExpr?.[0] && r.push(this.visit(t.flagsExpr)), {
       type: "function",
@@ -2437,13 +2437,13 @@ class gn extends En {
     return t.expression.map((r) => this.visit(r));
   }
   primaryExpression(t) {
-    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) => ({
+    return p(t).with({ expression: u.when(d) }, (r) => this.visit(r.expression[0])).with({ functionCall: u.when(d) }, (r) => this.visit(r.functionCall[0])).with({ literal: u.when(d) }, (r) => ({ type: "term", term: this.visit(r.literal[0]) })).with({ VARIABLE: u.when(d) }, (r) => ({
       type: "term",
       term: { type: "variable", name: r.VARIABLE[0].image.substring(1) }
-    })).with({ BLANK_NODE: l.when(d) }, (r) => ({
+    })).with({ BLANK_NODE: u.when(d) }, (r) => ({
       type: "term",
       term: { type: "blank", label: r.BLANK_NODE[0].image.substring(2) }
-    })).with({ iri: l.when(d) }, (r) => ({ type: "term", term: this.visit(r.iri[0]) })).otherwise(() => {
+    })).with({ iri: u.when(d) }, (r) => ({ type: "term", term: this.visit(r.iri[0]) })).otherwise(() => {
       throw new Error("Unknown primary expression type");
     });
   }
@@ -2480,7 +2480,7 @@ function B(e, t, r) {
   });
 }
 function yt(e, t) {
-  p(e).with({ type: l.union("triple", "property", "class", "general") }, (r) => {
+  p(e).with({ type: u.union("triple", "property", "class", "general") }, (r) => {
     I(t, rt(r));
   }).with({ type: "filter" }, (r) => {
     I(t, w(r.expression));
@@ -2498,12 +2498,12 @@ function yt(e, t) {
   }).exhaustive();
 }
 function yr(e, t) {
-  p(e).with({ type: l.union("triple", "property", "class", "general") }, (r) => {
+  p(e).with({ type: u.union("triple", "property", "class", "general") }, (r) => {
     I(t, rt(r));
   }).with({ type: "skolem" }, (r) => {
     const i = Kr(r);
     i && t.add(i);
-  }).with({ type: l.union("bind", "filter", "negation", "aggregate") }, () => {
+  }).with({ type: u.union("bind", "filter", "negation", "aggregate") }, () => {
   }).exhaustive();
 }
 function yn(e, t, r, i) {
@@ -2537,7 +2537,7 @@ function Ur(e, t, r) {
   });
 }
 function wr(e, t, r) {
-  p(e).with({ type: l.union("triple", "property", "class", "general") }, () => {
+  p(e).with({ type: u.union("triple", "property", "class", "general") }, () => {
   }).with({ type: "filter" }, (i) => {
     B(t, w(i.expression), r);
   }).with({ type: "bind" }, (i) => {
@@ -2729,7 +2729,7 @@ export {
   Te as STRING_LITERAL_LONG,
   Vt as SUM,
   ie as TRUE,
-  N as VARIABLE,
+  R as VARIABLE,
   Ui as WHITESPACE,
   or as allTokens,
   bs as areRulesEquivalent,
@@ -2798,7 +2798,7 @@ export {
   Vn as isTermExpression,
   xn as isTripleAtom,
   _n as isUnaryExpression,
-  v as isVariableTerm,
+  C as isVariableTerm,
   et as isXsdDatatype,
   wi as keywordTokenTypes,
   ns as literalSetComparisonFromExpression,
@@ -2824,7 +2824,7 @@ export {
   Kr as skolemMintedVariable,
   Si as stringLiteralTokenTypes,
   Ns as termTextsEqual,
-  b as termToDatalogText,
+  O as termToDatalogText,
   fs as termToSparql,
   ds as termTokenTypes,
   Je as termsEqual,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@manta-eu/datalog-parser",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "RDFox Datalog parser and AST builder with inference verification",
   "license": "MIT",
   "type": "module",