@manta-eu/datalog-parser 0.1.0

package/dist/index.js

@@ -0,0 +1,2871 @@
+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), Dn = (e) => p(e).with({ type: "blank" }, () => !0).otherwise(() => !1), $n = (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<>"{}|^`\\\\]', Dr = new RegExp(`^[a-z][a-z0-9+.-]*:${Ke}*$`, "i");
+function ts(e) {
+  return Dr.test(e);
+}
+function We(e) {
+  return e.includes("://");
+}
+const $r = /^(true|false)$/i, Gr = /^"(true|false)"\^\^<?\S*boolean>?$/i, St = "[eE][+-]?\\d+", _r = new RegExp(
+  `^[+-]?(?:\\d+\\.\\d*(?:${St})|\\d+\\.\\d+|\\.\\d+(?:${St})?|\\d+(?:${St})?)$`
+);
+function Rt(e) {
+  return _r.test(e);
+}
+const Vr = /^([+-]?)(\d*)(?:\.(\d*))?(?:[eE]([+-]?\d+))?$/, jr = 21;
+function qr(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;
+  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;
+  return h === "0" || r === "+" ? h : `${r}${h}`;
+}
+function es(e) {
+  if ($r.test(e)) return e.toLowerCase() === "true";
+  const t = e.match(Gr);
+  if (t != null && 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 = {
+  integer: "xsd:integer",
+  decimal: "xsd:decimal",
+  double: "xsd:double",
+  boolean: "xsd:boolean",
+  string: "xsd:string",
+  date: "xsd:date",
+  dateTime: "xsd:dateTime"
+}, Hr = ["integer", "decimal", "double"], Me = {
+  "||": 1,
+  "&&": 2,
+  "=": 3,
+  "!=": 3,
+  "<": 3,
+  ">": 3,
+  "<=": 3,
+  ">=": 3,
+  "+": 4,
+  "-": 4,
+  "*": 5,
+  "/": 5
+}, Ft = {
+  "=": "=",
+  "!=": "!=",
+  "<": ">",
+  "<=": ">=",
+  ">": "<",
+  ">=": "<="
+};
+function Be(e) {
+  return p(e).with({ type: u.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(
+    { type: "function" },
+    ({ name: t, args: r }) => t.toUpperCase() === "SKOLEM" || r.some(B)
+  ).with(
+    { type: "in" },
+    ({ expression: t, list: r }) => B(t) || r.some(B)
+  ).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(
+    { 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();
+}
+function Ye(e) {
+  return e.some((t) => t.type !== "negation" && xt(t));
+}
+function Ze(e) {
+  return p(e).with({ type: "class" }, (t) => ({
+    className: t.className,
+    instance: t.instance,
+    graph: t.graph
+  })).with(
+    {
+      type: "property",
+      predicate: u.union("a", "rdf:type", bt),
+      object: { type: "iri" }
+    },
+    (t) => ({
+      className: t.object.value,
+      instance: t.subject,
+      graph: t.graph
+    })
+  ).with(
+    {
+      type: "triple",
+      predicate: { type: "iri", value: u.union("a", "rdf:type", bt) },
+      object: { type: "iri" }
+    },
+    (t) => ({
+      className: t.object.value,
+      instance: t.subject,
+      graph: t.graph
+    })
+  ).otherwise(() => null);
+}
+function Je(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)) } },
+    (t) => ({
+      predicate: t.predicate.value,
+      subject: t.subject,
+      object: t.object,
+      graph: t.graph
+    })
+  ).otherwise(() => null);
+}
+function rs(e) {
+  return e in Ft;
+}
+function is(e) {
+  return Ft[e];
+}
+function it(e, t) {
+  return e === j[t] || e === `${Ot}${t}`;
+}
+function Fe(e) {
+  const { datatype: t } = e;
+  if (!(!t || it(t, "string")))
+    return t.startsWith(Ot) ? `xsd:${t.slice(Ot.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 Q(e) {
+  return Hr.some((t) => it(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 ss(e) {
+  return tt(e) && Q(e);
+}
+function er(e) {
+  return it(e.datatype, "boolean");
+}
+function Qr(e) {
+  return it(e.datatype, "date");
+}
+function zr(e) {
+  return it(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 os(e) {
+  return Kr(e.expression);
+}
+function Kr(e) {
+  return p(e).with(
+    { type: "binary", operator: u.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) ? {
+        variableName: i.name,
+        operator: Ft[t.operator],
+        literal: r
+      } : null;
+    }
+  ).otherwise(() => null);
+}
+function Wr(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)
+  ).otherwise(() => null);
+}
+function ls(e) {
+  var s;
+  if (e.type === "in") {
+    const a = G(e.expression), o = e.list.flatMap((l) => {
+      const E = ti(l);
+      return E ? [E] : [];
+    });
+    return a && o.length > 0 && o.length === e.list.length ? { subject: a, literals: o, negated: e.negated } : null;
+  }
+  const t = vt(e, "||");
+  if (t.length < 2) return null;
+  const r = t.flatMap((a) => {
+    const o = Wr(a);
+    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 : {
+    subject: i,
+    literals: r.map((a) => a.literal),
+    negated: !1
+  };
+}
+function Yr(e) {
+  const t = G(e);
+  return t && I(t) ? t.name : null;
+}
+function Zr(e) {
+  return p(e).with({ type: "skolem" }, (t) => {
+    const r = t.args.at(-1);
+    return r ? Yr(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);
+      });
+    }).with({ type: "skolem" }, (o) => o.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(
+      { 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) => [
+          y.variable,
+          ...y.expression === "*" ? [] : T(y.expression),
+          ...y.secondExpression ? T(y.secondExpression) : []
+        ])
+      ];
+      i(E);
+    }).with(
+      { type: "skolem" },
+      (l) => i(l.args.flatMap((E) => T(E)))
+    ).exhaustive();
+  };
+  return e.head.forEach(s), e.body.forEach(a), r;
+}
+function nt(e) {
+  return kr(e).map((t) => t.name);
+}
+function Jr(e) {
+  return e && I(e) ? [e.name] : [];
+}
+function T(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)
+  ]).exhaustive();
+}
+function ti(e) {
+  const t = G(e);
+  return t && tt(t) ? t : null;
+}
+function vt(e, t) {
+  return e.type !== "binary" || e.operator !== t ? [e] : [
+    ...vt(e.left, t),
+    ...vt(e.right, t)
+  ];
+}
+function rr(e) {
+  return We(e) ? `<${e}>` : e;
+}
+function x(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;
+  }).with({ type: "blank" }, (r) => `_:${r.label}`).exhaustive();
+}
+function ps(e, t = {}) {
+  const r = "graph" in e && e.graph ? ` ${x(e.graph, t)}` : "";
+  return p(e).with(
+    { type: "property" },
+    (i) => `${i.predicate}[${x(i.subject, t)}, ${x(i.object, t)}]${r}`
+  ).with(
+    { type: "triple" },
+    (i) => `[${x(i.subject, t)}, ${x(i.predicate, t)}, ${x(i.object, t)}]${r}`
+  ).with(
+    { type: "class" },
+    (i) => `${i.className}[${x(i.instance, t)}]${r}`
+  ).with(
+    { type: "general" },
+    (i) => `${i.tableName}(${i.terms.map((s) => x(s, t)).join(", ")})`
+  ).exhaustive();
+}
+function Pe(e) {
+  return Q(e) || er(e);
+}
+function hs(e, t = {}) {
+  return si(H(e, t));
+}
+function H(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}(`),
+    ...De(
+      r.args.map((i) => H(i, t)),
+      ", "
+    ),
+    C(")")
+  ]).with({ type: "in" }, (r) => [
+    ...H(r.expression, t),
+    C(` ${r.negated ? "NOT IN" : "IN"} (`),
+    ...De(
+      r.list.map((i) => H(i, t)),
+      ", "
+    ),
+    C(")")
+  ]).exhaustive();
+}
+function ei(e, t, r) {
+  if (e.type !== "binary") return !1;
+  const i = Me[e.operator], s = Me[t];
+  return i < s || r === "right" && i === s && (t === "-" || t === "/");
+}
+function ri(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 ii(e, t) {
+  const r = H(e, t);
+  return ri(e) ? ir(r) : r;
+}
+function ni(e, t) {
+  return I(e) ? [ai(e.name)] : tt(e) ? [oi(e, t)] : [C(x(e, t))];
+}
+function ir(e) {
+  return [C("("), ...e, C(")")];
+}
+function De(e, t) {
+  return e.flatMap((r, i) => i === 0 ? r : [C(t), ...r]);
+}
+function si(e) {
+  return e.map((t) => t.type === "variable" ? `?${t.name}` : t.text).join("");
+}
+function C(e) {
+  return { type: "text", text: e };
+}
+function ai(e) {
+  return { type: "variable", name: e };
+}
+function oi(e, t) {
+  return { type: "literal", literal: e, text: x(e, t) };
+}
+function G(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);
+}
+function Ct(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();
+}
+const g = new vr(), m = g.gen(), $e = Mt.getRule("aggregate"), Ge = Mt.getRule("expression"), ui = {
+  ...$e,
+  gImpl: (e) => (t, r) => {
+    const i = t.secondExpression;
+    if (!i)
+      return $e.gImpl(e)(t, r);
+    const { PRINT_WORD: s, SUBRULE: a } = e, o = t.expression[0], l = r.astFactory;
+    if (l.isWildcard(o))
+      throw new Error(
+        `RDFox aggregate ${t.aggregation.toUpperCase()} cannot combine * with a second expression.`
+      );
+    l.printFilter(t, () => {
+      s(t.aggregation.toUpperCase(), "("), t.distinct && s("DISTINCT");
+    }), a(Ge, o), l.printFilter(t, () => s(",")), a(Ge, i), l.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]) => {
+    const t = e;
+    return [t.LABEL.toLowerCase(), t.LABEL];
+  })
+);
+function $(e) {
+  if (e.includes("://") || e.startsWith("urn:") || e.startsWith("mailto:") || e.startsWith("tel:") || e.startsWith("data:"))
+    return g.termNamed(m, e);
+  const r = e.indexOf(":");
+  return r >= 0 ? g.termNamed(m, e.slice(r + 1), e.slice(0, r)) : g.termNamed(m, e);
+}
+function ot(e, t) {
+  return g.expressionOperation(e, t, m);
+}
+function di(e, t) {
+  const { function: r, expression: i, secondExpression: s } = e, a = pi.has(r), o = s !== void 0;
+  if (a && s == null)
+    throw new Error(`RDFox aggregate ${r} requires two expressions.`);
+  if (a && i === "*")
+    throw new Error(`RDFox aggregate ${r} cannot use * as an expression.`);
+  if (!a && o)
+    throw new Error(`RDFox aggregate ${r} accepts only one expression.`);
+  const l = i === "*" ? g.wildcard(m) : O(i, t), E = g.aggregate(
+    r.toLowerCase(),
+    e.distinct || !1,
+    l,
+    void 0,
+    m
+  );
+  return o ? {
+    ...E,
+    secondExpression: O(s, t)
+  } : E;
+}
+function D(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.`);
+  }).with("expression", () => {
+    if (e.type === "blank")
+      throw new Error(`Invalid expression term: ${e.type}. Expressions cannot use ${e.type} nodes.`);
+  }).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" ? $("rdf:type") : p(e).with({ type: "variable" }, (i) => (t.add(i.name), g.termVariable(i.name, m))).with({ type: "iri", prefixed: !0 }, (i) => $(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 = $(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());
+  if (i)
+    return ot(i.toLowerCase(), r);
+  const s = $(e.name);
+  return g.expressionFunctionCall(s, r, !1, m);
+}
+function O(e, t) {
+  return p(e).with(
+    { type: "binary" },
+    (r) => ot(r.operator, [
+      O(r.left, t),
+      O(r.right, t)
+    ])
+  ).with(
+    { type: "unary" },
+    (r) => ot(r.operator, [O(r.operand, t)])
+  ).with({ type: "term" }, (r) => D(r.term, t, "expression")).with({ type: "function" }, (r) => Ei(r, t)).with(
+    { type: "in" },
+    (r) => ot(r.negated ? "notin" : "in", [
+      O(r.expression, t),
+      ...r.list.map((i) => O(i, t))
+    ])
+  ).exhaustive();
+}
+function Pt(e, t) {
+  const r = p(e).with(
+    { type: "triple" },
+    (i) => g.triple(
+      D(i.subject, t),
+      D(i.predicate, t, "predicate"),
+      D(i.object, t)
+    )
+  ).with({ type: "property" }, (i) => {
+    const s = $(i.predicate);
+    return g.triple(D(i.subject, t), s, D(i.object, t));
+  }).with({ type: "class" }, (i) => {
+    const s = $("rdf:type"), a = $(i.className);
+    return g.triple(D(i.instance, t), s, a);
+  }).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(
+      D(e.graph, t, "graph"),
+      [i],
+      m
+    ) };
+  }
+  return { triples: [r] };
+}
+function fi(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" }, () => {
+      throw new Error("General formulas are not supported in negation patterns.");
+    }).exhaustive()
+  );
+}
+function gi(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;
+    }).with({ type: "filter" }, (s) => {
+      const a = O(s.expression, t), o = g.patternFilter(a, m);
+      return { ...r, filters: [...r.filters, o] };
+    }).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] };
+    }).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 ? `RDFox aggregate ${h.function}` : "Expression-only aggregate binding";
+      throw new Error(`${W} requires an expression.`);
+    }
+    if (h.function === void 0 && h.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);
+  }), {
+    triples: r,
+    filters: i,
+    binds: [...s, ...y],
+    graphPatterns: a,
+    selectVars: [...l, ...E],
+    groupBy: o
+  };
+}
+function yi(e, t) {
+  nr(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);
+      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);
+      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);
+      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] };
+      }
+      return h;
+    }).with({ type: "aggregate" }, (L) => {
+      const A = mi(L, r);
+      return {
+        triples: [...h.triples, ...A.triples],
+        filters: [...h.filters, ...A.filters],
+        binds: [...h.binds, ...A.binds],
+        graphPatterns: [...h.graphPatterns, ...A.graphPatterns],
+        groupByVars: A.groupBy,
+        aggregateSelectVars: A.selectVars
+      };
+    }).with({ type: "skolem" }, () => {
+      throw new Error("Skolem formulas are not supported in SPARQL translation.");
+    }).exhaustive(),
+    {
+      triples: [],
+      filters: [],
+      graphPatterns: [],
+      binds: [],
+      groupByVars: [],
+      aggregateSelectVars: []
+    }
+  ), s = [
+    ...i.triples.length > 0 ? [g.patternBgp(i.triples, m)] : [],
+    ...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
+    )
+  } : {}, l = t ? Object.entries(t).map(([h, R]) => {
+    const L = g.termNamed(m, R);
+    return g.contextDefinitionPrefix(m, h, L);
+  }) : [], E = g.querySelect(
+    {
+      context: l,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/ban-ts-comment
+      variables: a,
+      // @ts-ignore - Fails in CI for some reason
+      where: g.patternGroup(s, m),
+      datasets: g.datasetClauses([], m),
+      solutionModifiers: o
+    },
+    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);
+  return {
+    query: y,
+    variables: S
+  };
+}
+const kt = c({ name: "RULE_ARROW", pattern: /:-/ }), lt = c({ name: "NOT", pattern: /NOT/ }), Dt = c({ name: "EXISTS", pattern: /EXISTS?/ }), Z = c({ name: "IN", pattern: /IN/ }), $t = 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({
+  name: "PREFIXED_NAME",
+  pattern: new RegExp(`[a-zA-Z_][\\w]*:${or}`)
+}), Tt = c({ name: "PREFIX_ONLY", pattern: /[a-zA-Z_][\w]*:/ }), Ue = c({
+  name: "DEFAULT_NS_IRI",
+  pattern: new RegExp(`:${or}`)
+}), we = c({ name: "INTEGER", pattern: /[+-]?\d+/ }), Ae = c({ name: "DECIMAL", pattern: /[+-]?\d*\.\d+/ }), Te = c({
+  name: "DOUBLE",
+  pattern: /[+-]?(\d+\.\d*[eE][+-]?\d+|\.\d+[eE][+-]?\d+|\d+[eE][+-]?\d+)/
+}), Se = c({
+  name: "STRING_LITERAL_LONG",
+  pattern: /"""(?:[^"\\]|\\.|"(?!""))*"""|'''(?:[^'\\]|\\.|'(?!''))*'''/
+}), mt = c({
+  name: "STRING_LITERAL",
+  pattern: /"([^"\\]|\\.)*"|'([^'\\]|\\.)*'/
+}), Ne = c({ name: "LANGTAG", pattern: /@[a-zA-Z]+(-[a-zA-Z0-9]+)*/ }), rt = c({
+  name: "IDENTIFIER",
+  pattern: /[a-zA-Z_][a-zA-Z0-9_]*/,
+  longer_alt: st
+}), Ai = c({
+  name: "COMMENT",
+  pattern: /#[^\r\n]*/,
+  group: Bt.SKIPPED
+}), Ti = c({
+  name: "WHITESPACE",
+  pattern: /\s+/,
+  group: Bt.SKIPPED
+}), lr = [
+  // Whitespace and comments (skipped)
+  Ti,
+  Ai,
+  // Multi-character operators (before single-char)
+  kt,
+  oe,
+  ue,
+  pe,
+  he,
+  de,
+  gt,
+  // Keywords (before identifiers)
+  lt,
+  Dt,
+  Z,
+  $t,
+  z,
+  K,
+  wt,
+  At,
+  zt,
+  Kt,
+  Wt,
+  Yt,
+  Ht,
+  Qt,
+  Gt,
+  _t,
+  Vt,
+  jt,
+  qt,
+  Xt,
+  ut,
+  Zt,
+  Jt,
+  te,
+  ee,
+  ct,
+  re,
+  ie,
+  ne,
+  se,
+  // Literals (specific patterns before generic)
+  Se,
+  mt,
+  Te,
+  Ae,
+  we,
+  Ne,
+  // Identifiers and names
+  b,
+  ye,
+  me,
+  et,
+  st,
+  Ue,
+  Tt,
+  rt,
+  // Single character tokens
+  ae,
+  le,
+  ce,
+  pt,
+  ht,
+  dt,
+  Ee,
+  fe,
+  ge,
+  N,
+  U,
+  w,
+  Et,
+  ft,
+  sr,
+  ar
+], Si = /* @__PURE__ */ new Set([lt, Dt, Z, $t, z, K, wt, At, ut]), Ni = /* @__PURE__ */ new Set([
+  Gt,
+  _t,
+  Vt,
+  jt,
+  qt,
+  Xt,
+  Ht,
+  Qt,
+  zt,
+  Kt,
+  Wt,
+  Yt,
+  Zt,
+  Jt,
+  te,
+  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,
+  ae,
+  oe,
+  le,
+  ue,
+  ce,
+  pe,
+  he,
+  de,
+  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/);
+  return {
+    message: i,
+    line: a.length,
+    column: (((o = a.at(-1)) == null ? void 0 : o.length) ?? 0) + 1,
+    offset: t,
+    endOffset: t + r
+  };
+}
+function be(e) {
+  for (let t = 0; t < e.length; t++) {
+    const r = e.charCodeAt(t);
+    if (r >= 55296 && r <= 56319) {
+      const i = e.charCodeAt(t + 1);
+      if (i >= 56320 && i <= 57343) {
+        t++;
+        continue;
+      }
+      return J(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");
+  }
+}
+function Oe(e, t) {
+  for (const r of t)
+    if (bi.has(r.tokenType))
+      for (let i = 0; i < r.image.length; i++) {
+        if (r.image[i] !== "\\") continue;
+        const s = r.image[i + 1];
+        if (s !== "u" && s !== "U") {
+          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(
+            e,
+            y,
+            l.length,
+            `Unicode escape \\${s} must contain ${a} 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;
+      }
+}
+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]
+        {
+          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);
+          }
+        }
+      ]);
+    }));
+    // 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", () => {
+      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);
+          }
+        },
+        { ALT: () => this.SUBRULE(this.tupleTableAtom) }
+      ]);
+    }));
+    // ExistsClause := 'EXISTS' variable (',' variable)* 'IN'
+    d(this, "existsClause", this.RULE("existsClause", () => {
+      this.CONSUME(Dt), 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($t), 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);
+            }
+          }
+        ]);
+      });
+    }));
+    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)
+        {
+          ALT: () => {
+            this.SUBRULE(this.iri), this.CONSUME(U), this.OPTION(() => {
+              this.SUBRULE(this.argumentList);
+            }), this.CONSUME(w);
+          }
+        }
+      ]);
+    }));
+    // 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", () => {
+      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) }
+      ]);
+    }));
+    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;
+  }
+}
+let xi;
+function ve() {
+  return xi ?? (xi = new xe());
+}
+function ur(e, t) {
+  const r = be(t);
+  if (r) throw new Error(r.message);
+  const i = Re(t);
+  if (i.errors.length > 0)
+    throw new Error(`Lexer errors: ${i.errors.map((o) => o.message).join(", ")}`);
+  const s = Oe(t, i.tokens);
+  if (s) throw new Error(s.message);
+  e.input = i.tokens;
+  const a = e.rule();
+  if (e.errors.length > 0)
+    throw new Error(`Parser errors: ${e.errors.map((o) => o.message).join(", ")}`);
+  return a;
+}
+function cr(e) {
+  return ur(ve(), e);
+}
+function ys(e) {
+  try {
+    return cr(e), { valid: !0 };
+  } catch (t) {
+    return {
+      valid: !1,
+      error: t instanceof Error ? t.message : "Unknown parsing error"
+    };
+  }
+}
+class vi extends xe {
+  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 RDFox-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();
+  }
+  // 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) }]);
+  }
+}
+let Ci;
+function Ii() {
+  return Ci ?? (Ci = new vi());
+}
+function Mi(e) {
+  return ur(Ii(), 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);
+  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 Fi(e) {
+  const t = e.head[0];
+  return t ? p(t).with({ type: "triple" }, (r) => ({
+    subject: _(r.subject),
+    predicate: _(r.predicate),
+    object: _(r.object)
+  })).with({ type: "property" }, (r) => ({
+    subject: _(r.subject),
+    predicate: r.predicate,
+    object: _(r.object)
+  })).with({ type: "class" }, (r) => ({
+    subject: _(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();
+}
+const Pi = q.object({
+  results: q.object({
+    bindings: q.array(q.unknown())
+  })
+}), ki = q.object({
+  boolean: q.boolean()
+});
+async function Us(e, t, r, i, s) {
+  if (Ye(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)
+      return {
+        verified: !1,
+        error: "Could not generate test triple from rule head"
+      };
+    const l = Bi(e), E = await Di(l, t, r, i);
+    if (E)
+      return {
+        verified: !1,
+        testTriple: o,
+        candidateQuery: l,
+        error: E
+      };
+    const y = $i(o), S = new URL(`datastores/${r}/sparql`, t), h = await fetch(S.toString(), {
+      method: "POST",
+      headers: {
+        Authorization: i,
+        "Content-Type": "application/sparql-query",
+        Accept: "application/sparql-results+json"
+      },
+      body: y
+    });
+    if (!h.ok)
+      throw new Error(`SPARQL query failed: ${h.status} - ${await h.text()}`);
+    return {
+      verified: ki.parse(await h.json()).boolean,
+      testTriple: o,
+      sparqlQuery: y,
+      candidateQuery: l
+    };
+  } catch (o) {
+    return {
+      verified: !1,
+      testTriple: s,
+      error: o instanceof Error ? o.message : "Unknown error during inference verification"
+    };
+  }
+}
+async function Di(e, t, r, i) {
+  try {
+    const s = new URL(`datastores/${r}/sparql`, t), a = await fetch(s.toString(), {
+      method: "POST",
+      headers: {
+        Authorization: i,
+        "Content-Type": "application/sparql-query",
+        Accept: "application/sparql-results+json"
+      },
+      body: e
+    });
+    if (!a.ok) {
+      let l = "";
+      try {
+        l = await a.text();
+      } catch {
+      }
+      const E = l || a.statusText;
+      return `Candidate query failed: ${a.status}${E ? ` - ${E}` : ""}`;
+    }
+    return Pi.parse(await a.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 $i(e) {
+  return `
+    ASK WHERE {
+      ${e.subject} ${e.predicate} ${e.object} .
+      FILTER(NOT EXISTS {
+        ${e.subject} ${e.predicate} ${e.object} EXPLICIT true
+      })
+    }
+  `.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) => {
+    const { subject: r, predicate: i, object: s } = t.testTriple;
+    return `Expected inference was not produced:
+
+Expected triple: ${r} ${i} ${s}
+
+This could indicate:
+1. The rule syntax is correct but the rule conditions are not met
+2. Required facts are missing from the knowledge base
+3. Variable bindings in the rule body don't match existing data
+4. The rule head atom format doesn't match the expected pattern
+
+To debug:
+1. Check if the rule body conditions can be satisfied with current facts
+2. Verify variable names are consistent between head and body
+3. Ensure IRIs and predicates use correct prefixes
+4. Test rule components individually`;
+  }).exhaustive();
+}
+const Gi = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type";
+function pr() {
+  return { classes: [], predicates: [] };
+}
+function yt(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 hr(e) {
+  const t = Ze(e);
+  if (t)
+    return {
+      classes: [{ term: t.className, graph: t.graph }],
+      predicates: []
+    };
+  const r = Je(e);
+  return r && !_i(r.predicate) ? {
+    classes: [],
+    predicates: [{ term: r.predicate, graph: r.graph }]
+  } : pr();
+}
+function It(e) {
+  return p(e).with({ type: u.union("triple", "property", "class", "general") }, hr).with(
+    { type: "negation" },
+    ({ formulas: t }) => yt(t.map(It))
+  ).with(
+    { type: "aggregate" },
+    ({ atoms: t }) => yt(t.map(It))
+  ).with({ type: u.union("filter", "bind", "skolem") }, pr).exhaustive();
+}
+function Vi(e) {
+  return {
+    head: yt(e.head.map(hr)),
+    body: yt(e.body.map(It))
+  };
+}
+const ji = [
+  n.expression,
+  n.conditionalOrExpression,
+  n.conditionalAndExpression,
+  n.valueLogical,
+  n.relationalExpression,
+  n.numericExpression,
+  n.expressionList,
+  n.additiveExpression,
+  n.multiplicativeExpression,
+  n.unaryExpression,
+  n.primaryExpression,
+  n.brackettedExpression,
+  // BuiltInCall,
+  n.iriOrFunction,
+  n.rdfLiteral,
+  n.numericLiteral,
+  n.numericLiteralUnsigned,
+  n.numericLiteralPositive,
+  n.numericLiteralNegative,
+  n.booleanLiteral,
+  n.var_,
+  n.builtInStr,
+  n.builtInLang,
+  n.builtInLangmatches,
+  n.builtInDatatype,
+  n.builtInBound,
+  n.builtInIri,
+  n.builtInUri,
+  n.builtInBnodeSparqlJs,
+  n.builtInRand,
+  n.builtInAbs,
+  n.builtInCeil,
+  n.builtInFloor,
+  n.builtInRound,
+  n.builtInConcat,
+  n.builtInStrlen,
+  n.builtInUcase,
+  n.builtInLcase,
+  n.builtInEncode_for_uri
+], qi = {
+  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 = [
+  n.objectList,
+  n.object,
+  n.graphNode,
+  n.varOrTerm,
+  n.triplesNode,
+  n.collection,
+  n.blankNodePropertyList,
+  n.propertyListNotEmpty,
+  // PropertyListNotEmpty
+  n.verb,
+  n.verbA,
+  n.varOrIri,
+  n.var_,
+  n.iri,
+  n.iriFull,
+  n.prefixedName,
+  n.graphTerm,
+  n.rdfLiteral,
+  n.numericLiteral,
+  n.booleanLiteral,
+  n.blankNode,
+  n.string,
+  n.numericLiteralUnsigned,
+  n.numericLiteralPositive,
+  n.numericLiteralNegative
+], dr = P.create(Hi), Qi = P.create([
+  n.triplesBlock,
+  n.triplesSameSubjectPath,
+  // VarOrTerm is included in the required ObjectList rule
+  n.propertyListPathNotEmpty,
+  n.triplesNodePath,
+  n.propertyListPath,
+  // PropertyListNotEmpty
+  n.verbPath,
+  n.verbSimple,
+  n.objectListPath
+]).merge(dr, []).addMany(
+  n.path,
+  n.pathAlternative,
+  n.pathSequence,
+  n.pathEltOrInverse,
+  n.pathElt,
+  n.pathPrimary,
+  n.pathMod,
+  n.pathNegatedPropertySet,
+  n.pathOneInPropertySet,
+  // ObjectListPath
+  n.objectPath,
+  n.graphNodePath,
+  n.collectionPath,
+  n.blankNodePropertyListPath
+), zi = [
+  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(
+  n.graphPatternNotTriples,
+  n.groupOrUnionGraphPattern,
+  n.optionalGraphPattern,
+  n.minusGraphPattern,
+  n.graphGraphPattern,
+  n.serviceGraphPattern,
+  n.filter,
+  n.bind,
+  n.inlineData,
+  n.constraint,
+  n.functionCall,
+  n.dataBlock,
+  n.inlineDataOneVar,
+  n.inlineDataFull,
+  n.dataBlockValue,
+  // Solution modifier
+  n.groupClause,
+  n.havingClause,
+  n.orderClause,
+  n.limitOffsetClauses,
+  n.groupCondition,
+  n.havingCondition,
+  n.orderCondition,
+  n.limitClause,
+  n.offsetClause
+), Ki = [
+  n.triplesTemplate,
+  n.triplesSameSubject,
+  n.varOrTerm,
+  n.propertyListNotEmpty,
+  n.triplesNode,
+  n.propertyList,
+  n.var_,
+  n.graphTerm,
+  n.iri,
+  n.iriFull,
+  n.prefixedName,
+  n.rdfLiteral,
+  n.string,
+  n.numericLiteral,
+  n.numericLiteralUnsigned,
+  n.numericLiteralPositive,
+  n.numericLiteralNegative,
+  n.booleanLiteral,
+  n.blankNode,
+  n.verb,
+  n.verbA,
+  n.varOrIri,
+  n.objectList,
+  n.object,
+  n.collection,
+  n.blankNodePropertyList,
+  n.graphNode
+], fr = P.create(Ki), Wi = [
+  n.queryUnit,
+  n.query,
+  n.prologue,
+  n.selectQuery,
+  n.constructQuery,
+  n.describeQuery,
+  n.askQuery,
+  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 = {
+  name: "update1",
+  impl: ({ SUBRULE: e, OR: t }) => () => t([
+    { ALT: () => e(n.load) },
+    { ALT: () => e(n.clear) },
+    { ALT: () => e(n.drop) },
+    { ALT: () => e(n.add) },
+    { ALT: () => e(n.move) },
+    { ALT: () => e(n.copy) },
+    { ALT: () => e(n.create) },
+    { ALT: () => e(n.insertData) },
+    { ALT: () => e(n.deleteData) },
+    { ALT: () => e(n.deleteWhere) }
+  ]),
+  gImpl: n.update1.gImpl
+}, Ji = [
+  n.updateUnit,
+  n.update,
+  n.prologue,
+  // Update1,
+  n.baseDecl,
+  n.prefixDecl,
+  n.load,
+  n.clear,
+  n.drop,
+  n.add,
+  n.move,
+  n.copy,
+  n.create,
+  n.insertData,
+  n.deleteData,
+  n.deleteWhere,
+  n.iri,
+  n.prefixedName,
+  n.graphRef,
+  n.graphRefAll,
+  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 {
+  constructor(t = {}) {
+    const r = rn.build({
+      ...t,
+      tokenVocabulary: ze.sparql11LexerBuilder.tokenVocabulary,
+      queryPreProcessor: Mr
+    });
+    super(r, t.defaultContext);
+  }
+}
+let Lt;
+function nn(e) {
+  return e.type === "query";
+}
+function mr(e) {
+  return e.type === "update";
+}
+function yr(e) {
+  return e.replace(/\s+EXPLICIT\s+(TRUE|FALSE)\b/gi, "");
+}
+function sn(e) {
+  Lt ?? (Lt = new gr());
+  try {
+    const t = Lt.parse(yr(e));
+    return mr(t) ? {
+      valid: !0,
+      queryType: "update",
+      isReadOnly: !1
+    } : nn(t) ? {
+      valid: !0,
+      queryType: t.subType,
+      isReadOnly: !0
+    } : {
+      valid: !1,
+      error: "Unknown query type"
+    };
+  } catch (t) {
+    return {
+      valid: !1,
+      error: t instanceof Error ? t.message : "Failed to parse SPARQL query"
+    };
+  }
+}
+function As(e) {
+  const t = sn(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([
+  "insertdata",
+  "deletedata",
+  "modify"
+]), on = {
+  insertdata: "INSERT DATA",
+  deletedata: "DELETE DATA",
+  deletewhere: "DELETE WHERE",
+  modify: "DELETE/INSERT WHERE",
+  load: "LOAD",
+  clear: "CLEAR",
+  drop: "DROP",
+  create: "CREATE",
+  add: "ADD",
+  move: "MOVE",
+  copy: "COPY"
+};
+function _e(e) {
+  return an.has(e);
+}
+function Ve(e) {
+  return e.type === "term" && e.subType === "variable";
+}
+function ln(e) {
+  return Ve(e.subject) && e.predicate.subType === "variable" && Ve(e.object);
+}
+function un(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;
+  }
+  return !1;
+}
+function cn(e) {
+  return e.delete.length > 0 && un(e.delete);
+}
+function Ts(e) {
+  Lt ?? (Lt = new gr());
+  let t;
+  try {
+    t = Lt.parse(yr(e));
+  } catch (o) {
+    return {
+      allowed: !1,
+      error: o instanceof Error ? o.message : "Failed to parse SPARQL update"
+    };
+  }
+  if (!mr(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);
+  if (r.length === 0)
+    return { allowed: !1, error: "Empty SPARQL update -- no operations found." };
+  const i = r.filter((o) => !_e(o.subType));
+  if (i.length > 0) {
+    const o = i.map((E) => E.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
+    };
+  }
+  return r.filter(
+    (o) => o.subType === "modify" && cn(o)
+  ).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) };
+}
+async function pn(e) {
+  const { rdfoxUrl: t, datastoreName: r, authorization: i } = e, s = new URL(`datastores/${r}/connections`, t), a = 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}`);
+  }
+  const o = a.headers.get("Location");
+  if (!o)
+    throw new Error("Connection creation response missing Location header");
+  return o.split("/").pop();
+}
+async function hn(e) {
+  const { rdfoxUrl: 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(), {
+    method: "PATCH",
+    headers: {
+      Authorization: s
+    }
+  });
+  if (!o.ok) {
+    const l = await o.text();
+    throw new Error(`Failed to begin transaction: ${o.status} - ${l}`);
+  }
+}
+async function dn(e) {
+  const { rdfoxUrl: 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(), {
+    method: "PATCH",
+    headers: {
+      Authorization: s
+    }
+  });
+  if (!o.ok) {
+    const l = await o.text();
+    throw new Error(`Failed to commit transaction: ${o.status} - ${l}`);
+  }
+}
+async function En(e) {
+  const { rdfoxUrl: 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(), {
+    method: "PATCH",
+    headers: {
+      Authorization: s
+    }
+  });
+  if (!o.ok) {
+    const l = await o.text();
+    throw new Error(`Failed to rollback transaction: ${o.status} - ${l}`);
+  }
+}
+async function fn(e) {
+  const { rdfoxUrl: t, datastoreName: r, connectionId: i, authorization: s } = e, a = new URL(`datastores/${r}/connections/${i}`, t), o = await fetch(a.toString(), {
+    method: "DELETE",
+    headers: {
+      Authorization: s
+    }
+  });
+  if (!o.ok) {
+    const l = await o.text();
+    throw new Error(`Failed to delete connection: ${o.status} - ${l}`);
+  }
+}
+async function Ss(e, t) {
+  const r = await pn(e);
+  try {
+    await hn({ ...e, connectionId: r });
+    const i = await t(r);
+    return await dn({ ...e, connectionId: r }), i;
+  } catch (i) {
+    try {
+      await En({ ...e, connectionId: r });
+    } catch (s) {
+      console.error("Failed to rollback transaction:", s);
+    }
+    throw i;
+  } finally {
+    try {
+      await fn({ ...e, connectionId: r });
+    } catch (i) {
+      console.error("Failed to delete connection:", i);
+    }
+  }
+}
+function Nt(e) {
+  return e.type === "variable" ? `?${e.name}` : void 0;
+}
+function Ns(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));
+      }
+      return;
+    }
+    const y = Je(o);
+    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" });
+  }
+  function s(a) {
+    if (Be(a)) {
+      i({ atom: a, fromBody: !0 });
+      return;
+    }
+    a.type === "aggregate" && a.atoms.filter(Be).forEach((o) => i({ atom: o, fromBody: !0 }));
+  }
+  return e.head.forEach((a) => i({ atom: a })), e.body.forEach(s), [...t.values()];
+}
+function Rs(e, t) {
+  const r = [];
+  for (const i of e) {
+    const s = i.bodyClassTerm ?? i.classTerm;
+    if (s) {
+      r.push({ variable: i.variable, typeTerm: s, source: "class" });
+      continue;
+    }
+    const a = gn(i.predicateEvidence, t);
+    a && r.push({ variable: i.variable, ...a });
+  }
+  return r;
+}
+function gn(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 mn = new xe({ selfAnalysis: !1 }).getBaseCstVisitorConstructor();
+function v(e, t) {
+  if (e === void 0)
+    throw new Error(t);
+  return e;
+}
+function at(e, t, ...r) {
+  var s;
+  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]);
+  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) {
+  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) {
+  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) {
+  return {
+    token: e,
+    term: { type: "iri", value: r, prefixed: t }
+  };
+}
+function qe(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)
+  ).otherwise(() => {
+    throw new Error("Unknown IRI type");
+  });
+}
+function yn(e, t) {
+  const r = Y(e);
+  return {
+    start: r.start + t,
+    end: r.end - t
+  };
+}
+class Ln extends mn {
+  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) : [];
+    return { head: r, body: i };
+  }
+  ruleHead(t) {
+    return t.tupleTableAtom.map((r) => this.visit(r));
+  }
+  ruleBody(t) {
+    return t.bodyFormula.map((r) => this.visit(r));
+  }
+  bodyFormula(t) {
+    return at(
+      t,
+      this.visit.bind(this),
+      "negation",
+      "filterAtom",
+      "bindAtom",
+      "aggregate",
+      "skolemAtom",
+      "tupleTableAtom"
+    );
+  }
+  tupleTableAtom(t) {
+    const r = at(t, this.visit.bind(this), "defaultGraphAtom", "generalAtom");
+    if (f(t.graph)) {
+      const i = this.visit(t.graph[0]);
+      if (r.type === "triple" || r.type === "property" || r.type === "class")
+        return { ...r, graph: i };
+      throw new Error(`Graph annotation not supported on atom type '${r.type}'`);
+    }
+    return r;
+  }
+  graphName(t) {
+    if (f(t.VARIABLE))
+      return { type: "variable", name: t.VARIABLE[0].image.substring(1) };
+    if (f(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))
+      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)) {
+      const i = this.extractIriValue(r.predicateOrClass[0]), s = this.visit(r.firstTerm[0]);
+      return f(r.secondTerm) ? {
+        type: "property",
+        predicate: i,
+        subject: s,
+        object: this.visit(r.secondTerm[0])
+      } : {
+        type: "class",
+        className: i,
+        instance: s
+      };
+    }
+    throw new Error("Unknown default graph atom format");
+  }
+  generalAtom(t) {
+    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) : (() => {
+        throw new Error("Missing table name");
+      })(),
+      terms: r.term.map((s) => this.visit(s))
+    };
+  }
+  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) };
+    throw new Error("Unknown term type");
+  }
+  iri(t) {
+    return qe(t).term;
+  }
+  literal(t) {
+    return at(
+      t,
+      this.visit.bind(this),
+      "numericLiteral",
+      "booleanLiteral",
+      "stringLiteral"
+    );
+  }
+  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);
+    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 };
+    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;
+    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 = {
+      type: "literal",
+      value: a,
+      termSpan: { start: o.start, end: y },
+      valueSpan: yn(s, r ? 3 : 1)
+    };
+    return l ? S.language = l.image.substring(1) : E && (S.datatype = E.term.value), S;
+  }
+  negation(t) {
+    var s, a, o;
+    const r = [];
+    if ((s = t.existsClause) != null && s[0]) {
+      const l = this.visit(t.existsClause);
+      r.push(...l);
+    }
+    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)), {
+      type: "negation",
+      formulas: i,
+      existentialVars: r.length > 0 ? r : void 0
+    };
+  }
+  existsClause(t) {
+    return t.VARIABLE.map((r) => r.image.substring(1));
+  }
+  atomList(t) {
+    return t.atom ? t.atom.map((r) => this.visit(r)) : [];
+  }
+  atom(t) {
+    return at(
+      t,
+      (r) => this.visit(r),
+      "tupleTableAtom",
+      "filterAtom",
+      "bindAtom"
+    );
+  }
+  bodyFormulaList(t) {
+    return t.bodyFormula.map((r) => this.visit(r));
+  }
+  filterAtom(t) {
+    return {
+      type: "filter",
+      expression: this.visit(v(t.expression, "Filter missing expression"))
+    };
+  }
+  bindAtom(t) {
+    return {
+      type: "bind",
+      expression: this.visit(v(t.expression, "Bind missing expression")),
+      ...this.asTarget(t, "Bind missing variable")
+    };
+  }
+  // The expanded grammar accepts a value where a variable belongs, because RDFox
+  // substitutes the `AS` target when it grounds a rule.
+  asTarget(t, r) {
+    var a;
+    const i = (a = t.VARIABLE) == null ? void 0 : a[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 };
+  }
+  // A variable-free `term`, so it visits identically.
+  groundedAsTarget(t) {
+    return this.term(t);
+  }
+  skolemAtom(t) {
+    return {
+      type: "skolem",
+      args: this.visit(v(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))
+      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,
+      bindings: s
+    };
+  }
+  // RDFox 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 })
+    );
+    return {
+      onVars: [...r, ...s],
+      groundedOnTargets: i.length > 0 ? i : void 0
+    };
+  }
+  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")),
+      ...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(() => {
+      throw new Error("Unknown aggregate function arity");
+    });
+  }
+  aggregateFunction1(t) {
+    var i;
+    return {
+      function: p(t).when(
+        (s) => !!s.COUNT_MIN,
+        () => "COUNT_MIN"
+      ).when(
+        (s) => !!s.COUNT_MAX,
+        () => "COUNT_MAX"
+      ).when(
+        (s) => !!s.COUNT,
+        () => "COUNT"
+      ).when(
+        (s) => !!s.MIN,
+        () => "MIN"
+      ).when(
+        (s) => !!s.MAX,
+        () => "MAX"
+      ).when(
+        (s) => !!s.SUM,
+        () => "SUM"
+      ).when(
+        (s) => !!s.MUL,
+        () => "MUL"
+      ).when(
+        (s) => !!s.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" } },
+      ...t.DISTINCT && { distinct: !0 }
+    };
+  }
+  aggregateFunction2(t) {
+    var i, s;
+    return {
+      function: p(t).when(
+        (a) => !!a.MIN_ARGMIN,
+        () => "MIN_ARGMIN"
+      ).when(
+        (a) => !!a.MAX_ARGMIN,
+        () => "MAX_ARGMIN"
+      ).when(
+        (a) => !!a.MIN_ARGMAX,
+        () => "MIN_ARGMAX"
+      ).when(
+        (a) => !!a.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")),
+      secondExpression: this.visit(
+        v((s = t.secondExpr) == null ? void 0 : s[0], "AggregateFunction2 missing second expression")
+      ),
+      ...t.DISTINCT && { distinct: !0 }
+    };
+  }
+  expression(t) {
+    return this.visit(t.conditionalOrExpression);
+  }
+  conditionalOrExpression(t) {
+    return t.conditionalAndExpression.slice(1).reduce(
+      (r, i) => ({
+        type: "binary",
+        operator: "||",
+        left: r,
+        right: this.visit(i)
+      }),
+      this.visit(t.conditionalAndExpression[0])
+    );
+  }
+  conditionalAndExpression(t) {
+    return t.relationalExpression.slice(1).reduce(
+      (r, i) => ({
+        type: "binary",
+        operator: "&&",
+        left: r,
+        right: this.visit(i)
+      }),
+      this.visit(t.relationalExpression[0])
+    );
+  }
+  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) : [];
+      return {
+        type: "in",
+        negated: s,
+        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(() => "="),
+      left: r,
+      right: t.additiveExpression[1] ? this.visit(t.additiveExpression[1]) : r
+    } : r;
+  }
+  additiveExpression(t) {
+    const r = je([
+      { arr: t.PLUS, op: "+" },
+      { arr: t.MINUS, op: "-" }
+    ]);
+    return t.multiplicativeExpression.slice(1).reduce(
+      (i, s, a) => ({
+        type: "binary",
+        operator: r[a] ?? "+",
+        left: i,
+        right: this.visit(s)
+      }),
+      this.visit(t.multiplicativeExpression[0])
+    );
+  }
+  multiplicativeExpression(t) {
+    const r = je([
+      { arr: t.STAR, op: "*" },
+      { arr: t.SLASH, op: "/" }
+    ]);
+    return t.unaryExpression.slice(1).reduce(
+      (i, s, a) => ({
+        type: "binary",
+        operator: r[a] ?? "*",
+        left: i,
+        right: this.visit(s)
+      }),
+      this.visit(t.unaryExpression[0])
+    );
+  }
+  unaryExpression(t) {
+    return p(t).with(
+      { EXCLAMATION: u.when(Boolean) },
+      () => ({
+        type: "unary",
+        operator: "!",
+        operand: this.visit(t.primaryExpression)
+      })
+    ).with(
+      { PLUS: u.when(Boolean) },
+      () => ({
+        type: "unary",
+        operator: "+",
+        operand: this.visit(t.primaryExpression)
+      })
+    ).with(
+      { MINUS: u.when(Boolean) },
+      () => ({
+        type: "unary",
+        operator: "-",
+        operand: this.visit(t.primaryExpression)
+      })
+    ).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 };
+    }).otherwise(() => {
+      throw new Error("Unknown function call type");
+    });
+  }
+  concatFunction(t) {
+    return {
+      type: "function",
+      name: "CONCAT",
+      args: this.visit(t.argumentList)
+    };
+  }
+  strFunction(t) {
+    return {
+      type: "function",
+      name: "STR",
+      args: [this.visit(t.expression)]
+    };
+  }
+  ifFunction(t) {
+    return {
+      type: "function",
+      name: "IF",
+      args: [this.visit(t.condition), this.visit(t.thenExpr), this.visit(t.elseExpr)]
+    };
+  }
+  iriFunction(t) {
+    const r = [this.visit(t.iriExpr)];
+    return t.baseIri && r.push(this.visit(t.baseIri)), {
+      type: "function",
+      name: "IRI",
+      args: r
+    };
+  }
+  skolemFunction(t) {
+    return {
+      type: "function",
+      name: "SKOLEM",
+      args: this.visit(t.argumentList)
+    };
+  }
+  roundFunction(t) {
+    return {
+      type: "function",
+      name: "ROUND",
+      args: [this.visit(t.expression)]
+    };
+  }
+  regexFunction(t) {
+    var i;
+    const r = [
+      this.visit(v(t.textExpr, "REGEX missing text expression")),
+      this.visit(v(t.patternExpr, "REGEX missing pattern expression"))
+    ];
+    return (i = t.flagsExpr) != null && i[0] && r.push(this.visit(t.flagsExpr)), {
+      type: "function",
+      name: "REGEX",
+      args: r
+    };
+  }
+  argumentList(t) {
+    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) => ({
+      type: "term",
+      term: { type: "variable", name: r.VARIABLE[0].image.substring(1) }
+    })).with({ BLANK_NODE: u.when(f) }, (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(() => {
+      throw new Error("Unknown primary expression type");
+    });
+  }
+  extractIriValue(t) {
+    return this.visit(t).value;
+  }
+  numericTokenLiteral(t, r) {
+    const i = Y(t);
+    return {
+      type: "literal",
+      value: t.image,
+      datatype: r,
+      termSpan: i,
+      valueSpan: i
+    };
+  }
+  unquoteString(t) {
+    return t.substring(1, t.length - 1).replace(/\\(.)/g, "$1");
+  }
+  unquoteTripleString(t) {
+    return t.substring(3, t.length - 3).replace(/\\(.)/g, "$1");
+  }
+}
+let Un;
+function Ce() {
+  return Un ?? (Un = new Ln());
+}
+function M(e, t) {
+  t.forEach((r) => e.add(r));
+}
+function F(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));
+  }).with({ type: "filter" }, (r) => {
+    M(t, T(r.expression));
+  }).with({ type: "bind" }, (r) => {
+    M(t, T(r.expression)), t.add(r.variable);
+  }).with({ type: "skolem" }, (r) => {
+    r.args.forEach((i) => M(t, T(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]);
+  }).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));
+    });
+  }).exhaustive();
+}
+function Lr(e, t) {
+  p(e).with({ type: u.union("triple", "property", "class", "general") }, (r) => {
+    M(t, nt(r));
+  }).with({ type: "skolem" }, (r) => {
+    const i = Zr(r);
+    i && t.add(i);
+  }).with({ type: u.union("bind", "filter", "negation", "aggregate") }, () => {
+  }).exhaustive();
+}
+function wn(e, t, r, i) {
+  F(r, T(t), i), r.add(e);
+}
+function Ur(e, t, r) {
+  var o;
+  const i = /* @__PURE__ */ new Set();
+  e.atoms.forEach((l) => Lr(l, 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);
+  });
+}
+function wr(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);
+    });
+  });
+}
+function Ar(e, t, r) {
+  p(e).with({ type: u.union("triple", "property", "class", "general") }, () => {
+  }).with({ type: "filter" }, (i) => {
+    F(t, T(i.expression), r);
+  }).with({ type: "bind" }, (i) => {
+    wn(i.variable, i.expression, t, r);
+  }).with({ type: "skolem" }, (i) => {
+    i.args.slice(0, -1).forEach((s) => F(t, T(s), r));
+  }).with({ type: "negation" }, (i) => {
+    wr(i, t, r);
+  }).with({ type: "aggregate" }, (i) => {
+    Ur(i, t, r);
+  }).exhaustive();
+}
+function An(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();
+}
+function Tr(e, t) {
+  const r = t(e);
+  return { ...Ce().visit(r), raw: e };
+}
+function Xe(e) {
+  return Tr(e, cr);
+}
+function bs(e) {
+  return { ...Tr(e, Mi), grounded: !0 };
+}
+function X(e) {
+  return e !== void 0 && Number.isFinite(e) ? e : void 0;
+}
+function Tn(e) {
+  const t = X(e.startOffset), r = X(e.endOffset);
+  return { offset: t, endOffset: r === void 0 ? void 0 : r + 1 };
+}
+function Sr(e) {
+  const t = be(e);
+  if (t) return { ok: !1, issues: [t] };
+  const r = Re(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
+      }))
+    };
+  const i = Oe(e, r.tokens);
+  if (i) return { ok: !1, issues: [i] };
+  const s = ve();
+  s.input = r.tokens;
+  const a = 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)
+      }))
+    };
+  try {
+    return { ok: !0, rule: { ...Ce().visit(a), raw: e } };
+  } catch (o) {
+    return {
+      ok: !1,
+      issues: [{ message: o instanceof Error ? o.message : "Invalid Datalog rule" }]
+    };
+  }
+}
+function Os(e) {
+  const t = Sr(e);
+  return t.ok ? { ok: !0, vocabulary: Vi(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();
+  r.input = t.tokens;
+  const i = r.term();
+  if (!(r.errors.length > 0 || !r.atEndOfInput))
+    return Ce().visit(i);
+}
+function He(e) {
+  const t = Sn(e), r = (t == null ? void 0 : t.type) === "iri" && !t.prefixed && !We(t.value);
+  return t && !r ? t : void 0;
+}
+function xs(e, t) {
+  const r = He(e), i = He(t);
+  if (!(!r || !i))
+    return tr(r, i);
+}
+function vs(e) {
+  const t = Sr(e);
+  if (!t.ok)
+    return {
+      valid: !1,
+      error: t.issues.map(({ message: s }) => s).join("; ") || "Invalid Datalog rule"
+    };
+  const r = An(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) {
+  try {
+    const r = Xe(e), i = Xe(t);
+    return r.head.length !== i.head.length ? !1 : Qe(e) === Qe(t);
+  } catch {
+    return !1;
+  }
+}
+function Qe(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,
+  Dt as EXISTS,
+  vi as ExpandedDatalogParser,
+  se as FALSE,
+  $t 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,
+  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,
+  Dn 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,
+  $n 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
+};