@traqula/rules-sparql-1-2 0.0.3 → 0.0.5

package/lib/index.cjs

@@ -34,16 +34,16 @@ __export(grammar_exports2, {
   annotationBlock: () => annotationBlock,
   annotationBlockPath: () => annotationBlockPath,
   annotationPath: () => annotationPath,
+  buildInHasLang: () => buildInHasLang2,
+  buildInHasLangDir: () => buildInHasLangDir2,
+  buildInIsTriple: () => buildInIsTriple,
+  buildInLangDir: () => buildInLangDir2,
+  buildInLangStrDir: () => buildInLangStrDir,
+  buildInObject: () => buildInObject,
+  buildInPredicate: () => buildInPredicate,
+  buildInSubject: () => buildInSubject,
+  buildInTriple: () => buildInTriple,
   builtInCall: () => builtInCall2,
-  builtinHasLang: () => builtinHasLang2,
-  builtinHasLangDir: () => builtinHasLangDir2,
-  builtinIsTriple: () => builtinIsTriple,
-  builtinLangDir: () => builtinLangDir2,
-  builtinLangStrDir: () => builtinLangStrDir,
-  builtinObject: () => builtinObject,
-  builtinPredicate: () => builtinPredicate,
-  builtinSubject: () => builtinSubject,
-  builtinTriple: () => builtinTriple,
   dataBlockValue: () => dataBlockValue2,
   exprTripleTerm: () => exprTripleTerm,
   exprTripleTermObject: () => exprTripleTermObject,
@@ -260,6 +260,7 @@ __export(grammar_exports, {
   quads: () => quads,
   quadsNotTriples: () => quadsNotTriples,
   query: () => query,
+  queryOrUpdate: () => queryOrUpdate,
   queryUnit: () => queryUnit,
   rdfLiteral: () => rdfLiteral,
   regexExpression: () => regexExpression,
@@ -308,7 +309,7 @@ __export(lexer_exports, {
   ask: () => ask,
   baseDecl: () => baseDecl,
   bind: () => bind,
-  builtIn: () => BuildinCalls_exports,
+  builtIn: () => BuiltInCalls_exports,
   by: () => by,
   clear: () => clear,
   construct: () => construct,
@@ -345,7 +346,7 @@ __export(lexer_exports, {
   separator: () => separator,
   service: () => service,
   silent: () => silent,
-  sparql11Tokens: () => sparql11Tokens,
+  sparql11LexerBuilder: () => sparql11LexerBuilder,
   symbols: () => symbols_exports,
   terminals: () => terminals_exports,
   to: () => to,
@@ -357,10 +358,10 @@ __export(lexer_exports, {
   where: () => where
 });
 
-// ../rules-sparql-1-1/lib/lexer/BuildinCalls.ts
-var BuildinCalls_exports = {};
-__export(BuildinCalls_exports, {
-  BuildInCalls: () => BuildInCalls,
+// ../rules-sparql-1-1/lib/lexer/BuiltInCalls.ts
+var BuiltInCalls_exports = {};
+__export(BuiltInCalls_exports, {
+  BuiltInCalls: () => BuiltInCalls,
   abs: () => abs,
   allBuiltInCalls: () => allBuiltInCalls,
   avg: () => avg,
@@ -753,10 +754,10 @@ var coreJsData = root_default["__core-js_shared__"];
 var coreJsData_default = coreJsData;
 
 // ../../node_modules/lodash-es/_isMasked.js
-var maskSrcKey = function() {
+var maskSrcKey = (function() {
   var uid = /[^.]+$/.exec(coreJsData_default && coreJsData_default.keys && coreJsData_default.keys.IE_PROTO || "");
   return uid ? "Symbol(src)_1." + uid : "";
-}();
+})();
 function isMasked(func) {
   return !!maskSrcKey && maskSrcKey in func;
 }
@@ -818,7 +819,7 @@ var WeakMap_default = WeakMap;
 
 // ../../node_modules/lodash-es/_baseCreate.js
 var objectCreate = Object.create;
-var baseCreate = /* @__PURE__ */ function() {
+var baseCreate = /* @__PURE__ */ (function() {
   function object3() {
   }
   return function(proto) {
@@ -833,7 +834,7 @@ var baseCreate = /* @__PURE__ */ function() {
     object3.prototype = void 0;
     return result;
   };
-}();
+})();
 var baseCreate_default = baseCreate;
 
 // ../../node_modules/lodash-es/_apply.js
@@ -898,14 +899,14 @@ function constant(value) {
 var constant_default = constant;
 
 // ../../node_modules/lodash-es/_defineProperty.js
-var defineProperty = function() {
+var defineProperty = (function() {
   try {
     var func = getNative_default(Object, "defineProperty");
     func({}, "", {});
     return func;
   } catch (e) {
   }
-}();
+})();
 var defineProperty_default = defineProperty;
 
 // ../../node_modules/lodash-es/_baseSetToString.js
@@ -1143,9 +1144,9 @@ var baseIsArguments_default = baseIsArguments;
 var objectProto6 = Object.prototype;
 var hasOwnProperty4 = objectProto6.hasOwnProperty;
 var propertyIsEnumerable = objectProto6.propertyIsEnumerable;
-var isArguments = baseIsArguments_default(/* @__PURE__ */ function() {
+var isArguments = baseIsArguments_default(/* @__PURE__ */ (function() {
   return arguments;
-}()) ? baseIsArguments_default : function(value) {
+})()) ? baseIsArguments_default : function(value) {
   return isObjectLike_default(value) && hasOwnProperty4.call(value, "callee") && !propertyIsEnumerable.call(value, "callee");
 };
 var isArguments_default = isArguments;
@@ -1211,7 +1212,7 @@ var freeExports2 = typeof exports == "object" && exports && !exports.nodeType &&
 var freeModule2 = freeExports2 && typeof module == "object" && module && !module.nodeType && module;
 var moduleExports2 = freeModule2 && freeModule2.exports === freeExports2;
 var freeProcess = moduleExports2 && freeGlobal_default.process;
-var nodeUtil = function() {
+var nodeUtil = (function() {
   try {
     var types = freeModule2 && freeModule2.require && freeModule2.require("util").types;
     if (types) {
@@ -1220,7 +1221,7 @@ var nodeUtil = function() {
     return freeProcess && freeProcess.binding && freeProcess.binding("util");
   } catch (e) {
   }
-}();
+})();
 var nodeUtil_default = nodeUtil;
 
 // ../../node_modules/lodash-es/isTypedArray.js
@@ -9765,6 +9766,7 @@ applyMixins(Parser, [
 
 // ../core/lib/lexer-builder/LexerBuilder.ts
 var LexerBuilder = class _LexerBuilder {
+  tokens;
   static create(starter) {
     return new _LexerBuilder(starter);
   }
@@ -9922,71 +9924,71 @@ var Transformer = class {
   }
 };
 
-// ../rules-sparql-1-1/lib/lexer/BuildinCalls.ts
-var BuildInCalls = /* @__PURE__ */ ((BuildInCalls2) => {
-  BuildInCalls2["Str"] = "builtInStr";
-  BuildInCalls2["Lang"] = "builtInLang";
-  BuildInCalls2["Langmatches"] = "builtInLangmatches";
-  BuildInCalls2["Datatype"] = "builtInDatatype";
-  BuildInCalls2["Bound"] = "builtInBound";
-  BuildInCalls2["Iri"] = "builtInIri";
-  BuildInCalls2["Uri"] = "builtInUri";
-  BuildInCalls2["Bnode"] = "builtInBnode";
-  BuildInCalls2["Rand"] = "builtInRand";
-  BuildInCalls2["Abs"] = "builtInAbs";
-  BuildInCalls2["Ceil"] = "builtInCeil";
-  BuildInCalls2["Floor"] = "builtInFloor";
-  BuildInCalls2["Round"] = "builtInRound";
-  BuildInCalls2["Concat"] = "builtInConcat";
-  BuildInCalls2["Strlen"] = "builtInStrlen";
-  BuildInCalls2["Ucase"] = "builtInUcase";
-  BuildInCalls2["Lcase"] = "builtInLcase";
-  BuildInCalls2["Encode_for_uri"] = "builtInEncode_for_uri";
-  BuildInCalls2["Contains"] = "builtInContains";
-  BuildInCalls2["Strstarts"] = "builtInStrstarts";
-  BuildInCalls2["Strends"] = "builtInStrends";
-  BuildInCalls2["Strbefore"] = "builtInStrbefore";
-  BuildInCalls2["Strafter"] = "builtInStrafter";
-  BuildInCalls2["Year"] = "builtInYear";
-  BuildInCalls2["Month"] = "builtInMonth";
-  BuildInCalls2["Day"] = "builtInDay";
-  BuildInCalls2["Hours"] = "builtInHours";
-  BuildInCalls2["Minutes"] = "builtInMinutes";
-  BuildInCalls2["Seconds"] = "builtInSeconds";
-  BuildInCalls2["Timezone"] = "builtInTimezone";
-  BuildInCalls2["Tz"] = "builtInTz";
-  BuildInCalls2["Now"] = "builtInNow";
-  BuildInCalls2["Uuid"] = "builtInUuid";
-  BuildInCalls2["Struuid"] = "builtInStruuid";
-  BuildInCalls2["Md5"] = "builtInMd5";
-  BuildInCalls2["Sha1"] = "builtInSha1";
-  BuildInCalls2["Sha256"] = "builtInSha256";
-  BuildInCalls2["Sha384"] = "builtInSha384";
-  BuildInCalls2["Sha512"] = "builtInSha512";
-  BuildInCalls2["Coalesce"] = "builtInCoalesce";
-  BuildInCalls2["If"] = "builtInIf";
-  BuildInCalls2["Strlang"] = "builtInStrlang";
-  BuildInCalls2["Strdt"] = "builtInStrdt";
-  BuildInCalls2["Sameterm"] = "builtInSameterm";
-  BuildInCalls2["Isiri"] = "builtInIsiri";
-  BuildInCalls2["Isuri"] = "builtInIsuri";
-  BuildInCalls2["Isblank"] = "builtInIsblank";
-  BuildInCalls2["Isliteral"] = "builtInIsliteral";
-  BuildInCalls2["Isnumeric"] = "builtInIsnumeric";
-  BuildInCalls2["Regex"] = "builtInRegex";
-  BuildInCalls2["Substr"] = "builtInSubstr";
-  BuildInCalls2["Replace"] = "builtInReplace";
-  BuildInCalls2["Exists"] = "builtInExists";
-  BuildInCalls2["Notexists"] = "builtInNotexists";
-  BuildInCalls2["Count"] = "builtInCount";
-  BuildInCalls2["Sum"] = "builtInSum";
-  BuildInCalls2["Min"] = "builtInMin";
-  BuildInCalls2["Max"] = "builtInMax";
-  BuildInCalls2["Avg"] = "builtInAvg";
-  BuildInCalls2["Sample"] = "builtInSample";
-  BuildInCalls2["Group_concat"] = "builtInGroup_concat";
-  return BuildInCalls2;
-})(BuildInCalls || {});
+// ../rules-sparql-1-1/lib/lexer/BuiltInCalls.ts
+var BuiltInCalls = /* @__PURE__ */ ((BuiltInCalls2) => {
+  BuiltInCalls2["Str"] = "builtInStr";
+  BuiltInCalls2["Lang"] = "builtInLang";
+  BuiltInCalls2["Langmatches"] = "builtInLangmatches";
+  BuiltInCalls2["Datatype"] = "builtInDatatype";
+  BuiltInCalls2["Bound"] = "builtInBound";
+  BuiltInCalls2["Iri"] = "builtInIri";
+  BuiltInCalls2["Uri"] = "builtInUri";
+  BuiltInCalls2["Bnode"] = "builtInBnode";
+  BuiltInCalls2["Rand"] = "builtInRand";
+  BuiltInCalls2["Abs"] = "builtInAbs";
+  BuiltInCalls2["Ceil"] = "builtInCeil";
+  BuiltInCalls2["Floor"] = "builtInFloor";
+  BuiltInCalls2["Round"] = "builtInRound";
+  BuiltInCalls2["Concat"] = "builtInConcat";
+  BuiltInCalls2["Strlen"] = "builtInStrlen";
+  BuiltInCalls2["Ucase"] = "builtInUcase";
+  BuiltInCalls2["Lcase"] = "builtInLcase";
+  BuiltInCalls2["Encode_for_uri"] = "builtInEncode_for_uri";
+  BuiltInCalls2["Contains"] = "builtInContains";
+  BuiltInCalls2["Strstarts"] = "builtInStrstarts";
+  BuiltInCalls2["Strends"] = "builtInStrends";
+  BuiltInCalls2["Strbefore"] = "builtInStrbefore";
+  BuiltInCalls2["Strafter"] = "builtInStrafter";
+  BuiltInCalls2["Year"] = "builtInYear";
+  BuiltInCalls2["Month"] = "builtInMonth";
+  BuiltInCalls2["Day"] = "builtInDay";
+  BuiltInCalls2["Hours"] = "builtInHours";
+  BuiltInCalls2["Minutes"] = "builtInMinutes";
+  BuiltInCalls2["Seconds"] = "builtInSeconds";
+  BuiltInCalls2["Timezone"] = "builtInTimezone";
+  BuiltInCalls2["Tz"] = "builtInTz";
+  BuiltInCalls2["Now"] = "builtInNow";
+  BuiltInCalls2["Uuid"] = "builtInUuid";
+  BuiltInCalls2["Struuid"] = "builtInStruuid";
+  BuiltInCalls2["Md5"] = "builtInMd5";
+  BuiltInCalls2["Sha1"] = "builtInSha1";
+  BuiltInCalls2["Sha256"] = "builtInSha256";
+  BuiltInCalls2["Sha384"] = "builtInSha384";
+  BuiltInCalls2["Sha512"] = "builtInSha512";
+  BuiltInCalls2["Coalesce"] = "builtInCoalesce";
+  BuiltInCalls2["If"] = "builtInIf";
+  BuiltInCalls2["Strlang"] = "builtInStrlang";
+  BuiltInCalls2["Strdt"] = "builtInStrdt";
+  BuiltInCalls2["Sameterm"] = "builtInSameterm";
+  BuiltInCalls2["Isiri"] = "builtInIsiri";
+  BuiltInCalls2["Isuri"] = "builtInIsuri";
+  BuiltInCalls2["Isblank"] = "builtInIsblank";
+  BuiltInCalls2["Isliteral"] = "builtInIsliteral";
+  BuiltInCalls2["Isnumeric"] = "builtInIsnumeric";
+  BuiltInCalls2["Regex"] = "builtInRegex";
+  BuiltInCalls2["Substr"] = "builtInSubstr";
+  BuiltInCalls2["Replace"] = "builtInReplace";
+  BuiltInCalls2["Exists"] = "builtInExists";
+  BuiltInCalls2["Notexists"] = "builtInNotexists";
+  BuiltInCalls2["Count"] = "builtInCount";
+  BuiltInCalls2["Sum"] = "builtInSum";
+  BuiltInCalls2["Min"] = "builtInMin";
+  BuiltInCalls2["Max"] = "builtInMax";
+  BuiltInCalls2["Avg"] = "builtInAvg";
+  BuiltInCalls2["Sample"] = "builtInSample";
+  BuiltInCalls2["Group_concat"] = "builtInGroup_concat";
+  return BuiltInCalls2;
+})(BuiltInCalls || {});
 function capitalize(string2) {
   return string2.charAt(0).toUpperCase() + string2.slice(1);
 }
@@ -10490,7 +10492,7 @@ var allBaseTokens = LexerBuilder.create().add(
   notIn,
   separator
 );
-var sparql11Tokens = LexerBuilder.create(allTerminals).merge(allBaseTokens).merge(allBuiltInCalls).merge(allGraphTokens).merge(allSymbols).moveBefore(datatype, dataClause).moveAfter(avg, a).moveBefore(a, graphAll).moveAfter(groupConcat, groupByGroup);
+var sparql11LexerBuilder = LexerBuilder.create(allTerminals).merge(allBaseTokens).merge(allBuiltInCalls).merge(allGraphTokens).merge(allSymbols).moveBefore(datatype, dataClause).moveAfter(avg, a).moveBefore(a, graphAll).moveAfter(groupConcat, groupByGroup);
 
 // ../rules-sparql-1-1/lib/factoryMixins/ContextFactory.ts
 var nodeType = "contextDef";
@@ -10935,10 +10937,7 @@ function SolutionModifiersFactoryMixin(Base) {
 var nodeType8 = "term";
 function TermFactoryMixin(Base) {
   return class TermFactory extends Base {
-    constructor() {
-      super(...arguments);
-      this.__blankNodeCounter = 0;
-    }
+    __blankNodeCounter = 0;
     resetBlankNodeCounter() {
       this.__blankNodeCounter = 0;
     }
@@ -11441,7 +11440,7 @@ function stringEscapedLexical(str2) {
 var rdfLiteral = {
   name: "rdfLiteral",
   impl: ({ ACTION, SUBRULE1, CONSUME, OPTION, OR }) => (C) => {
-    const value = SUBRULE1(string, void 0);
+    const value = SUBRULE1(string);
     return OPTION(() => OR([
       { ALT: () => {
         const lang2 = CONSUME(terminals_exports.langTag);
@@ -11453,7 +11452,7 @@ var rdfLiteral = {
       } },
       { ALT: () => {
         CONSUME(symbols_exports.hathat);
-        const iriVal = SUBRULE1(iri2, void 0);
+        const iriVal = SUBRULE1(iri2);
         return ACTION(() => C.factory.literalTerm(
           C.factory.sourceLocation(value, iriVal),
           value.value,
@@ -11469,7 +11468,7 @@ var rdfLiteral = {
         factory.printFilter(ast, () => PRINT("@", ast.langOrIri));
       } else {
         factory.printFilter(ast, () => PRINT("^^"));
-        SUBRULE(iri2, ast.langOrIri, void 0);
+        SUBRULE(iri2, ast.langOrIri);
       }
     }
   }
@@ -11477,9 +11476,9 @@ var rdfLiteral = {
 var numericLiteral = {
   name: "numericLiteral",
   impl: ({ SUBRULE, OR }) => () => OR([
-    { ALT: () => SUBRULE(numericLiteralUnsigned, void 0) },
-    { ALT: () => SUBRULE(numericLiteralPositive, void 0) },
-    { ALT: () => SUBRULE(numericLiteralNegative, void 0) }
+    { ALT: () => SUBRULE(numericLiteralUnsigned) },
+    { ALT: () => SUBRULE(numericLiteralPositive) },
+    { ALT: () => SUBRULE(numericLiteralNegative) }
   ])
 };
 var numericLiteralUnsigned = {
@@ -11587,10 +11586,10 @@ var string = {
 var iri2 = {
   name: "iri",
   impl: ({ SUBRULE, OR }) => () => OR([
-    { ALT: () => SUBRULE(iriFull, void 0) },
-    { ALT: () => SUBRULE(prefixedName, void 0) }
+    { ALT: () => SUBRULE(iriFull) },
+    { ALT: () => SUBRULE(prefixedName) }
   ]),
-  gImpl: ({ SUBRULE }) => (ast, { factory: F3 }) => F3.isTermNamedPrefixed(ast) ? SUBRULE(prefixedName, ast, void 0) : SUBRULE(iriFull, ast, void 0)
+  gImpl: ({ SUBRULE }) => (ast, { factory: F3 }) => F3.isTermNamedPrefixed(ast) ? SUBRULE(prefixedName, ast) : SUBRULE(iriFull, ast)
 };
 var iriFull = {
   name: "iriFull",
@@ -11654,93 +11653,25 @@ var verbA = {
   }
 };
 
-// ../rules-sparql-1-1/lib/grammar/dataSetClause.ts
-function datasetClauseUsing(name, token) {
-  return {
-    name,
-    impl: ({ ACTION, SUBRULE, CONSUME, OR }) => (C) => {
-      const start = CONSUME(token);
-      return OR([
-        { ALT: () => {
-          const iri3 = SUBRULE(defaultGraphClause, void 0);
-          return ACTION(() => C.factory.wrap({ clauseType: "default", value: iri3 }, C.factory.sourceLocation(start, iri3)));
-        } },
-        { ALT: () => {
-          const namedClause = SUBRULE(namedGraphClause, void 0);
-          return ACTION(() => C.factory.wrap({
-            clauseType: "named",
-            value: namedClause.val
-          }, C.factory.sourceLocation(start, namedClause)));
-        } }
-      ]);
-    }
-  };
-}
-var datasetClause = datasetClauseUsing("datasetClause", from);
-var defaultGraphClause = {
-  name: "defaultGraphClause",
-  impl: ({ SUBRULE }) => () => SUBRULE(sourceSelector, void 0)
-};
-var usingClause2 = datasetClauseUsing("usingClause", usingClause);
-function datasetClauseUsingStar(name, subRule, fromUsing) {
-  return {
-    name,
-    impl: ({ ACTION, MANY, SUBRULE }) => (C) => {
-      const clauses = [];
-      MANY(() => {
-        const clause = SUBRULE(subRule, void 0);
-        clauses.push(clause);
-      });
-      return ACTION(() => C.factory.datasetClauses(
-        clauses.map((clause) => clause.val),
-        C.factory.sourceLocation(...clauses)
-      ));
-    },
-    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
-      for (const clause of ast.clauses) {
-        F3.printFilter(ast, () => PRINT_WORD(fromUsing));
-        if (clause.clauseType === "named") {
-          F3.printFilter(ast, () => PRINT_WORD("NAMED"));
-        }
-        SUBRULE(iri2, clause.value, void 0);
-      }
-    }
-  };
-}
-var datasetClauseStar = datasetClauseUsingStar("datasetClauses", datasetClause, "FROM");
-var usingClauseStar = datasetClauseUsingStar("usingClauses", usingClause2, "USING");
-var namedGraphClause = {
-  name: "namedGraphClause",
-  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
-    const named2 = CONSUME(graph_exports.named);
-    const iri3 = SUBRULE(sourceSelector, void 0);
-    return ACTION(() => C.factory.wrap(iri3, C.factory.sourceLocation(named2, iri3)));
-  }
-};
-var sourceSelector = {
-  name: "sourceSelector",
-  impl: ({ SUBRULE }) => () => SUBRULE(iri2, void 0)
-};
-
 // ../rules-sparql-1-1/lib/grammar/general.ts
 var prologue = {
   name: "prologue",
   impl: ({ SUBRULE, MANY, OR }) => () => {
     const result = [];
     MANY(() => OR([
-      { ALT: () => result.push(SUBRULE(baseDecl2, void 0)) },
+      { ALT: () => result.push(SUBRULE(baseDecl2)) },
       // TODO: the [spec](https://www.w3.org/TR/sparql11-query/#iriRefs) says you cannot redefine prefixes.
       //  We might need to check this.
-      { ALT: () => result.push(SUBRULE(prefixDecl2, void 0)) }
+      { ALT: () => result.push(SUBRULE(prefixDecl2)) }
     ]));
     return result;
   },
   gImpl: ({ SUBRULE }) => (ast, { factory: F3 }) => {
     for (const context of ast) {
       if (F3.isContextDefinitionBase(context)) {
-        SUBRULE(baseDecl2, context, void 0);
+        SUBRULE(baseDecl2, context);
       } else if (F3.isContextDefinitionPrefix(context)) {
-        SUBRULE(prefixDecl2, context, void 0);
+        SUBRULE(prefixDecl2, context);
       }
     }
   }
@@ -11749,12 +11680,12 @@ var baseDecl2 = {
   name: "baseDecl",
   impl: ({ ACTION, CONSUME, SUBRULE }) => (C) => {
     const base = CONSUME(baseDecl);
-    const val = SUBRULE(iriFull, void 0);
+    const val = SUBRULE(iriFull);
     return ACTION(() => C.factory.contextDefinitionBase(C.factory.sourceLocation(base, val), val));
   },
   gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
     F3.printFilter(ast, () => PRINT_WORD("BASE"));
-    SUBRULE(iri2, ast.value, void 0);
+    SUBRULE(iri2, ast.value);
   }
 };
 var prefixDecl2 = {
@@ -11762,41 +11693,41 @@ var prefixDecl2 = {
   impl: ({ ACTION, CONSUME, SUBRULE }) => (C) => {
     const prefix = CONSUME(prefixDecl);
     const name = CONSUME(terminals_exports.pNameNs).image.slice(0, -1);
-    const value = SUBRULE(iriFull, void 0);
+    const value = SUBRULE(iriFull);
     return ACTION(() => C.factory.contextDefinitionPrefix(C.factory.sourceLocation(prefix, value), name, value));
   },
   gImpl: ({ SUBRULE, PRINT_WORDS }) => (ast, { factory: F3 }) => {
     F3.printFilter(ast, () => {
       PRINT_WORDS("PREFIX", `${ast.key}:`);
     });
-    SUBRULE(iri2, ast.value, void 0);
+    SUBRULE(iri2, ast.value);
   }
 };
 var verb = {
   name: "verb",
   impl: ({ SUBRULE, OR }) => () => OR([
-    { ALT: () => SUBRULE(varOrIri, void 0) },
-    { ALT: () => SUBRULE(verbA, void 0) }
+    { ALT: () => SUBRULE(varOrIri) },
+    { ALT: () => SUBRULE(verbA) }
   ])
 };
 var varOrTerm = {
   name: "varOrTerm",
   impl: ({ SUBRULE, OR }) => (C) => OR([
-    { GATE: () => C.parseMode.has("canParseVars"), ALT: () => SUBRULE(var_, void 0) },
-    { ALT: () => SUBRULE(graphTerm, void 0) }
+    { GATE: () => C.parseMode.has("canParseVars"), ALT: () => SUBRULE(var_) },
+    { ALT: () => SUBRULE(graphTerm) }
   ]),
   gImpl: ({ SUBRULE }) => (ast, { factory: F3 }) => {
     if (F3.isTermVariable(ast)) {
-      return SUBRULE(var_, ast, void 0);
+      return SUBRULE(var_, ast);
     }
-    return SUBRULE(graphTerm, ast, void 0);
+    return SUBRULE(graphTerm, ast);
   }
 };
 var varOrIri = {
   name: "varOrIri",
   impl: ({ SUBRULE, OR }) => (C) => OR([
-    { GATE: () => C.parseMode.has("canParseVars"), ALT: () => SUBRULE(var_, void 0) },
-    { ALT: () => SUBRULE(iri2, void 0) }
+    { GATE: () => C.parseMode.has("canParseVars"), ALT: () => SUBRULE(var_) },
+    { ALT: () => SUBRULE(iri2) }
   ])
 };
 var var_ = {
@@ -11815,11 +11746,11 @@ var var_ = {
 var graphTerm = {
   name: "graphTerm",
   impl: ({ ACTION, SUBRULE, CONSUME, OR }) => (C) => OR([
-    { ALT: () => SUBRULE(iri2, void 0) },
-    { ALT: () => SUBRULE(rdfLiteral, void 0) },
-    { ALT: () => SUBRULE(numericLiteral, void 0) },
-    { ALT: () => SUBRULE(booleanLiteral, void 0) },
-    { GATE: () => C.parseMode.has("canCreateBlankNodes"), ALT: () => SUBRULE(blankNode, void 0) },
+    { ALT: () => SUBRULE(iri2) },
+    { ALT: () => SUBRULE(rdfLiteral) },
+    { ALT: () => SUBRULE(numericLiteral) },
+    { ALT: () => SUBRULE(booleanLiteral) },
+    { GATE: () => C.parseMode.has("canCreateBlankNodes"), ALT: () => SUBRULE(blankNode) },
     { ALT: () => {
       const tokenNil = CONSUME(terminals_exports.nil);
       return ACTION(() => C.factory.namedNode(C.factory.sourceLocation(tokenNil), "http://www.w3.org/1999/02/22-rdf-syntax-ns#nil" /* NIL */));
@@ -11827,1275 +11758,1344 @@ var graphTerm = {
   ]),
   gImpl: ({ SUBRULE }) => (ast, { factory: F3 }) => {
     if (F3.isTermNamed(ast)) {
-      SUBRULE(iri2, ast, void 0);
+      SUBRULE(iri2, ast);
     } else if (F3.isTermLiteral(ast)) {
-      SUBRULE(rdfLiteral, ast, void 0);
+      SUBRULE(rdfLiteral, ast);
     } else if (F3.isTermBlank(ast)) {
-      SUBRULE(blankNode, ast, void 0);
+      SUBRULE(blankNode, ast);
     }
   }
 };
 
-// ../rules-sparql-1-1/lib/grammar/propertyPaths.ts
-var path = {
-  name: "path",
-  impl: ({ SUBRULE }) => () => SUBRULE(pathAlternative, void 0)
-};
-var pathGenerator = {
-  name: "path",
-  gImpl: ({ PRINT, SUBRULE }) => (ast, { factory: F3 }, braces = true) => {
-    if (F3.isTerm(ast) && F3.isTermNamed(ast)) {
-      SUBRULE(iri2, ast, void 0);
-    } else {
-      F3.printFilter(ast, () => braces && PRINT("("));
-      switch (ast.subType) {
-        case "|":
-        case "/": {
-          const [head2, ...tail] = ast.items;
-          SUBRULE(pathGenerator, head2, braces);
-          for (const val of tail) {
-            F3.printFilter(ast, () => PRINT(ast.subType));
-            SUBRULE(pathGenerator, val, braces);
-          }
-          break;
-        }
-        case "^":
-          F3.printFilter(ast, () => PRINT("^"));
-          SUBRULE(pathGenerator, ast.items[0], braces);
-          break;
-        case "?":
-        case "*":
-        case "+":
-          SUBRULE(pathGenerator, ast.items[0], braces);
-          F3.printFilter(ast, () => PRINT(ast.subType));
-          break;
-        case "!":
-          F3.printFilter(ast, () => PRINT("!"));
-          F3.printFilter(ast, () => PRINT("("));
-          SUBRULE(pathGenerator, ast.items[0], false);
-          F3.printFilter(ast, () => PRINT(")"));
-          break;
-      }
-      F3.printFilter(ast, () => braces && PRINT(")"));
+// ../rules-sparql-1-1/lib/grammar/dataSetClause.ts
+function datasetClauseUsing(name, token) {
+  return {
+    name,
+    impl: ({ ACTION, SUBRULE, CONSUME, OR }) => (C) => {
+      const start = CONSUME(token);
+      return OR([
+        { ALT: () => {
+          const iri3 = SUBRULE(defaultGraphClause);
+          return ACTION(() => C.factory.wrap({ clauseType: "default", value: iri3 }, C.factory.sourceLocation(start, iri3)));
+        } },
+        { ALT: () => {
+          const namedClause = SUBRULE(namedGraphClause);
+          return ACTION(() => C.factory.wrap({
+            clauseType: "named",
+            value: namedClause.val
+          }, C.factory.sourceLocation(start, namedClause)));
+        } }
+      ]);
     }
-  }
+  };
+}
+var datasetClause = datasetClauseUsing("datasetClause", from);
+var defaultGraphClause = {
+  name: "defaultGraphClause",
+  impl: ({ SUBRULE }) => () => SUBRULE(sourceSelector)
 };
-function pathChainHelper(name, SEP, subType, subRule) {
+var usingClause2 = datasetClauseUsing("usingClause", usingClause);
+function datasetClauseUsingStar(name, subRule, fromUsing) {
   return {
     name,
-    impl: ({ ACTION, CONSUME, SUBRULE1, SUBRULE2, MANY }) => (C) => {
-      const head2 = SUBRULE1(subRule, void 0);
-      let tailEnd = head2;
-      const tail = [];
+    impl: ({ ACTION, MANY, SUBRULE }) => (C) => {
+      const clauses = [];
       MANY(() => {
-        CONSUME(SEP);
-        tailEnd = SUBRULE2(subRule, void 0);
-        tail.push(tailEnd);
+        const clause = SUBRULE(subRule);
+        clauses.push(clause);
       });
-      return ACTION(() => tail.length === 0 ? head2 : C.factory.path(subType, [head2, ...tail], C.factory.sourceLocation(head2, tailEnd)));
+      return ACTION(() => C.factory.datasetClauses(
+        clauses.map((clause) => clause.val),
+        C.factory.sourceLocation(...clauses)
+      ));
+    },
+    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+      for (const clause of ast.clauses) {
+        F3.printFilter(ast, () => PRINT_WORD(fromUsing));
+        if (clause.clauseType === "named") {
+          F3.printFilter(ast, () => PRINT_WORD("NAMED"));
+        }
+        SUBRULE(iri2, clause.value);
+      }
     }
   };
 }
-var pathEltOrInverse = {
-  name: "pathEltOrInverse",
-  impl: ({ ACTION, CONSUME, SUBRULE1, SUBRULE2, OR }) => (C) => OR([
-    { ALT: () => SUBRULE1(pathElt, void 0) },
-    { ALT: () => {
-      const hat2 = CONSUME(symbols_exports.hat);
-      const item = SUBRULE2(pathElt, void 0);
-      return ACTION(() => C.factory.path("^", [item], C.factory.sourceLocation(hat2, item)));
-    } }
-  ])
-};
-var pathSequence = pathChainHelper("pathSequence", symbols_exports.slash, "/", pathEltOrInverse);
-var pathAlternative = pathChainHelper("pathAlternative", symbols_exports.pipe, "|", pathSequence);
-var pathElt = {
-  name: "pathElt",
-  impl: ({ ACTION, SUBRULE, OPTION }) => (C) => {
-    const item = SUBRULE(pathPrimary, void 0);
-    const modification = OPTION(() => SUBRULE(pathMod, void 0));
-    return ACTION(() => modification === void 0 ? item : C.factory.path(modification.image, [item], C.factory.sourceLocation(item, modification)));
-  }
-};
-var pathMod = {
-  name: "pathMod",
-  impl: ({ CONSUME, OR }) => () => OR([
-    { ALT: () => CONSUME(symbols_exports.question) },
-    { ALT: () => CONSUME(symbols_exports.star) },
-    { ALT: () => CONSUME(symbols_exports.opPlus) }
-  ])
-};
-var pathPrimary = {
-  name: "pathPrimary",
-  impl: ({ SUBRULE, CONSUME, OR }) => () => OR([
-    { ALT: () => SUBRULE(iri2, void 0) },
-    { ALT: () => SUBRULE(verbA, void 0) },
-    { ALT: () => SUBRULE(pathNegatedPropertySet, void 0) },
-    { ALT: () => {
-      CONSUME(symbols_exports.LParen);
-      const resRecursive = SUBRULE(path, void 0);
-      CONSUME(symbols_exports.RParen);
-      return resRecursive;
-    } }
-  ])
-};
-var pathNegatedPropertySet = {
-  name: "pathNegatedPropertySet",
-  impl: ({ ACTION, CONSUME, SUBRULE1, SUBRULE2, SUBRULE3, OR, MANY }) => (C) => {
-    const exclamation2 = CONSUME(symbols_exports.exclamation);
-    return OR([
-      { ALT: () => {
-        const noAlternative = SUBRULE1(pathOneInPropertySet, void 0);
-        return ACTION(() => C.factory.path("!", [noAlternative], C.factory.sourceLocation(exclamation2, noAlternative)));
-      } },
-      { ALT: () => {
-        const open = CONSUME(symbols_exports.LParen);
-        const head2 = SUBRULE2(pathOneInPropertySet, void 0);
-        const tail = [];
-        MANY(() => {
-          CONSUME(symbols_exports.pipe);
-          const item = SUBRULE3(pathOneInPropertySet, void 0);
-          tail.push(item);
-        });
-        const close = CONSUME(symbols_exports.RParen);
-        return ACTION(() => {
-          const F3 = C.factory;
-          if (tail.length === 0) {
-            return F3.path("!", [head2], F3.sourceLocation(exclamation2, close));
-          }
-          return F3.path(
-            "!",
-            [F3.path("|", [head2, ...tail], F3.sourceLocation(open, close))],
-            F3.sourceLocation(exclamation2, close)
-          );
-        });
-      } }
-    ]);
+var datasetClauseStar = datasetClauseUsingStar("datasetClauses", datasetClause, "FROM");
+var usingClauseStar = datasetClauseUsingStar("usingClauses", usingClause2, "USING");
+var namedGraphClause = {
+  name: "namedGraphClause",
+  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
+    const named2 = CONSUME(graph_exports.named);
+    const iri3 = SUBRULE(sourceSelector);
+    return ACTION(() => C.factory.wrap(iri3, C.factory.sourceLocation(named2, iri3)));
   }
 };
-var pathOneInPropertySet = {
-  name: "pathOneInPropertySet",
-  impl: ({ ACTION, CONSUME, SUBRULE1, SUBRULE2, OR1, OR2 }) => (C) => OR1([
-    { ALT: () => SUBRULE1(iri2, void 0) },
-    { ALT: () => SUBRULE1(verbA, void 0) },
-    { ALT: () => {
-      const hat2 = CONSUME(symbols_exports.hat);
-      const item = OR2([
-        { ALT: () => SUBRULE2(iri2, void 0) },
-        { ALT: () => SUBRULE2(verbA, void 0) }
-      ]);
-      return ACTION(() => C.factory.path("^", [item], C.factory.sourceLocation(hat2, item)));
-    } }
-  ])
+var sourceSelector = {
+  name: "sourceSelector",
+  impl: ({ SUBRULE }) => () => SUBRULE(iri2)
 };
 
-// ../rules-sparql-1-1/lib/grammar/tripleBlock.ts
-function triplesDotSeperated(triplesSameSubjectSubrule) {
-  return ({ ACTION, AT_LEAST_ONE, SUBRULE, CONSUME, OPTION }) => (C) => {
-    const triples = [];
-    let parsedDot = true;
-    let dotToken;
-    AT_LEAST_ONE({
-      GATE: () => parsedDot,
-      DEF: () => {
-        parsedDot = false;
-        const template = SUBRULE(triplesSameSubjectSubrule, void 0);
-        ACTION(() => {
-          triples.push(...template);
-        });
-        OPTION(() => {
-          dotToken = CONSUME(symbols_exports.dot);
-          parsedDot = true;
-        });
-      }
-    });
-    return ACTION(() => C.factory.patternBgp(triples, C.factory.sourceLocation(...triples, dotToken)));
-  };
-}
-var triplesBlock = {
-  name: "triplesBlock",
-  impl: (implArgs) => (C) => triplesDotSeperated(triplesSameSubjectPath)(implArgs)(C, void 0),
-  gImpl: ({ SUBRULE, PRINT_WORD, HANDLE_LOC }) => (ast, { factory: F3 }) => {
-    for (const [index, triple] of ast.triples.entries()) {
-      HANDLE_LOC(triple, () => {
-        const nextTriple = ast.triples.at(index);
-        if (F3.isTripleCollection(triple)) {
-          SUBRULE(graphNodePath, triple, void 0);
-          F3.printFilter(triple, () => PRINT_WORD("."));
-        } else {
-          SUBRULE(graphNodePath, triple.subject, void 0);
-          if (F3.isTerm(triple.predicate) && F3.isTermVariable(triple.predicate)) {
-            SUBRULE(varOrTerm, triple.predicate, void 0);
-          } else {
-            SUBRULE(pathGenerator, triple.predicate, void 0);
-          }
-          SUBRULE(graphNodePath, triple.object, void 0);
-          if (nextTriple === void 0 || F3.isTripleCollection(nextTriple) || !F3.isSourceLocationNoMaterialize(nextTriple.subject.loc)) {
-            F3.printFilter(ast, () => PRINT_WORD("."));
-          } else if (F3.isSourceLocationNoMaterialize(nextTriple.predicate.loc)) {
-            F3.printFilter(ast, () => PRINT_WORD(","));
-          } else {
-            F3.printFilter(ast, () => PRINT_WORD(";"));
-          }
-        }
-      });
-    }
-  }
-};
-function triplesSameSubjectImpl(name, allowPaths) {
+// ../rules-sparql-1-1/lib/expressionHelpers.ts
+function funcExpr1(func) {
   return {
-    name,
-    impl: ({ ACTION, SUBRULE, OR }) => (C) => OR([
-      { ALT: () => {
-        const subject = SUBRULE(varOrTerm, void 0);
-        const res = SUBRULE(
-          allowPaths ? propertyListPathNotEmpty : propertyListNotEmpty,
-          { subject: ACTION(() => C.factory.dematerialized(subject)) }
-        );
-        return ACTION(() => {
-          if (res.length > 0) {
-            res[0].subject = subject;
-            res[0].loc = C.factory.sourceLocation(subject, res[0]);
-          }
-          return res;
-        });
-      } },
-      { ALT: () => {
-        const subjectNode = SUBRULE(allowPaths ? triplesNodePath : triplesNode, void 0);
-        const restNode = SUBRULE(
-          allowPaths ? propertyListPath : propertyList,
-          { subject: ACTION(() => C.factory.graphNodeIdentifier(subjectNode)) }
-        );
-        return ACTION(() => {
-          if (restNode.length === 0) {
-            return [subjectNode];
-          }
-          restNode[0].subject = subjectNode;
-          restNode[0].loc = C.factory.sourceLocation(subjectNode, restNode[0]);
-          return restNode;
-        });
-      } }
-    ])
+    name: unCapitalize(func.name),
+    impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
+      const operator = CONSUME(func);
+      CONSUME(symbols_exports.LParen);
+      const arg = SUBRULE(expression);
+      const close = CONSUME(symbols_exports.RParen);
+      return ACTION(() => C.factory.expressionOperation(operator.image, [arg], C.factory.sourceLocation(operator, close)));
+    }
   };
 }
-var triplesSameSubject = triplesSameSubjectImpl("triplesSameSubject", false);
-var triplesSameSubjectPath = triplesSameSubjectImpl("triplesSameSubjectPath", true);
-var triplesTemplate = {
-  name: "triplesTemplate",
-  impl: triplesDotSeperated(triplesSameSubject)
-};
-function propertyListImpl(name, allowPaths) {
+function funcExpr2(func) {
   return {
-    name,
-    impl: ({ SUBRULE, OPTION }) => (_, arg) => OPTION(() => SUBRULE(allowPaths ? propertyListPathNotEmpty : propertyListNotEmpty, arg)) ?? []
+    name: unCapitalize(func.name),
+    impl: ({ ACTION, CONSUME, SUBRULE1, SUBRULE2 }) => (C) => {
+      const operator = CONSUME(func);
+      CONSUME(symbols_exports.LParen);
+      const arg1 = SUBRULE1(expression);
+      CONSUME(symbols_exports.comma);
+      const arg2 = SUBRULE2(expression);
+      const close = CONSUME(symbols_exports.RParen);
+      return ACTION(() => C.factory.expressionOperation(operator.image, [arg1, arg2], C.factory.sourceLocation(operator, close)));
+    }
   };
 }
-var propertyList = propertyListImpl("propertyList", false);
-var propertyListPath = propertyListImpl("propertyListPath", true);
-function propertyListNotEmptyImplementation(name, allowPaths) {
+function funcExpr3(func) {
   return {
-    name,
-    impl: ({ ACTION, CONSUME, AT_LEAST_ONE, SUBRULE1, MANY2, OR1 }) => (_, arg) => {
-      const result = [];
-      let parsedSemi = true;
-      AT_LEAST_ONE({
-        GATE: () => parsedSemi,
-        DEF: () => {
-          parsedSemi = false;
-          const predicate = allowPaths ? OR1([
-            { ALT: () => SUBRULE1(verbPath, void 0) },
-            { ALT: () => SUBRULE1(verbSimple, void 0) }
-          ]) : SUBRULE1(verb, void 0);
-          const triples = SUBRULE1(
-            allowPaths ? objectListPath : objectList,
-            ACTION(() => ({ subject: arg.subject, predicate }))
-          );
-          MANY2(() => {
-            CONSUME(symbols_exports.semi);
-            parsedSemi = true;
-          });
-          ACTION(() => {
-            result.push(...triples);
-          });
-        }
-      });
-      return result;
+    name: unCapitalize(func.name),
+    impl: ({ ACTION, CONSUME, CONSUME1, CONSUME2, SUBRULE1, SUBRULE2, SUBRULE3 }) => (C) => {
+      const operator = CONSUME(func);
+      CONSUME(symbols_exports.LParen);
+      const arg1 = SUBRULE1(expression);
+      CONSUME1(symbols_exports.comma);
+      const arg2 = SUBRULE2(expression);
+      CONSUME2(symbols_exports.comma);
+      const arg3 = SUBRULE3(expression);
+      const close = CONSUME(symbols_exports.RParen);
+      return ACTION(() => C.factory.expressionOperation(operator.image, [arg1, arg2, arg3], C.factory.sourceLocation(operator, close)));
     }
   };
 }
-var propertyListNotEmpty = propertyListNotEmptyImplementation("propertyListNotEmpty", false);
-var propertyListPathNotEmpty = propertyListNotEmptyImplementation("propertyListPathNotEmpty", true);
-var verbPath = {
-  name: "verbPath",
-  impl: ({ SUBRULE }) => () => SUBRULE(path, void 0)
-};
-var verbSimple = {
-  name: "verbSimple",
-  impl: ({ SUBRULE }) => () => SUBRULE(var_, void 0)
-};
-function objectListImpl(name, allowPaths) {
+function funcVar1(func) {
   return {
-    name,
-    impl: ({ ACTION, SUBRULE, AT_LEAST_ONE_SEP }) => (_, arg) => {
-      const objects = [];
-      AT_LEAST_ONE_SEP({
-        SEP: symbols_exports.comma,
-        DEF: () => {
-          const objectTriple = SUBRULE(allowPaths ? objectPath : object, arg);
-          ACTION(() => {
-            objects.push(objectTriple);
-          });
-        }
-      });
-      return objects;
+    name: unCapitalize(func.name),
+    impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
+      const operator = CONSUME(func);
+      CONSUME(symbols_exports.LParen);
+      const arg = SUBRULE(var_);
+      const close = CONSUME(symbols_exports.RParen);
+      return ACTION(() => C.factory.expressionOperation(operator.image, [arg], C.factory.sourceLocation(operator, close)));
     }
   };
 }
-var objectList = objectListImpl("objectList", false);
-var objectListPath = objectListImpl("objectListPath", true);
-function objectImpl(name, allowPaths) {
+function funcExprOrNil1(func) {
   return {
-    name,
-    impl: ({ ACTION, SUBRULE }) => (C, arg) => {
-      const node = SUBRULE(allowPaths ? graphNodePath : graphNode, void 0);
-      return ACTION(() => C.factory.triple(arg.subject, arg.predicate, node));
+    name: unCapitalize(func.name),
+    impl: ({ ACTION, CONSUME, OR, SUBRULE }) => (C) => {
+      const operator = CONSUME(func);
+      return OR([
+        { ALT: () => {
+          CONSUME(symbols_exports.LParen);
+          const arg = SUBRULE(expression);
+          const close = CONSUME(symbols_exports.RParen);
+          return ACTION(() => C.factory.expressionOperation(operator.image, [arg], C.factory.sourceLocation(operator, close)));
+        } },
+        { ALT: () => {
+          const nil2 = CONSUME(terminals_exports.nil);
+          return ACTION(() => C.factory.expressionOperation(operator.image, [], C.factory.sourceLocation(operator, nil2)));
+        } }
+      ]);
     }
   };
 }
-var object = objectImpl("object", false);
-var objectPath = objectImpl("objectPath", true);
-function collectionImpl(name, allowPaths) {
+function funcNil1(func) {
   return {
-    name,
-    impl: ({ ACTION, AT_LEAST_ONE, SUBRULE, CONSUME }) => (C) => {
-      const terms = [];
-      const startToken = CONSUME(symbols_exports.LParen);
-      AT_LEAST_ONE(() => {
-        terms.push(SUBRULE(allowPaths ? graphNodePath : graphNode, void 0));
-      });
-      const endToken = CONSUME(symbols_exports.RParen);
-      return ACTION(() => {
-        const F3 = C.factory;
-        const triples = [];
-        const predFirst = F3.namedNode(F3.sourceLocationNoMaterialize(), "http://www.w3.org/1999/02/22-rdf-syntax-ns#first" /* FIRST */, void 0);
-        const predRest = F3.namedNode(F3.sourceLocationNoMaterialize(), "http://www.w3.org/1999/02/22-rdf-syntax-ns#rest" /* REST */, void 0);
-        const predNil = F3.namedNode(F3.sourceLocationNoMaterialize(), "http://www.w3.org/1999/02/22-rdf-syntax-ns#nil" /* NIL */, void 0);
-        const listHead = F3.blankNode(void 0, F3.sourceLocationNoMaterialize());
-        let iterHead = listHead;
-        for (const [index, term] of terms.entries()) {
-          const lastInList = index === terms.length - 1;
-          const headTriple = F3.triple(
-            iterHead,
-            predFirst,
-            term
-          );
-          triples.push(headTriple);
-          if (lastInList) {
-            const nilTriple = F3.triple(iterHead, predRest, predNil);
-            triples.push(nilTriple);
-          } else {
-            const tail = F3.blankNode(void 0, F3.sourceLocationNoMaterialize());
-            const linkTriple = F3.triple(iterHead, predRest, tail);
-            triples.push(linkTriple);
-            iterHead = tail;
-          }
-        }
-        return F3.tripleCollectionList(listHead, triples, F3.sourceLocation(startToken, endToken));
-      });
-    },
-    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
-      F3.printFilter(ast, () => PRINT_WORD("("));
-      for (const [idx, triple] of ast.triples.entries()) {
-        if (idx % 2 === 0) {
-          SUBRULE(allowPaths ? graphNodePath : graphNode, triple.object, void 0);
-        }
-      }
-      F3.printFilter(ast, () => PRINT_WORD(")"));
+    name: unCapitalize(func.name),
+    impl: ({ ACTION, CONSUME }) => (C) => {
+      const operator = CONSUME(func);
+      const nil2 = CONSUME(terminals_exports.nil);
+      return ACTION(() => C.factory.expressionOperation(operator.image, [], C.factory.sourceLocation(operator, nil2)));
     }
   };
 }
-var collection = collectionImpl("collection", false);
-var collectionPath = collectionImpl("collectionPath", true);
-function triplesNodeImpl(name, allowPaths) {
+function funcExprList1(func) {
   return {
-    name,
-    impl: ({ SUBRULE, OR }) => () => OR([
-      { ALT: () => SUBRULE(allowPaths ? collectionPath : collection, void 0) },
-      { ALT: () => SUBRULE(allowPaths ? blankNodePropertyListPath : blankNodePropertyList, void 0) }
-    ]),
-    gImpl: ({ SUBRULE }) => (ast) => ast.subType === "list" ? SUBRULE(allowPaths ? collectionPath : collection, ast, void 0) : SUBRULE(allowPaths ? blankNodePropertyListPath : blankNodePropertyList, ast, void 0)
+    name: unCapitalize(func.name),
+    impl: ({ ACTION, CONSUME, SUBRULE }) => (C) => {
+      const operator = CONSUME(func);
+      const args = SUBRULE(expressionList);
+      return ACTION(() => C.factory.expressionOperation(operator.image, args.val, C.factory.sourceLocation(operator, args)));
+    }
   };
 }
-var triplesNode = triplesNodeImpl("triplesNode", false);
-var triplesNodePath = triplesNodeImpl("triplesNodePath", true);
-function blankNodePropertyListImpl(name, allowPaths) {
-  const propertyPathNotEmptyImpl = allowPaths ? propertyListPathNotEmpty : propertyListNotEmpty;
+function funcExpr2or3(func) {
   return {
-    name,
-    impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
-      const startToken = CONSUME(symbols_exports.LSquare);
-      const blankNode2 = ACTION(() => C.factory.blankNode(void 0, C.factory.sourceLocationNoMaterialize()));
-      const propList = SUBRULE(propertyPathNotEmptyImpl, { subject: blankNode2 });
-      const endToken = CONSUME(symbols_exports.RSquare);
-      return ACTION(() => C.factory.tripleCollectionBlankNodeProperties(
-        blankNode2,
-        propList,
-        C.factory.sourceLocation(startToken, endToken)
+    name: unCapitalize(func.name),
+    impl: ({ ACTION, CONSUME, SUBRULE1, SUBRULE2, SUBRULE3, CONSUME1, OPTION, CONSUME2 }) => (C) => {
+      const operator = CONSUME(func);
+      CONSUME(symbols_exports.LParen);
+      const arg1 = SUBRULE1(expression);
+      CONSUME1(symbols_exports.comma);
+      const arg2 = SUBRULE2(expression);
+      const arg3 = OPTION(() => {
+        CONSUME2(symbols_exports.comma);
+        return SUBRULE3(expression);
+      });
+      const close = CONSUME(symbols_exports.RParen);
+      return ACTION(() => C.factory.expressionOperation(
+        operator.image,
+        arg3 ? [arg1, arg2, arg3] : [arg1, arg2],
+        C.factory.sourceLocation(operator, close)
       ));
-    },
-    gImpl: ({ SUBRULE, PRINT, PRINT_WORD, HANDLE_LOC }) => (ast, { factory: F3 }) => {
-      F3.printFilter(ast, () => PRINT("["));
-      for (const triple of ast.triples) {
-        HANDLE_LOC(triple, () => {
-          if (F3.isTerm(triple.predicate) && F3.isTermVariable(triple.predicate)) {
-            SUBRULE(varOrTerm, triple.predicate, void 0);
-          } else {
-            SUBRULE(pathGenerator, triple.predicate, void 0);
-          }
-          SUBRULE(graphNodePath, triple.object, void 0);
-          F3.printFilter(ast, () => PRINT_WORD(";"));
-        });
-      }
-      F3.printFilter(ast, () => PRINT("]"));
     }
   };
 }
-var blankNodePropertyList = blankNodePropertyListImpl("blankNodePropertyList", false);
-var blankNodePropertyListPath = blankNodePropertyListImpl("blankNodePropertyListPath", true);
-function graphNodeImpl(name, allowPaths) {
-  const triplesNodeRule = allowPaths ? triplesNodePath : triplesNode;
+function funcExpr3or4(func) {
   return {
-    name,
-    impl: ({ SUBRULE, OR }) => (C) => OR([
-      { ALT: () => SUBRULE(varOrTerm, void 0) },
-      {
-        GATE: () => C.parseMode.has("canCreateBlankNodes"),
-        ALT: () => SUBRULE(triplesNodeRule, void 0)
-      }
-    ]),
-    gImpl: ({ SUBRULE }) => (ast, { factory: F3 }) => {
-      if (F3.isTerm(ast)) {
-        SUBRULE(varOrTerm, ast, void 0);
-      } else {
-        SUBRULE(triplesNodeRule, ast, void 0);
-      }
+    name: unCapitalize(func.name),
+    impl: ({
+      ACTION,
+      CONSUME,
+      SUBRULE1,
+      SUBRULE2,
+      SUBRULE3,
+      SUBRULE4,
+      CONSUME1,
+      OPTION,
+      CONSUME2,
+      CONSUME3
+    }) => (C) => {
+      const operator = CONSUME(func);
+      CONSUME(symbols_exports.LParen);
+      const arg1 = SUBRULE1(expression);
+      CONSUME1(symbols_exports.comma);
+      const arg2 = SUBRULE2(expression);
+      CONSUME2(symbols_exports.comma);
+      const arg3 = SUBRULE3(expression);
+      const arg4 = OPTION(() => {
+        CONSUME3(symbols_exports.comma);
+        return SUBRULE4(expression);
+      });
+      const close = CONSUME(symbols_exports.RParen);
+      return ACTION(() => C.factory.expressionOperation(
+        operator.image,
+        arg4 ? [arg1, arg2, arg3, arg4] : [arg1, arg2, arg3],
+        C.factory.sourceLocation(operator, close)
+      ));
+    }
+  };
+}
+function funcGroupGraphPattern(func) {
+  return {
+    name: unCapitalize(func.name),
+    impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
+      const operator = CONSUME(func);
+      const group = SUBRULE(groupGraphPattern);
+      return ACTION(() => C.factory.expressionPatternOperation(
+        operator.image,
+        group,
+        C.factory.sourceLocation(operator, group)
+      ));
+    }
+  };
+}
+function baseAggregateFunc(func) {
+  return {
+    name: unCapitalize(func.name),
+    impl: ({ ACTION, CONSUME, SUBRULE, OPTION }) => (C) => {
+      const operator = CONSUME(func);
+      CONSUME(symbols_exports.LParen);
+      const distinct2 = OPTION(() => CONSUME(distinct));
+      const expr1 = SUBRULE(expression);
+      const close = CONSUME(symbols_exports.RParen);
+      return ACTION(() => C.factory.aggregate(
+        operator.image,
+        distinct2 !== void 0,
+        expr1,
+        void 0,
+        C.factory.sourceLocation(operator, close)
+      ));
     }
   };
 }
-var graphNode = graphNodeImpl("graphNode", false);
-var graphNodePath = graphNodeImpl("graphNodePath", true);
 
-// ../rules-sparql-1-1/lib/grammar/whereClause.ts
-var whereClause = {
-  name: "whereClause",
-  impl: ({ ACTION, SUBRULE, CONSUME, OPTION }) => (C) => {
-    const where2 = OPTION(() => CONSUME(where));
-    const group = SUBRULE(groupGraphPattern, void 0);
-    return ACTION(() => C.factory.wrap(group, C.factory.sourceLocation(where2, group)));
-  },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
-    F3.printFilter(ast, () => PRINT_WORD("WHERE"));
-    SUBRULE(groupGraphPattern, ast.val, void 0);
+// ../rules-sparql-1-1/lib/grammar/builtIn.ts
+var builtInStr = funcExpr1(BuiltInCalls_exports.str);
+var builtInLang = funcExpr1(BuiltInCalls_exports.lang);
+var builtInLangmatches = funcExpr2(BuiltInCalls_exports.langmatches);
+var builtInDatatype = funcExpr1(BuiltInCalls_exports.datatype);
+var builtInBound = funcVar1(BuiltInCalls_exports.bound);
+var builtInIri = funcExpr1(BuiltInCalls_exports.iri);
+var builtInUri = funcExpr1(BuiltInCalls_exports.uri);
+var builtInBnodeSparqlJs = funcExprOrNil1(BuiltInCalls_exports.bnode);
+var builtInRand = funcNil1(BuiltInCalls_exports.rand);
+var builtInAbs = funcExpr1(BuiltInCalls_exports.abs);
+var builtInCeil = funcExpr1(BuiltInCalls_exports.ceil);
+var builtInFloor = funcExpr1(BuiltInCalls_exports.floor);
+var builtInRound = funcExpr1(BuiltInCalls_exports.round);
+var builtInConcat = funcExprList1(BuiltInCalls_exports.concat);
+var builtInStrlen = funcExpr1(BuiltInCalls_exports.strlen);
+var builtInUcase = funcExpr1(BuiltInCalls_exports.ucase);
+var builtInLcase = funcExpr1(BuiltInCalls_exports.lcase);
+var builtInEncode_for_uri = funcExpr1(BuiltInCalls_exports.encode_for_uri);
+var builtInContains = funcExpr2(BuiltInCalls_exports.contains);
+var builtInStrstarts = funcExpr2(BuiltInCalls_exports.strstarts);
+var builtInStrends = funcExpr2(BuiltInCalls_exports.strends);
+var builtInStrbefore = funcExpr2(BuiltInCalls_exports.strbefore);
+var builtInStrafter = funcExpr2(BuiltInCalls_exports.strafter);
+var builtInYear = funcExpr1(BuiltInCalls_exports.year);
+var builtInMonth = funcExpr1(BuiltInCalls_exports.month);
+var builtInDay = funcExpr1(BuiltInCalls_exports.day);
+var builtInHours = funcExpr1(BuiltInCalls_exports.hours);
+var builtInMinutes = funcExpr1(BuiltInCalls_exports.minutes);
+var builtInSeconds = funcExpr1(BuiltInCalls_exports.seconds);
+var builtInTimezone = funcExpr1(BuiltInCalls_exports.timezone);
+var builtInTz = funcExpr1(BuiltInCalls_exports.tz);
+var builtInNow = funcNil1(BuiltInCalls_exports.now);
+var builtInUuid = funcNil1(BuiltInCalls_exports.uuid);
+var builtInStruuid = funcNil1(BuiltInCalls_exports.struuid);
+var builtInMd5 = funcExpr1(BuiltInCalls_exports.md5);
+var builtInSha1 = funcExpr1(BuiltInCalls_exports.sha1);
+var builtInSha256 = funcExpr1(BuiltInCalls_exports.sha256);
+var builtInSha384 = funcExpr1(BuiltInCalls_exports.sha384);
+var builtInSha512 = funcExpr1(BuiltInCalls_exports.sha512);
+var builtInCoalesce = funcExprList1(BuiltInCalls_exports.coalesce);
+var builtInIf = funcExpr3(BuiltInCalls_exports.if_);
+var builtInStrlang = funcExpr2(BuiltInCalls_exports.strlang);
+var builtInStrdt = funcExpr2(BuiltInCalls_exports.strdt);
+var builtInSameterm = funcExpr2(BuiltInCalls_exports.sameterm);
+var builtInIsiri = funcExpr1(BuiltInCalls_exports.isiri);
+var builtInIsuri = funcExpr1(BuiltInCalls_exports.isuri);
+var builtInIsblank = funcExpr1(BuiltInCalls_exports.isblank);
+var builtInIsliteral = funcExpr1(BuiltInCalls_exports.isliteral);
+var builtInIsnumeric = funcExpr1(BuiltInCalls_exports.isnumeric);
+function builtInCallList(SUBRULE) {
+  return [
+    { ALT: () => SUBRULE(aggregate) },
+    { ALT: () => SUBRULE(builtInStr) },
+    { ALT: () => SUBRULE(builtInLang) },
+    { ALT: () => SUBRULE(builtInLangmatches) },
+    { ALT: () => SUBRULE(builtInDatatype) },
+    { ALT: () => SUBRULE(builtInBound) },
+    { ALT: () => SUBRULE(builtInIri) },
+    { ALT: () => SUBRULE(builtInUri) },
+    { ALT: () => SUBRULE(builtInBnodeSparqlJs) },
+    { ALT: () => SUBRULE(builtInRand) },
+    { ALT: () => SUBRULE(builtInAbs) },
+    { ALT: () => SUBRULE(builtInCeil) },
+    { ALT: () => SUBRULE(builtInFloor) },
+    { ALT: () => SUBRULE(builtInRound) },
+    { ALT: () => SUBRULE(builtInConcat) },
+    { ALT: () => SUBRULE(substringExpression) },
+    { ALT: () => SUBRULE(builtInStrlen) },
+    { ALT: () => SUBRULE(strReplaceExpression) },
+    { ALT: () => SUBRULE(builtInUcase) },
+    { ALT: () => SUBRULE(builtInLcase) },
+    { ALT: () => SUBRULE(builtInEncode_for_uri) },
+    { ALT: () => SUBRULE(builtInContains) },
+    { ALT: () => SUBRULE(builtInStrstarts) },
+    { ALT: () => SUBRULE(builtInStrends) },
+    { ALT: () => SUBRULE(builtInStrbefore) },
+    { ALT: () => SUBRULE(builtInStrafter) },
+    { ALT: () => SUBRULE(builtInYear) },
+    { ALT: () => SUBRULE(builtInMonth) },
+    { ALT: () => SUBRULE(builtInDay) },
+    { ALT: () => SUBRULE(builtInHours) },
+    { ALT: () => SUBRULE(builtInMinutes) },
+    { ALT: () => SUBRULE(builtInSeconds) },
+    { ALT: () => SUBRULE(builtInTimezone) },
+    { ALT: () => SUBRULE(builtInTz) },
+    { ALT: () => SUBRULE(builtInNow) },
+    { ALT: () => SUBRULE(builtInUuid) },
+    { ALT: () => SUBRULE(builtInStruuid) },
+    { ALT: () => SUBRULE(builtInMd5) },
+    { ALT: () => SUBRULE(builtInSha1) },
+    { ALT: () => SUBRULE(builtInSha256) },
+    { ALT: () => SUBRULE(builtInSha384) },
+    { ALT: () => SUBRULE(builtInSha512) },
+    { ALT: () => SUBRULE(builtInCoalesce) },
+    { ALT: () => SUBRULE(builtInIf) },
+    { ALT: () => SUBRULE(builtInStrlang) },
+    { ALT: () => SUBRULE(builtInStrdt) },
+    { ALT: () => SUBRULE(builtInSameterm) },
+    { ALT: () => SUBRULE(builtInIsiri) },
+    { ALT: () => SUBRULE(builtInIsuri) },
+    { ALT: () => SUBRULE(builtInIsblank) },
+    { ALT: () => SUBRULE(builtInIsliteral) },
+    { ALT: () => SUBRULE(builtInIsnumeric) },
+    { ALT: () => SUBRULE(regexExpression) },
+    { ALT: () => SUBRULE(existsFunc) },
+    { ALT: () => SUBRULE(notExistsFunc) }
+  ];
+}
+var builtInCall = {
+  name: "builtInCall",
+  impl: ({ OR, SUBRULE, cache }) => () => {
+    const cached = cache.get(builtInCall);
+    if (cached) {
+      return OR(cached);
+    }
+    const builtIns = builtInCallList(SUBRULE);
+    cache.set(builtInCall, builtIns);
+    return OR(builtIns);
   }
 };
-var groupGraphPattern = {
-  name: "groupGraphPattern",
-  impl: ({ ACTION, SUBRULE, CONSUME, OR }) => (C) => {
-    const open = CONSUME(symbols_exports.LCurly);
-    const patterns = OR([
-      { ALT: () => [SUBRULE(subSelect, void 0)] },
-      { ALT: () => SUBRULE(groupGraphPatternSub, void 0) }
+var regexExpression = funcExpr2or3(BuiltInCalls_exports.regex);
+var substringExpression = funcExpr2or3(BuiltInCalls_exports.substr);
+var strReplaceExpression = funcExpr3or4(BuiltInCalls_exports.replace);
+var existsFunc = funcGroupGraphPattern(BuiltInCalls_exports.exists);
+var notExistsFunc = funcGroupGraphPattern(BuiltInCalls_exports.notexists);
+var aggregateCount = {
+  name: unCapitalize(BuiltInCalls_exports.count.name),
+  impl: ({ ACTION, CONSUME, SUBRULE, OR, OPTION }) => (C) => {
+    const operatorToken = CONSUME(BuiltInCalls_exports.count);
+    CONSUME(symbols_exports.LParen);
+    const distinctToken = OPTION(() => CONSUME(distinct));
+    const expressionVal = OR([
+      { ALT: () => {
+        const starToken = CONSUME(symbols_exports.star);
+        return ACTION(() => C.factory.wildcard(C.factory.sourceLocation(starToken)));
+      } },
+      { ALT: () => SUBRULE(expression) }
     ]);
-    const close = CONSUME(symbols_exports.RCurly);
-    return ACTION(() => C.factory.patternGroup(patterns, C.factory.sourceLocation(open, close)));
-  },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
-    F3.printFilter(ast, () => PRINT_WORD("{"));
-    for (const pattern of ast.patterns) {
-      SUBRULE(generatePattern, pattern, void 0);
-    }
-    F3.printFilter(ast, () => PRINT_WORD("}"));
+    const closeToken = CONSUME(symbols_exports.RParen);
+    return ACTION(() => {
+      const F3 = C.factory;
+      if (C.factory.isWildcard(expressionVal)) {
+        return F3.aggregate(
+          operatorToken.image,
+          Boolean(distinctToken),
+          expressionVal,
+          void 0,
+          C.factory.sourceLocation(operatorToken, closeToken)
+        );
+      }
+      return F3.aggregate(
+        operatorToken.image,
+        Boolean(distinctToken),
+        expressionVal,
+        void 0,
+        C.factory.sourceLocation(operatorToken, closeToken)
+      );
+    });
   }
 };
-var generatePattern = {
-  name: "generatePattern",
-  gImpl: ({ SUBRULE }) => (ast, { factory: F3 }) => {
-    if (ast.type === "query") {
-      SUBRULE(query, F3.querySelect({
-        context: [],
-        datasets: F3.datasetClauses([], F3.sourceLocation()),
-        where: ast.where,
-        variables: ast.variables,
-        solutionModifiers: ast.solutionModifiers,
-        values: ast.values,
-        distinct: ast.distinct,
-        reduced: ast.reduced
-      }, ast.loc), void 0);
-    } else if (ast.subType === "group") {
-      SUBRULE(groupGraphPattern, ast, void 0);
-    } else if (ast.subType === "bgp") {
-      SUBRULE(triplesBlock, ast, void 0);
-    } else {
-      SUBRULE(graphPatternNotTriples, ast, void 0);
-    }
+var aggregateSum = baseAggregateFunc(BuiltInCalls_exports.sum);
+var aggregateMin = baseAggregateFunc(BuiltInCalls_exports.min);
+var aggregateMax = baseAggregateFunc(BuiltInCalls_exports.max);
+var aggregateAvg = baseAggregateFunc(BuiltInCalls_exports.avg);
+var aggregateSample = baseAggregateFunc(BuiltInCalls_exports.sample);
+var aggregateGroup_concat = {
+  name: unCapitalize(BuiltInCalls_exports.groupConcat.name),
+  impl: ({ ACTION, CONSUME, OPTION1, SUBRULE, OPTION2 }) => (C) => {
+    const operatorToken = CONSUME(BuiltInCalls_exports.groupConcat);
+    CONSUME(symbols_exports.LParen);
+    const distinctToken = OPTION1(() => CONSUME(distinct));
+    const expr = SUBRULE(expression);
+    const sep = OPTION2(() => {
+      CONSUME(symbols_exports.semi);
+      CONSUME(separator);
+      CONSUME(symbols_exports.equal);
+      return SUBRULE(string);
+    });
+    const closeToken = CONSUME(symbols_exports.RParen);
+    return ACTION(() => {
+      const F3 = C.factory;
+      return F3.aggregate(
+        operatorToken.image,
+        Boolean(distinctToken),
+        expr,
+        sep?.value ?? " ",
+        F3.sourceLocation(operatorToken, closeToken)
+      );
+    });
   }
 };
-var groupGraphPatternSub = {
-  name: "groupGraphPatternSub",
-  impl: ({ ACTION, SUBRULE, CONSUME, MANY, SUBRULE1, SUBRULE2, OPTION1, OPTION2, OPTION3 }) => () => {
-    const patterns = [];
-    const bgpPattern = OPTION1(() => SUBRULE1(triplesBlock, void 0));
-    if (bgpPattern) {
-      patterns.push(bgpPattern);
-    }
-    MANY(() => {
-      const notTriples = SUBRULE(graphPatternNotTriples, void 0);
-      patterns.push(notTriples);
-      OPTION2(() => CONSUME(symbols_exports.dot));
-      const moreTriples = OPTION3(() => SUBRULE2(triplesBlock, void 0));
-      if (moreTriples) {
-        patterns.push(moreTriples);
+var aggregate = {
+  name: "aggregate",
+  impl: ({ ACTION, SUBRULE, OR }) => (C) => {
+    const wasInAggregate = ACTION(() => C.parseMode.has("inAggregate"));
+    ACTION(() => C.parseMode.add("inAggregate"));
+    const result = OR([
+      { ALT: () => SUBRULE(aggregateCount) },
+      { ALT: () => SUBRULE(aggregateSum) },
+      { ALT: () => SUBRULE(aggregateMin) },
+      { ALT: () => SUBRULE(aggregateMax) },
+      { ALT: () => SUBRULE(aggregateAvg) },
+      { ALT: () => SUBRULE(aggregateSample) },
+      { ALT: () => SUBRULE(aggregateGroup_concat) }
+    ]);
+    ACTION(() => !wasInAggregate && C.parseMode.delete("inAggregate"));
+    ACTION(() => {
+      if (!C.parseMode.has("canParseAggregate")) {
+        throw new Error("Aggregates are only allowed in SELECT, HAVING, and ORDER BY clauses.");
+      }
+      if (C.parseMode.has("inAggregate")) {
+        throw new Error("An aggregate function is not allowed within an aggregate function.");
       }
     });
-    ACTION(() => checkNote13(patterns));
-    return patterns;
-  }
-};
-var graphPatternNotTriples = {
-  name: "graphPatternNotTriples",
-  impl: ({ SUBRULE, OR }) => () => OR([
-    { ALT: () => SUBRULE(groupOrUnionGraphPattern, void 0) },
-    { ALT: () => SUBRULE(optionalGraphPattern, void 0) },
-    { ALT: () => SUBRULE(minusGraphPattern, void 0) },
-    { ALT: () => SUBRULE(graphGraphPattern, void 0) },
-    { ALT: () => SUBRULE(serviceGraphPattern, void 0) },
-    { ALT: () => SUBRULE(filter3, void 0) },
-    { ALT: () => SUBRULE(bind2, void 0) },
-    { ALT: () => SUBRULE(inlineData, void 0) }
-  ]),
-  gImpl: ({ SUBRULE }) => (ast) => {
-    switch (ast.subType) {
-      case "group":
-      case "union":
-        SUBRULE(groupOrUnionGraphPattern, ast, void 0);
-        break;
-      case "optional":
-        SUBRULE(optionalGraphPattern, ast, void 0);
-        break;
-      case "minus":
-        SUBRULE(minusGraphPattern, ast, void 0);
-        break;
-      case "graph":
-        SUBRULE(graphGraphPattern, ast, void 0);
-        break;
-      case "service":
-        SUBRULE(serviceGraphPattern, ast, void 0);
-        break;
-      case "filter":
-        SUBRULE(filter3, ast, void 0);
-        break;
-      case "bind":
-        SUBRULE(bind2, ast, void 0);
-        break;
-      case "values":
-        SUBRULE(inlineData, ast, void 0);
-        break;
+    return result;
+  },
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+    F3.printFilter(ast, () => {
+      PRINT_WORD(ast.aggregation, "(");
+      if (ast.distinct) {
+        PRINT_WORD("DISTINCT");
+      }
+    });
+    const arg = ast.expression[0];
+    if (F3.isWildcard(arg)) {
+      F3.printFilter(ast, () => PRINT_WORD("*"));
+    } else {
+      SUBRULE(expression, arg);
+    }
+    if (F3.isExpressionAggregateSeparator(ast)) {
+      F3.printFilter(ast, () => PRINT_WORD(";", "SEPARATOR", "=", stringEscapedLexical(ast.separator)));
     }
+    F3.printFilter(ast, () => PRINT_WORD(")"));
   }
 };
-var optionalGraphPattern = {
-  name: "optionalGraphPattern",
-  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
-    const optional2 = CONSUME(optional);
-    const group = SUBRULE(groupGraphPattern, void 0);
-    return ACTION(() => C.factory.patternOptional(group.patterns, C.factory.sourceLocation(optional2, group)));
-  },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
-    F3.printFilter(ast, () => PRINT_WORD("OPTIONAL"));
-    SUBRULE(groupGraphPattern, F3.patternGroup(ast.patterns, ast.loc), void 0);
-  }
-};
-var graphGraphPattern = {
-  name: "graphGraphPattern",
-  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
-    const graph2 = CONSUME(graph_exports.graph);
-    const name = SUBRULE(varOrIri, void 0);
-    const group = SUBRULE(groupGraphPattern, void 0);
-    return ACTION(() => C.factory.patternGraph(name, group.patterns, C.factory.sourceLocation(graph2, group)));
-  },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
-    F3.printFilter(ast, () => PRINT_WORD("GRAPH"));
-    SUBRULE(varOrTerm, ast.name, void 0);
-    SUBRULE(groupGraphPattern, F3.patternGroup(ast.patterns, ast.loc), void 0);
-  }
-};
-var serviceGraphPattern = {
-  name: "serviceGraphPattern",
-  impl: ({ ACTION, SUBRULE1, CONSUME, OPTION }) => (C) => {
-    const service2 = CONSUME(service);
-    const silent2 = OPTION(() => {
-      CONSUME(silent);
-      return true;
-    }) ?? false;
-    const name = SUBRULE1(varOrIri, void 0);
-    const group = SUBRULE1(groupGraphPattern, void 0);
-    return ACTION(() => C.factory.patternService(name, group.patterns, silent2, C.factory.sourceLocation(service2, group)));
-  },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
-    F3.printFilter(ast, () => {
-      PRINT_WORD("SERVICE");
-      if (ast.silent) {
-        PRINT_WORD("SILENT");
-      }
-    });
-    SUBRULE(varOrTerm, ast.name, void 0);
-    SUBRULE(groupGraphPattern, F3.patternGroup(ast.patterns, ast.loc), void 0);
-  }
-};
-var bind2 = {
-  name: "bind",
-  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
-    const bind3 = CONSUME(bind);
-    CONSUME(symbols_exports.LParen);
-    const expressionVal = SUBRULE(expression, void 0);
-    CONSUME(as);
-    const variable = SUBRULE(var_, void 0);
-    const close = CONSUME(symbols_exports.RParen);
-    return ACTION(() => C.factory.patternBind(expressionVal, variable, C.factory.sourceLocation(bind3, close)));
-  },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
-    F3.printFilter(ast, () => PRINT_WORD("BIND", "("));
-    SUBRULE(expression, ast.expression, void 0);
-    F3.printFilter(ast, () => PRINT_WORD("AS"));
-    SUBRULE(var_, ast.variable, void 0);
-    F3.printFilter(ast, () => PRINT_WORD(")"));
-  }
+
+// ../rules-sparql-1-1/lib/grammar/propertyPaths.ts
+var path = {
+  name: "path",
+  impl: ({ SUBRULE }) => () => SUBRULE(pathAlternative)
 };
-var inlineData = {
-  name: "inlineData",
-  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
-    const values3 = CONSUME(values2);
-    const datablock = SUBRULE(dataBlock, void 0);
-    return ACTION(() => C.factory.patternValues(datablock.val, C.factory.sourceLocation(values3, datablock)));
-  },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
-    const variables = Object.keys(ast.values[0]);
-    F3.printFilter(ast, () => {
-      PRINT_WORD("VALUES", "(");
-      for (const variable of variables) {
-        PRINT_WORD(`?${variable}`);
-      }
-      PRINT_WORD(")", "{");
-    });
-    for (const mapping of ast.values) {
-      F3.printFilter(ast, () => PRINT_WORD("("));
-      for (const variable of variables) {
-        if (mapping[variable] === void 0) {
-          F3.printFilter(ast, () => PRINT_WORD("UNDEF"));
-        } else {
-          SUBRULE(graphNodePath, mapping[variable], void 0);
+var pathGenerator = {
+  name: "path",
+  gImpl: ({ PRINT, SUBRULE }) => (ast, { factory: F3 }, braces = true) => {
+    if (F3.isTerm(ast) && F3.isTermNamed(ast)) {
+      SUBRULE(iri2, ast);
+    } else {
+      F3.printFilter(ast, () => braces && PRINT("("));
+      switch (ast.subType) {
+        case "|":
+        case "/": {
+          const [head2, ...tail] = ast.items;
+          SUBRULE(pathGenerator, head2, braces);
+          for (const val of tail) {
+            F3.printFilter(ast, () => PRINT(ast.subType));
+            SUBRULE(pathGenerator, val, braces);
+          }
+          break;
         }
+        case "^":
+          F3.printFilter(ast, () => PRINT("^"));
+          SUBRULE(pathGenerator, ast.items[0], braces);
+          break;
+        case "?":
+        case "*":
+        case "+":
+          SUBRULE(pathGenerator, ast.items[0], braces);
+          F3.printFilter(ast, () => PRINT(ast.subType));
+          break;
+        case "!":
+          F3.printFilter(ast, () => PRINT("!"));
+          F3.printFilter(ast, () => PRINT("("));
+          SUBRULE(pathGenerator, ast.items[0], false);
+          F3.printFilter(ast, () => PRINT(")"));
+          break;
       }
-      F3.printFilter(ast, () => PRINT_WORD(")"));
+      F3.printFilter(ast, () => braces && PRINT(")"));
     }
-    F3.printFilter(ast, () => PRINT_WORD("}"));
   }
 };
-var dataBlock = {
-  name: "dataBlock",
-  impl: ({ SUBRULE, OR }) => () => OR([
-    { ALT: () => SUBRULE(inlineDataOneVar, void 0) },
-    { ALT: () => SUBRULE(inlineDataFull, void 0) }
+function pathChainHelper(name, SEP, subType, subRule) {
+  return {
+    name,
+    impl: ({ ACTION, CONSUME, SUBRULE1, SUBRULE2, MANY }) => (C) => {
+      const head2 = SUBRULE1(subRule);
+      let tailEnd = head2;
+      const tail = [];
+      MANY(() => {
+        CONSUME(SEP);
+        tailEnd = SUBRULE2(subRule);
+        tail.push(tailEnd);
+      });
+      return ACTION(() => tail.length === 0 ? head2 : C.factory.path(subType, [head2, ...tail], C.factory.sourceLocation(head2, tailEnd)));
+    }
+  };
+}
+var pathEltOrInverse = {
+  name: "pathEltOrInverse",
+  impl: ({ ACTION, CONSUME, SUBRULE1, SUBRULE2, OR }) => (C) => OR([
+    { ALT: () => SUBRULE1(pathElt) },
+    { ALT: () => {
+      const hat2 = CONSUME(symbols_exports.hat);
+      const item = SUBRULE2(pathElt);
+      return ACTION(() => C.factory.path("^", [item], C.factory.sourceLocation(hat2, item)));
+    } }
   ])
 };
-var inlineDataOneVar = {
-  name: "inlineDataOneVar",
-  impl: ({ ACTION, SUBRULE, CONSUME, MANY }) => (C) => {
-    const res = [];
-    const varVal = SUBRULE(var_, void 0);
-    CONSUME(symbols_exports.LCurly);
-    MANY(() => {
-      const value = SUBRULE(dataBlockValue, void 0);
-      ACTION(() => {
-        res.push({ [varVal.value]: value });
-      });
-    });
-    const close = CONSUME(symbols_exports.RCurly);
-    return ACTION(() => C.factory.wrap(res, C.factory.sourceLocation(varVal, close)));
+var pathSequence = pathChainHelper("pathSequence", symbols_exports.slash, "/", pathEltOrInverse);
+var pathAlternative = pathChainHelper("pathAlternative", symbols_exports.pipe, "|", pathSequence);
+var pathElt = {
+  name: "pathElt",
+  impl: ({ ACTION, SUBRULE, OPTION }) => (C) => {
+    const item = SUBRULE(pathPrimary);
+    const modification = OPTION(() => SUBRULE(pathMod));
+    return ACTION(() => modification === void 0 ? item : C.factory.path(modification.image, [item], C.factory.sourceLocation(item, modification)));
   }
 };
-var inlineDataFull = {
-  name: "inlineDataFull",
-  impl: ({
-    ACTION,
-    OR,
-    MANY1,
-    MANY2,
-    MANY3,
-    MANY4,
-    SUBRULE,
-    CONSUME1,
-    CONSUME2
-  }) => (C) => {
-    const res = [];
-    const vars = [];
+var pathMod = {
+  name: "pathMod",
+  impl: ({ CONSUME, OR }) => () => OR([
+    { ALT: () => CONSUME(symbols_exports.question) },
+    { ALT: () => CONSUME(symbols_exports.star) },
+    { ALT: () => CONSUME(symbols_exports.opPlus) }
+  ])
+};
+var pathPrimary = {
+  name: "pathPrimary",
+  impl: ({ SUBRULE, CONSUME, OR }) => () => OR([
+    { ALT: () => SUBRULE(iri2) },
+    { ALT: () => SUBRULE(verbA) },
+    { ALT: () => SUBRULE(pathNegatedPropertySet) },
+    { ALT: () => {
+      CONSUME(symbols_exports.LParen);
+      const resRecursive = SUBRULE(path);
+      CONSUME(symbols_exports.RParen);
+      return resRecursive;
+    } }
+  ])
+};
+var pathNegatedPropertySet = {
+  name: "pathNegatedPropertySet",
+  impl: ({ ACTION, CONSUME, SUBRULE1, SUBRULE2, SUBRULE3, OR, MANY }) => (C) => {
+    const exclamation2 = CONSUME(symbols_exports.exclamation);
     return OR([
       { ALT: () => {
-        const nil2 = CONSUME1(terminals_exports.nil);
-        CONSUME1(symbols_exports.LCurly);
-        MANY1(() => {
-          CONSUME2(terminals_exports.nil);
-          res.push({});
-        });
-        const close = CONSUME1(symbols_exports.RCurly);
-        return ACTION(() => C.factory.wrap(res, C.factory.sourceLocation(nil2, close)));
+        const noAlternative = SUBRULE1(pathOneInPropertySet);
+        return ACTION(() => C.factory.path("!", [noAlternative], C.factory.sourceLocation(exclamation2, noAlternative)));
       } },
       { ALT: () => {
-        const open = CONSUME1(symbols_exports.LParen);
-        MANY2(() => {
-          vars.push(SUBRULE(var_, void 0));
+        const open = CONSUME(symbols_exports.LParen);
+        const head2 = SUBRULE2(pathOneInPropertySet);
+        const tail = [];
+        MANY(() => {
+          CONSUME(symbols_exports.pipe);
+          const item = SUBRULE3(pathOneInPropertySet);
+          tail.push(item);
         });
-        CONSUME1(symbols_exports.RParen);
-        CONSUME2(symbols_exports.LCurly);
-        MANY3(() => {
-          let parsedValues = 0;
-          const currentRow = {};
-          CONSUME2(symbols_exports.LParen);
-          MANY4(() => {
-            if (parsedValues >= vars.length) {
-              throw new Error("Number of dataBlockValues does not match number of variables. Too much values.");
-            }
-            const value = SUBRULE(dataBlockValue, void 0);
-            ACTION(() => {
-              currentRow[vars[parsedValues].value] = value;
-              parsedValues++;
-            });
-          });
-          CONSUME2(symbols_exports.RParen);
-          ACTION(() => {
-            res.push(currentRow);
-            if (vars.length !== parsedValues) {
-              throw new Error("Number of dataBlockValues does not match number of variables. Too few values.");
-            }
-          });
+        const close = CONSUME(symbols_exports.RParen);
+        return ACTION(() => {
+          const F3 = C.factory;
+          if (tail.length === 0) {
+            return F3.path("!", [head2], F3.sourceLocation(exclamation2, close));
+          }
+          return F3.path(
+            "!",
+            [F3.path("|", [head2, ...tail], F3.sourceLocation(open, close))],
+            F3.sourceLocation(exclamation2, close)
+          );
         });
-        const close = CONSUME2(symbols_exports.RCurly);
-        return ACTION(() => C.factory.wrap(res, C.factory.sourceLocation(open, close)));
       } }
     ]);
   }
 };
-var dataBlockValue = {
-  name: "dataBlockValue",
-  impl: ({ SUBRULE, CONSUME, OR }) => () => OR([
-    { ALT: () => SUBRULE(iri2, void 0) },
-    { ALT: () => SUBRULE(rdfLiteral, void 0) },
-    { ALT: () => SUBRULE(numericLiteral, void 0) },
-    { ALT: () => SUBRULE(booleanLiteral, void 0) },
+var pathOneInPropertySet = {
+  name: "pathOneInPropertySet",
+  impl: ({ ACTION, CONSUME, SUBRULE1, SUBRULE2, OR1, OR2 }) => (C) => OR1([
+    { ALT: () => SUBRULE1(iri2) },
+    { ALT: () => SUBRULE1(verbA) },
     { ALT: () => {
-      CONSUME(undef);
-      return void 0;
+      const hat2 = CONSUME(symbols_exports.hat);
+      const item = OR2([
+        { ALT: () => SUBRULE2(iri2) },
+        { ALT: () => SUBRULE2(verbA) }
+      ]);
+      return ACTION(() => C.factory.path("^", [item], C.factory.sourceLocation(hat2, item)));
     } }
   ])
 };
-var minusGraphPattern = {
-  name: "minusGraphPattern",
-  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
-    const minus2 = CONSUME(minus);
-    const group = SUBRULE(groupGraphPattern, void 0);
-    return ACTION(() => C.factory.patternMinus(group.patterns, C.factory.sourceLocation(minus2, group)));
-  },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
-    F3.printFilter(ast, () => PRINT_WORD("MINUS"));
-    SUBRULE(groupGraphPattern, F3.patternGroup(ast.patterns, ast.loc), void 0);
-  }
-};
-var groupOrUnionGraphPattern = {
-  name: "groupOrUnionGraphPattern",
-  impl: ({ ACTION, MANY, SUBRULE1, SUBRULE2, CONSUME }) => (C) => {
-    const groups = [];
-    const group = SUBRULE1(groupGraphPattern, void 0);
-    groups.push(group);
-    MANY(() => {
-      CONSUME(union);
-      const group2 = SUBRULE2(groupGraphPattern, void 0);
-      groups.push(group2);
-    });
-    return ACTION(() => groups.length === 1 ? groups[0] : C.factory.patternUnion(
-      groups,
-      C.factory.sourceLocation(group, groups.at(-1))
-    ));
-  },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
-    if (F3.isPatternUnion(ast)) {
-      const [head2, ...tail] = ast.patterns;
-      SUBRULE(groupGraphPattern, head2, void 0);
-      for (const pattern of tail) {
-        F3.printFilter(ast, () => PRINT_WORD("UNION"));
-        SUBRULE(groupGraphPattern, pattern, void 0);
-      }
-    } else {
-      SUBRULE(groupGraphPattern, ast, void 0);
-    }
-  }
-};
-var filter3 = {
-  name: "filter",
-  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
-    const filterToken = CONSUME(filter2);
-    const expression2 = SUBRULE(constraint, void 0);
-    return ACTION(() => C.factory.patternFilter(expression2, C.factory.sourceLocation(filterToken, expression2)));
-  },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
-    F3.printFilter(ast, () => PRINT_WORD("FILTER ("));
-    SUBRULE(expression, ast.expression, void 0);
-    F3.printFilter(ast, () => PRINT_WORD(")"));
-  }
-};
-var constraint = {
-  name: "constraint",
-  impl: ({ SUBRULE, OR }) => () => OR([
-    { ALT: () => SUBRULE(brackettedExpression, void 0) },
-    { ALT: () => SUBRULE(builtInCall, void 0) },
-    { ALT: () => SUBRULE(functionCall, void 0) }
-  ])
-};
-var functionCall = {
-  name: "functionCall",
-  impl: ({ ACTION, SUBRULE }) => (C) => {
-    const func = SUBRULE(iri2, void 0);
-    const args = SUBRULE(argList, void 0);
-    return ACTION(() => C.factory.expressionFunctionCall(
-      func,
-      args.val.args,
-      args.val.distinct,
-      C.factory.sourceLocation(func, args)
-    ));
-  }
-};
 
-// ../rules-sparql-1-1/lib/expressionHelpers.ts
-function funcExpr1(func) {
-  return {
-    name: unCapitalize(func.name),
-    impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
-      const operator = CONSUME(func);
-      CONSUME(symbols_exports.LParen);
-      const arg = SUBRULE(expression, void 0);
-      const close = CONSUME(symbols_exports.RParen);
-      return ACTION(() => C.factory.expressionOperation(operator.image, [arg], C.factory.sourceLocation(operator, close)));
-    }
+// ../rules-sparql-1-1/lib/grammar/tripleBlock.ts
+function triplesDotSeperated(triplesSameSubjectSubrule) {
+  return ({ ACTION, AT_LEAST_ONE, SUBRULE, CONSUME, OPTION }) => (C) => {
+    const triples = [];
+    let parsedDot = true;
+    let dotToken;
+    AT_LEAST_ONE({
+      GATE: () => parsedDot,
+      DEF: () => {
+        parsedDot = false;
+        const template = SUBRULE(triplesSameSubjectSubrule);
+        ACTION(() => {
+          triples.push(...template);
+        });
+        OPTION(() => {
+          dotToken = CONSUME(symbols_exports.dot);
+          parsedDot = true;
+        });
+      }
+    });
+    return ACTION(() => C.factory.patternBgp(triples, C.factory.sourceLocation(...triples, dotToken)));
   };
 }
-function funcExpr2(func) {
-  return {
-    name: unCapitalize(func.name),
-    impl: ({ ACTION, CONSUME, SUBRULE1, SUBRULE2 }) => (C) => {
-      const operator = CONSUME(func);
-      CONSUME(symbols_exports.LParen);
-      const arg1 = SUBRULE1(expression, void 0);
-      CONSUME(symbols_exports.comma);
-      const arg2 = SUBRULE2(expression, void 0);
-      const close = CONSUME(symbols_exports.RParen);
-      return ACTION(() => C.factory.expressionOperation(operator.image, [arg1, arg2], C.factory.sourceLocation(operator, close)));
+var triplesBlock = {
+  name: "triplesBlock",
+  impl: (implArgs) => (C) => triplesDotSeperated(triplesSameSubjectPath)(implArgs)(C),
+  gImpl: ({ SUBRULE, PRINT_WORD, HANDLE_LOC }) => (ast, { factory: F3 }) => {
+    for (const [index, triple] of ast.triples.entries()) {
+      HANDLE_LOC(triple, () => {
+        const nextTriple = ast.triples.at(index);
+        if (F3.isTripleCollection(triple)) {
+          SUBRULE(graphNodePath, triple);
+          F3.printFilter(triple, () => PRINT_WORD("."));
+        } else {
+          SUBRULE(graphNodePath, triple.subject);
+          if (F3.isTerm(triple.predicate) && F3.isTermVariable(triple.predicate)) {
+            SUBRULE(varOrTerm, triple.predicate);
+          } else {
+            SUBRULE(pathGenerator, triple.predicate, void 0);
+          }
+          SUBRULE(graphNodePath, triple.object);
+          if (nextTriple === void 0 || F3.isTripleCollection(nextTriple) || !F3.isSourceLocationNoMaterialize(nextTriple.subject.loc)) {
+            F3.printFilter(ast, () => PRINT_WORD("."));
+          } else if (F3.isSourceLocationNoMaterialize(nextTriple.predicate.loc)) {
+            F3.printFilter(ast, () => PRINT_WORD(","));
+          } else {
+            F3.printFilter(ast, () => PRINT_WORD(";"));
+          }
+        }
+      });
     }
-  };
-}
-function funcExpr3(func) {
+  }
+};
+function triplesSameSubjectImpl(name, allowPaths) {
   return {
-    name: unCapitalize(func.name),
-    impl: ({ ACTION, CONSUME, CONSUME1, CONSUME2, SUBRULE1, SUBRULE2, SUBRULE3 }) => (C) => {
-      const operator = CONSUME(func);
-      CONSUME(symbols_exports.LParen);
-      const arg1 = SUBRULE1(expression, void 0);
-      CONSUME1(symbols_exports.comma);
-      const arg2 = SUBRULE2(expression, void 0);
-      CONSUME2(symbols_exports.comma);
-      const arg3 = SUBRULE3(expression, void 0);
-      const close = CONSUME(symbols_exports.RParen);
-      return ACTION(() => C.factory.expressionOperation(operator.image, [arg1, arg2, arg3], C.factory.sourceLocation(operator, close)));
-    }
+    name,
+    impl: ({ ACTION, SUBRULE, OR }) => (C) => OR([
+      { ALT: () => {
+        const subject = SUBRULE(varOrTerm);
+        const res = SUBRULE(
+          allowPaths ? propertyListPathNotEmpty : propertyListNotEmpty,
+          ACTION(() => C.factory.dematerialized(subject))
+        );
+        return ACTION(() => {
+          if (res.length > 0) {
+            res[0].subject = subject;
+            res[0].loc = C.factory.sourceLocation(subject, res[0]);
+          }
+          return res;
+        });
+      } },
+      { ALT: () => {
+        const subjectNode = SUBRULE(allowPaths ? triplesNodePath : triplesNode);
+        const restNode = SUBRULE(
+          allowPaths ? propertyListPath : propertyList,
+          ACTION(() => C.factory.graphNodeIdentifier(subjectNode))
+        );
+        return ACTION(() => {
+          if (restNode.length === 0) {
+            return [subjectNode];
+          }
+          restNode[0].subject = subjectNode;
+          restNode[0].loc = C.factory.sourceLocation(subjectNode, restNode[0]);
+          return restNode;
+        });
+      } }
+    ])
   };
 }
-function funcVar1(func) {
+var triplesSameSubject = triplesSameSubjectImpl("triplesSameSubject", false);
+var triplesSameSubjectPath = triplesSameSubjectImpl("triplesSameSubjectPath", true);
+var triplesTemplate = {
+  name: "triplesTemplate",
+  impl: triplesDotSeperated(triplesSameSubject)
+};
+function propertyListImpl(name, allowPaths) {
   return {
-    name: unCapitalize(func.name),
-    impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
-      const operator = CONSUME(func);
-      CONSUME(symbols_exports.LParen);
-      const arg = SUBRULE(var_, void 0);
-      const close = CONSUME(symbols_exports.RParen);
-      return ACTION(() => C.factory.expressionOperation(operator.image, [arg], C.factory.sourceLocation(operator, close)));
-    }
+    name,
+    impl: ({ SUBRULE, OPTION }) => (_, subject) => OPTION(() => SUBRULE(allowPaths ? propertyListPathNotEmpty : propertyListNotEmpty, subject)) ?? []
   };
 }
-function funcExprOrNil1(func) {
+var propertyList = propertyListImpl("propertyList", false);
+var propertyListPath = propertyListImpl("propertyListPath", true);
+function propertyListNotEmptyImplementation(name, allowPaths) {
   return {
-    name: unCapitalize(func.name),
-    impl: ({ ACTION, CONSUME, OR, SUBRULE }) => (C) => {
-      const operator = CONSUME(func);
-      return OR([
-        { ALT: () => {
-          CONSUME(symbols_exports.LParen);
-          const arg = SUBRULE(expression, void 0);
-          const close = CONSUME(symbols_exports.RParen);
-          return ACTION(() => C.factory.expressionOperation(operator.image, [arg], C.factory.sourceLocation(operator, close)));
-        } },
-        { ALT: () => {
-          const nil2 = CONSUME(terminals_exports.nil);
-          return ACTION(() => C.factory.expressionOperation(operator.image, [], C.factory.sourceLocation(operator, nil2)));
-        } }
-      ]);
+    name,
+    impl: ({ ACTION, CONSUME, AT_LEAST_ONE, SUBRULE1, MANY2, OR1 }) => (_, subject) => {
+      const result = [];
+      let parsedSemi = true;
+      AT_LEAST_ONE({
+        GATE: () => parsedSemi,
+        DEF: () => {
+          parsedSemi = false;
+          const predicate = allowPaths ? OR1([
+            { ALT: () => SUBRULE1(verbPath) },
+            { ALT: () => SUBRULE1(verbSimple) }
+          ]) : SUBRULE1(verb);
+          const triples = SUBRULE1(
+            allowPaths ? objectListPath : objectList,
+            subject,
+            predicate
+          );
+          MANY2(() => {
+            CONSUME(symbols_exports.semi);
+            parsedSemi = true;
+          });
+          ACTION(() => {
+            result.push(...triples);
+          });
+        }
+      });
+      return result;
     }
   };
 }
-function funcNil1(func) {
+var propertyListNotEmpty = propertyListNotEmptyImplementation("propertyListNotEmpty", false);
+var propertyListPathNotEmpty = propertyListNotEmptyImplementation("propertyListPathNotEmpty", true);
+var verbPath = {
+  name: "verbPath",
+  impl: ({ SUBRULE }) => () => SUBRULE(path)
+};
+var verbSimple = {
+  name: "verbSimple",
+  impl: ({ SUBRULE }) => () => SUBRULE(var_)
+};
+function objectListImpl(name, allowPaths) {
   return {
-    name: unCapitalize(func.name),
-    impl: ({ ACTION, CONSUME }) => (C) => {
-      const operator = CONSUME(func);
-      const nil2 = CONSUME(terminals_exports.nil);
-      return ACTION(() => C.factory.expressionOperation(operator.image, [], C.factory.sourceLocation(operator, nil2)));
+    name,
+    impl: ({ ACTION, SUBRULE, AT_LEAST_ONE_SEP }) => (_, subj, pred) => {
+      const objects = [];
+      AT_LEAST_ONE_SEP({
+        SEP: symbols_exports.comma,
+        DEF: () => {
+          const objectTriple = SUBRULE(allowPaths ? objectPath : object, subj, pred);
+          ACTION(() => {
+            objects.push(objectTriple);
+          });
+        }
+      });
+      return objects;
     }
   };
 }
-function funcExprList1(func) {
+var objectList = objectListImpl("objectList", false);
+var objectListPath = objectListImpl("objectListPath", true);
+function objectImpl(name, allowPaths) {
   return {
-    name: unCapitalize(func.name),
-    impl: ({ ACTION, CONSUME, SUBRULE }) => (C) => {
-      const operator = CONSUME(func);
-      const args = SUBRULE(expressionList, void 0);
-      return ACTION(() => C.factory.expressionOperation(operator.image, args.val, C.factory.sourceLocation(operator, args)));
+    name,
+    impl: ({ ACTION, SUBRULE }) => (C, subject, predicate) => {
+      const node = SUBRULE(allowPaths ? graphNodePath : graphNode);
+      return ACTION(() => C.factory.triple(subject, predicate, node));
     }
   };
 }
-function funcExpr2or3(func) {
+var object = objectImpl("object", false);
+var objectPath = objectImpl("objectPath", true);
+function collectionImpl(name, allowPaths) {
   return {
-    name: unCapitalize(func.name),
-    impl: ({ ACTION, CONSUME, SUBRULE1, SUBRULE2, SUBRULE3, CONSUME1, OPTION, CONSUME2 }) => (C) => {
-      const operator = CONSUME(func);
-      CONSUME(symbols_exports.LParen);
-      const arg1 = SUBRULE1(expression, void 0);
-      CONSUME1(symbols_exports.comma);
-      const arg2 = SUBRULE2(expression, void 0);
-      const arg3 = OPTION(() => {
-        CONSUME2(symbols_exports.comma);
-        return SUBRULE3(expression, void 0);
+    name,
+    impl: ({ ACTION, AT_LEAST_ONE, SUBRULE, CONSUME }) => (C) => {
+      const terms = [];
+      const startToken = CONSUME(symbols_exports.LParen);
+      AT_LEAST_ONE(() => {
+        terms.push(SUBRULE(allowPaths ? graphNodePath : graphNode));
       });
-      const close = CONSUME(symbols_exports.RParen);
-      return ACTION(() => C.factory.expressionOperation(
-        operator.image,
-        arg3 ? [arg1, arg2, arg3] : [arg1, arg2],
-        C.factory.sourceLocation(operator, close)
-      ));
+      const endToken = CONSUME(symbols_exports.RParen);
+      return ACTION(() => {
+        const F3 = C.factory;
+        const triples = [];
+        const predFirst = F3.namedNode(F3.sourceLocationNoMaterialize(), "http://www.w3.org/1999/02/22-rdf-syntax-ns#first" /* FIRST */, void 0);
+        const predRest = F3.namedNode(F3.sourceLocationNoMaterialize(), "http://www.w3.org/1999/02/22-rdf-syntax-ns#rest" /* REST */, void 0);
+        const predNil = F3.namedNode(F3.sourceLocationNoMaterialize(), "http://www.w3.org/1999/02/22-rdf-syntax-ns#nil" /* NIL */, void 0);
+        const listHead = F3.blankNode(void 0, F3.sourceLocationNoMaterialize());
+        let iterHead = listHead;
+        for (const [index, term] of terms.entries()) {
+          const lastInList = index === terms.length - 1;
+          const headTriple = F3.triple(
+            iterHead,
+            predFirst,
+            term
+          );
+          triples.push(headTriple);
+          if (lastInList) {
+            const nilTriple = F3.triple(iterHead, predRest, predNil);
+            triples.push(nilTriple);
+          } else {
+            const tail = F3.blankNode(void 0, F3.sourceLocationNoMaterialize());
+            const linkTriple = F3.triple(iterHead, predRest, tail);
+            triples.push(linkTriple);
+            iterHead = tail;
+          }
+        }
+        return F3.tripleCollectionList(listHead, triples, F3.sourceLocation(startToken, endToken));
+      });
+    },
+    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+      F3.printFilter(ast, () => PRINT_WORD("("));
+      for (const [idx, triple] of ast.triples.entries()) {
+        if (idx % 2 === 0) {
+          SUBRULE(allowPaths ? graphNodePath : graphNode, triple.object);
+        }
+      }
+      F3.printFilter(ast, () => PRINT_WORD(")"));
     }
   };
 }
-function funcExpr3or4(func) {
+var collection = collectionImpl("collection", false);
+var collectionPath = collectionImpl("collectionPath", true);
+function triplesNodeImpl(name, allowPaths) {
   return {
-    name: unCapitalize(func.name),
-    impl: ({
-      ACTION,
-      CONSUME,
-      SUBRULE1,
-      SUBRULE2,
-      SUBRULE3,
-      SUBRULE4,
-      CONSUME1,
-      OPTION,
-      CONSUME2,
-      CONSUME3
-    }) => (C) => {
-      const operator = CONSUME(func);
-      CONSUME(symbols_exports.LParen);
-      const arg1 = SUBRULE1(expression, void 0);
-      CONSUME1(symbols_exports.comma);
-      const arg2 = SUBRULE2(expression, void 0);
-      CONSUME2(symbols_exports.comma);
-      const arg3 = SUBRULE3(expression, void 0);
-      const arg4 = OPTION(() => {
-        CONSUME3(symbols_exports.comma);
-        return SUBRULE4(expression, void 0);
-      });
-      const close = CONSUME(symbols_exports.RParen);
-      return ACTION(() => C.factory.expressionOperation(
-        operator.image,
-        arg4 ? [arg1, arg2, arg3, arg4] : [arg1, arg2, arg3],
-        C.factory.sourceLocation(operator, close)
-      ));
-    }
+    name,
+    impl: ({ SUBRULE, OR }) => () => OR([
+      { ALT: () => SUBRULE(allowPaths ? collectionPath : collection) },
+      { ALT: () => SUBRULE(allowPaths ? blankNodePropertyListPath : blankNodePropertyList) }
+    ]),
+    gImpl: ({ SUBRULE }) => (ast) => ast.subType === "list" ? SUBRULE(allowPaths ? collectionPath : collection, ast) : SUBRULE(allowPaths ? blankNodePropertyListPath : blankNodePropertyList, ast)
   };
 }
-function funcGroupGraphPattern(func) {
+var triplesNode = triplesNodeImpl("triplesNode", false);
+var triplesNodePath = triplesNodeImpl("triplesNodePath", true);
+function blankNodePropertyListImpl(name, allowPaths) {
+  const propertyPathNotEmptyImpl = allowPaths ? propertyListPathNotEmpty : propertyListNotEmpty;
   return {
-    name: unCapitalize(func.name),
+    name,
     impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
-      const operator = CONSUME(func);
-      const group = SUBRULE(groupGraphPattern, void 0);
-      return ACTION(() => C.factory.expressionPatternOperation(
-        operator.image,
-        group,
-        C.factory.sourceLocation(operator, group)
+      const startToken = CONSUME(symbols_exports.LSquare);
+      const blankNode2 = ACTION(() => C.factory.blankNode(void 0, C.factory.sourceLocationNoMaterialize()));
+      const propList = SUBRULE(propertyPathNotEmptyImpl, blankNode2);
+      const endToken = CONSUME(symbols_exports.RSquare);
+      return ACTION(() => C.factory.tripleCollectionBlankNodeProperties(
+        blankNode2,
+        propList,
+        C.factory.sourceLocation(startToken, endToken)
       ));
+    },
+    gImpl: ({ SUBRULE, PRINT, PRINT_WORD, HANDLE_LOC }) => (ast, { factory: F3 }) => {
+      F3.printFilter(ast, () => PRINT("["));
+      for (const triple of ast.triples) {
+        HANDLE_LOC(triple, () => {
+          if (F3.isTerm(triple.predicate) && F3.isTermVariable(triple.predicate)) {
+            SUBRULE(varOrTerm, triple.predicate);
+          } else {
+            SUBRULE(pathGenerator, triple.predicate, void 0);
+          }
+          SUBRULE(graphNodePath, triple.object);
+          F3.printFilter(ast, () => PRINT_WORD(";"));
+        });
+      }
+      F3.printFilter(ast, () => PRINT("]"));
     }
   };
 }
-function baseAggregateFunc(func) {
+var blankNodePropertyList = blankNodePropertyListImpl("blankNodePropertyList", false);
+var blankNodePropertyListPath = blankNodePropertyListImpl("blankNodePropertyListPath", true);
+function graphNodeImpl(name, allowPaths) {
+  const triplesNodeRule = allowPaths ? triplesNodePath : triplesNode;
   return {
-    name: unCapitalize(func.name),
-    impl: ({ ACTION, CONSUME, SUBRULE, OPTION }) => (C) => {
-      const operator = CONSUME(func);
-      CONSUME(symbols_exports.LParen);
-      const distinct2 = OPTION(() => CONSUME(distinct));
-      const expr1 = SUBRULE(expression, void 0);
-      const close = CONSUME(symbols_exports.RParen);
-      return ACTION(() => C.factory.aggregate(
-        operator.image,
-        distinct2 !== void 0,
-        expr1,
-        void 0,
-        C.factory.sourceLocation(operator, close)
-      ));
+    name,
+    impl: ({ SUBRULE, OR }) => (C) => OR([
+      { ALT: () => SUBRULE(varOrTerm) },
+      {
+        GATE: () => C.parseMode.has("canCreateBlankNodes"),
+        ALT: () => SUBRULE(triplesNodeRule)
+      }
+    ]),
+    gImpl: ({ SUBRULE }) => (ast, { factory: F3 }) => {
+      if (F3.isTerm(ast)) {
+        SUBRULE(varOrTerm, ast);
+      } else {
+        SUBRULE(triplesNodeRule, ast);
+      }
     }
   };
 }
+var graphNode = graphNodeImpl("graphNode", false);
+var graphNodePath = graphNodeImpl("graphNodePath", true);
 
-// ../rules-sparql-1-1/lib/grammar/builtIn.ts
-var builtInStr = funcExpr1(BuildinCalls_exports.str);
-var builtInLang = funcExpr1(BuildinCalls_exports.lang);
-var builtInLangmatches = funcExpr2(BuildinCalls_exports.langmatches);
-var builtInDatatype = funcExpr1(BuildinCalls_exports.datatype);
-var builtInBound = funcVar1(BuildinCalls_exports.bound);
-var builtInIri = funcExpr1(BuildinCalls_exports.iri);
-var builtInUri = funcExpr1(BuildinCalls_exports.uri);
-var builtInBnodeSparqlJs = funcExprOrNil1(BuildinCalls_exports.bnode);
-var builtInRand = funcNil1(BuildinCalls_exports.rand);
-var builtInAbs = funcExpr1(BuildinCalls_exports.abs);
-var builtInCeil = funcExpr1(BuildinCalls_exports.ceil);
-var builtInFloor = funcExpr1(BuildinCalls_exports.floor);
-var builtInRound = funcExpr1(BuildinCalls_exports.round);
-var builtInConcat = funcExprList1(BuildinCalls_exports.concat);
-var builtInStrlen = funcExpr1(BuildinCalls_exports.strlen);
-var builtInUcase = funcExpr1(BuildinCalls_exports.ucase);
-var builtInLcase = funcExpr1(BuildinCalls_exports.lcase);
-var builtInEncode_for_uri = funcExpr1(BuildinCalls_exports.encode_for_uri);
-var builtInContains = funcExpr2(BuildinCalls_exports.contains);
-var builtInStrstarts = funcExpr2(BuildinCalls_exports.strstarts);
-var builtInStrends = funcExpr2(BuildinCalls_exports.strends);
-var builtInStrbefore = funcExpr2(BuildinCalls_exports.strbefore);
-var builtInStrafter = funcExpr2(BuildinCalls_exports.strafter);
-var builtInYear = funcExpr1(BuildinCalls_exports.year);
-var builtInMonth = funcExpr1(BuildinCalls_exports.month);
-var builtInDay = funcExpr1(BuildinCalls_exports.day);
-var builtInHours = funcExpr1(BuildinCalls_exports.hours);
-var builtInMinutes = funcExpr1(BuildinCalls_exports.minutes);
-var builtInSeconds = funcExpr1(BuildinCalls_exports.seconds);
-var builtInTimezone = funcExpr1(BuildinCalls_exports.timezone);
-var builtInTz = funcExpr1(BuildinCalls_exports.tz);
-var builtInNow = funcNil1(BuildinCalls_exports.now);
-var builtInUuid = funcNil1(BuildinCalls_exports.uuid);
-var builtInStruuid = funcNil1(BuildinCalls_exports.struuid);
-var builtInMd5 = funcExpr1(BuildinCalls_exports.md5);
-var builtInSha1 = funcExpr1(BuildinCalls_exports.sha1);
-var builtInSha256 = funcExpr1(BuildinCalls_exports.sha256);
-var builtInSha384 = funcExpr1(BuildinCalls_exports.sha384);
-var builtInSha512 = funcExpr1(BuildinCalls_exports.sha512);
-var builtInCoalesce = funcExprList1(BuildinCalls_exports.coalesce);
-var builtInIf = funcExpr3(BuildinCalls_exports.if_);
-var builtInStrlang = funcExpr2(BuildinCalls_exports.strlang);
-var builtInStrdt = funcExpr2(BuildinCalls_exports.strdt);
-var builtInSameterm = funcExpr2(BuildinCalls_exports.sameterm);
-var builtInIsiri = funcExpr1(BuildinCalls_exports.isiri);
-var builtInIsuri = funcExpr1(BuildinCalls_exports.isuri);
-var builtInIsblank = funcExpr1(BuildinCalls_exports.isblank);
-var builtInIsliteral = funcExpr1(BuildinCalls_exports.isliteral);
-var builtInIsnumeric = funcExpr1(BuildinCalls_exports.isnumeric);
-function builtInCallList(SUBRULE) {
-  return [
-    { ALT: () => SUBRULE(aggregate, void 0) },
-    { ALT: () => SUBRULE(builtInStr, void 0) },
-    { ALT: () => SUBRULE(builtInLang, void 0) },
-    { ALT: () => SUBRULE(builtInLangmatches, void 0) },
-    { ALT: () => SUBRULE(builtInDatatype, void 0) },
-    { ALT: () => SUBRULE(builtInBound, void 0) },
-    { ALT: () => SUBRULE(builtInIri, void 0) },
-    { ALT: () => SUBRULE(builtInUri, void 0) },
-    { ALT: () => SUBRULE(builtInBnodeSparqlJs, void 0) },
-    { ALT: () => SUBRULE(builtInRand, void 0) },
-    { ALT: () => SUBRULE(builtInAbs, void 0) },
-    { ALT: () => SUBRULE(builtInCeil, void 0) },
-    { ALT: () => SUBRULE(builtInFloor, void 0) },
-    { ALT: () => SUBRULE(builtInRound, void 0) },
-    { ALT: () => SUBRULE(builtInConcat, void 0) },
-    { ALT: () => SUBRULE(substringExpression, void 0) },
-    { ALT: () => SUBRULE(builtInStrlen, void 0) },
-    { ALT: () => SUBRULE(strReplaceExpression, void 0) },
-    { ALT: () => SUBRULE(builtInUcase, void 0) },
-    { ALT: () => SUBRULE(builtInLcase, void 0) },
-    { ALT: () => SUBRULE(builtInEncode_for_uri, void 0) },
-    { ALT: () => SUBRULE(builtInContains, void 0) },
-    { ALT: () => SUBRULE(builtInStrstarts, void 0) },
-    { ALT: () => SUBRULE(builtInStrends, void 0) },
-    { ALT: () => SUBRULE(builtInStrbefore, void 0) },
-    { ALT: () => SUBRULE(builtInStrafter, void 0) },
-    { ALT: () => SUBRULE(builtInYear, void 0) },
-    { ALT: () => SUBRULE(builtInMonth, void 0) },
-    { ALT: () => SUBRULE(builtInDay, void 0) },
-    { ALT: () => SUBRULE(builtInHours, void 0) },
-    { ALT: () => SUBRULE(builtInMinutes, void 0) },
-    { ALT: () => SUBRULE(builtInSeconds, void 0) },
-    { ALT: () => SUBRULE(builtInTimezone, void 0) },
-    { ALT: () => SUBRULE(builtInTz, void 0) },
-    { ALT: () => SUBRULE(builtInNow, void 0) },
-    { ALT: () => SUBRULE(builtInUuid, void 0) },
-    { ALT: () => SUBRULE(builtInStruuid, void 0) },
-    { ALT: () => SUBRULE(builtInMd5, void 0) },
-    { ALT: () => SUBRULE(builtInSha1, void 0) },
-    { ALT: () => SUBRULE(builtInSha256, void 0) },
-    { ALT: () => SUBRULE(builtInSha384, void 0) },
-    { ALT: () => SUBRULE(builtInSha512, void 0) },
-    { ALT: () => SUBRULE(builtInCoalesce, void 0) },
-    { ALT: () => SUBRULE(builtInIf, void 0) },
-    { ALT: () => SUBRULE(builtInStrlang, void 0) },
-    { ALT: () => SUBRULE(builtInStrdt, void 0) },
-    { ALT: () => SUBRULE(builtInSameterm, void 0) },
-    { ALT: () => SUBRULE(builtInIsiri, void 0) },
-    { ALT: () => SUBRULE(builtInIsuri, void 0) },
-    { ALT: () => SUBRULE(builtInIsblank, void 0) },
-    { ALT: () => SUBRULE(builtInIsliteral, void 0) },
-    { ALT: () => SUBRULE(builtInIsnumeric, void 0) },
-    { ALT: () => SUBRULE(regexExpression, void 0) },
-    { ALT: () => SUBRULE(existsFunc, void 0) },
-    { ALT: () => SUBRULE(notExistsFunc, void 0) }
-  ];
-}
-var builtInCall = {
-  name: "builtInCall",
-  impl: ({ OR, SUBRULE, cache }) => () => {
-    const cached = cache.get(builtInCall);
-    if (cached) {
-      return OR(cached);
+// ../rules-sparql-1-1/lib/grammar/whereClause.ts
+var whereClause = {
+  name: "whereClause",
+  impl: ({ ACTION, SUBRULE, CONSUME, OPTION }) => (C) => {
+    const where2 = OPTION(() => CONSUME(where));
+    const group = SUBRULE(groupGraphPattern);
+    return ACTION(() => C.factory.wrap(group, C.factory.sourceLocation(where2, group)));
+  },
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+    F3.printFilter(ast, () => PRINT_WORD("WHERE"));
+    SUBRULE(groupGraphPattern, ast.val);
+  }
+};
+var groupGraphPattern = {
+  name: "groupGraphPattern",
+  impl: ({ ACTION, SUBRULE, CONSUME, OR }) => (C) => {
+    const open = CONSUME(symbols_exports.LCurly);
+    const patterns = OR([
+      { ALT: () => [SUBRULE(subSelect)] },
+      { ALT: () => SUBRULE(groupGraphPatternSub) }
+    ]);
+    const close = CONSUME(symbols_exports.RCurly);
+    return ACTION(() => C.factory.patternGroup(patterns, C.factory.sourceLocation(open, close)));
+  },
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+    F3.printFilter(ast, () => PRINT_WORD("{"));
+    for (const pattern of ast.patterns) {
+      SUBRULE(generatePattern, pattern);
+    }
+    F3.printFilter(ast, () => PRINT_WORD("}"));
+  }
+};
+var generatePattern = {
+  name: "generatePattern",
+  gImpl: ({ SUBRULE }) => (ast, { factory: F3 }) => {
+    if (ast.type === "query") {
+      SUBRULE(query, F3.querySelect({
+        context: [],
+        datasets: F3.datasetClauses([], F3.sourceLocation()),
+        where: ast.where,
+        variables: ast.variables,
+        solutionModifiers: ast.solutionModifiers,
+        values: ast.values,
+        distinct: ast.distinct,
+        reduced: ast.reduced
+      }, ast.loc));
+    } else if (ast.subType === "group") {
+      SUBRULE(groupGraphPattern, ast);
+    } else if (ast.subType === "bgp") {
+      SUBRULE(triplesBlock, ast);
+    } else {
+      SUBRULE(graphPatternNotTriples, ast);
+    }
+  }
+};
+var groupGraphPatternSub = {
+  name: "groupGraphPatternSub",
+  impl: ({ ACTION, SUBRULE, CONSUME, MANY, SUBRULE1, SUBRULE2, OPTION1, OPTION2, OPTION3 }) => () => {
+    const patterns = [];
+    const bgpPattern = OPTION1(() => SUBRULE1(triplesBlock));
+    if (bgpPattern) {
+      patterns.push(bgpPattern);
+    }
+    MANY(() => {
+      const notTriples = SUBRULE(graphPatternNotTriples);
+      patterns.push(notTriples);
+      OPTION2(() => CONSUME(symbols_exports.dot));
+      const moreTriples = OPTION3(() => SUBRULE2(triplesBlock));
+      if (moreTriples) {
+        patterns.push(moreTriples);
+      }
+    });
+    ACTION(() => checkNote13(patterns));
+    return patterns;
+  }
+};
+var graphPatternNotTriples = {
+  name: "graphPatternNotTriples",
+  impl: ({ SUBRULE, OR }) => () => OR([
+    { ALT: () => SUBRULE(groupOrUnionGraphPattern) },
+    { ALT: () => SUBRULE(optionalGraphPattern) },
+    { ALT: () => SUBRULE(minusGraphPattern) },
+    { ALT: () => SUBRULE(graphGraphPattern) },
+    { ALT: () => SUBRULE(serviceGraphPattern) },
+    { ALT: () => SUBRULE(filter3) },
+    { ALT: () => SUBRULE(bind2) },
+    { ALT: () => SUBRULE(inlineData) }
+  ]),
+  gImpl: ({ SUBRULE }) => (ast) => {
+    switch (ast.subType) {
+      case "group":
+      case "union":
+        SUBRULE(groupOrUnionGraphPattern, ast);
+        break;
+      case "optional":
+        SUBRULE(optionalGraphPattern, ast);
+        break;
+      case "minus":
+        SUBRULE(minusGraphPattern, ast);
+        break;
+      case "graph":
+        SUBRULE(graphGraphPattern, ast);
+        break;
+      case "service":
+        SUBRULE(serviceGraphPattern, ast);
+        break;
+      case "filter":
+        SUBRULE(filter3, ast);
+        break;
+      case "bind":
+        SUBRULE(bind2, ast);
+        break;
+      case "values":
+        SUBRULE(inlineData, ast);
+        break;
+    }
+  }
+};
+var optionalGraphPattern = {
+  name: "optionalGraphPattern",
+  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
+    const optional2 = CONSUME(optional);
+    const group = SUBRULE(groupGraphPattern);
+    return ACTION(() => C.factory.patternOptional(group.patterns, C.factory.sourceLocation(optional2, group)));
+  },
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+    F3.printFilter(ast, () => PRINT_WORD("OPTIONAL"));
+    SUBRULE(groupGraphPattern, F3.patternGroup(ast.patterns, ast.loc));
+  }
+};
+var graphGraphPattern = {
+  name: "graphGraphPattern",
+  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
+    const graph2 = CONSUME(graph_exports.graph);
+    const name = SUBRULE(varOrIri);
+    const group = SUBRULE(groupGraphPattern);
+    return ACTION(() => C.factory.patternGraph(name, group.patterns, C.factory.sourceLocation(graph2, group)));
+  },
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+    F3.printFilter(ast, () => PRINT_WORD("GRAPH"));
+    SUBRULE(varOrTerm, ast.name);
+    SUBRULE(groupGraphPattern, F3.patternGroup(ast.patterns, ast.loc));
+  }
+};
+var serviceGraphPattern = {
+  name: "serviceGraphPattern",
+  impl: ({ ACTION, SUBRULE1, CONSUME, OPTION }) => (C) => {
+    const service2 = CONSUME(service);
+    const silent2 = OPTION(() => {
+      CONSUME(silent);
+      return true;
+    }) ?? false;
+    const name = SUBRULE1(varOrIri);
+    const group = SUBRULE1(groupGraphPattern);
+    return ACTION(() => C.factory.patternService(name, group.patterns, silent2, C.factory.sourceLocation(service2, group)));
+  },
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+    F3.printFilter(ast, () => {
+      PRINT_WORD("SERVICE");
+      if (ast.silent) {
+        PRINT_WORD("SILENT");
+      }
+    });
+    SUBRULE(varOrTerm, ast.name);
+    SUBRULE(groupGraphPattern, F3.patternGroup(ast.patterns, ast.loc));
+  }
+};
+var bind2 = {
+  name: "bind",
+  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
+    const bind3 = CONSUME(bind);
+    CONSUME(symbols_exports.LParen);
+    const expressionVal = SUBRULE(expression);
+    CONSUME(as);
+    const variable = SUBRULE(var_);
+    const close = CONSUME(symbols_exports.RParen);
+    return ACTION(() => C.factory.patternBind(expressionVal, variable, C.factory.sourceLocation(bind3, close)));
+  },
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+    F3.printFilter(ast, () => PRINT_WORD("BIND", "("));
+    SUBRULE(expression, ast.expression);
+    F3.printFilter(ast, () => PRINT_WORD("AS"));
+    SUBRULE(var_, ast.variable);
+    F3.printFilter(ast, () => PRINT_WORD(")"));
+  }
+};
+var inlineData = {
+  name: "inlineData",
+  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
+    const values3 = CONSUME(values2);
+    const datablock = SUBRULE(dataBlock);
+    return ACTION(() => C.factory.patternValues(datablock.val, C.factory.sourceLocation(values3, datablock)));
+  },
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+    const variables = Object.keys(ast.values[0]);
+    F3.printFilter(ast, () => {
+      PRINT_WORD("VALUES", "(");
+      for (const variable of variables) {
+        PRINT_WORD(`?${variable}`);
+      }
+      PRINT_WORD(")", "{");
+    });
+    for (const mapping of ast.values) {
+      F3.printFilter(ast, () => PRINT_WORD("("));
+      for (const variable of variables) {
+        if (mapping[variable] === void 0) {
+          F3.printFilter(ast, () => PRINT_WORD("UNDEF"));
+        } else {
+          SUBRULE(graphNodePath, mapping[variable]);
+        }
+      }
+      F3.printFilter(ast, () => PRINT_WORD(")"));
     }
-    const builtIns = builtInCallList(SUBRULE);
-    cache.set(builtInCall, builtIns);
-    return OR(builtIns);
+    F3.printFilter(ast, () => PRINT_WORD("}"));
   }
 };
-var regexExpression = funcExpr2or3(BuildinCalls_exports.regex);
-var substringExpression = funcExpr2or3(BuildinCalls_exports.substr);
-var strReplaceExpression = funcExpr3or4(BuildinCalls_exports.replace);
-var existsFunc = funcGroupGraphPattern(BuildinCalls_exports.exists);
-var notExistsFunc = funcGroupGraphPattern(BuildinCalls_exports.notexists);
-var aggregateCount = {
-  name: unCapitalize(BuildinCalls_exports.count.name),
-  impl: ({ ACTION, CONSUME, SUBRULE, OR, OPTION }) => (C) => {
-    const operatorToken = CONSUME(BuildinCalls_exports.count);
-    CONSUME(symbols_exports.LParen);
-    const distinctToken = OPTION(() => CONSUME(distinct));
-    const expressionVal = OR([
+var dataBlock = {
+  name: "dataBlock",
+  impl: ({ SUBRULE, OR }) => () => OR([
+    { ALT: () => SUBRULE(inlineDataOneVar) },
+    { ALT: () => SUBRULE(inlineDataFull) }
+  ])
+};
+var inlineDataOneVar = {
+  name: "inlineDataOneVar",
+  impl: ({ ACTION, SUBRULE, CONSUME, MANY }) => (C) => {
+    const res = [];
+    const varVal = SUBRULE(var_);
+    CONSUME(symbols_exports.LCurly);
+    MANY(() => {
+      const value = SUBRULE(dataBlockValue);
+      ACTION(() => {
+        res.push({ [varVal.value]: value });
+      });
+    });
+    const close = CONSUME(symbols_exports.RCurly);
+    return ACTION(() => C.factory.wrap(res, C.factory.sourceLocation(varVal, close)));
+  }
+};
+var inlineDataFull = {
+  name: "inlineDataFull",
+  impl: ({
+    ACTION,
+    OR,
+    MANY1,
+    MANY2,
+    MANY3,
+    MANY4,
+    SUBRULE,
+    CONSUME1,
+    CONSUME2
+  }) => (C) => {
+    const res = [];
+    const vars = [];
+    return OR([
       { ALT: () => {
-        const starToken = CONSUME(symbols_exports.star);
-        return ACTION(() => C.factory.wildcard(C.factory.sourceLocation(starToken)));
+        const nil2 = CONSUME1(terminals_exports.nil);
+        CONSUME1(symbols_exports.LCurly);
+        MANY1(() => {
+          CONSUME2(terminals_exports.nil);
+          res.push({});
+        });
+        const close = CONSUME1(symbols_exports.RCurly);
+        return ACTION(() => C.factory.wrap(res, C.factory.sourceLocation(nil2, close)));
       } },
-      { ALT: () => SUBRULE(expression, void 0) }
+      { ALT: () => {
+        const open = CONSUME1(symbols_exports.LParen);
+        MANY2(() => {
+          vars.push(SUBRULE(var_));
+        });
+        CONSUME1(symbols_exports.RParen);
+        CONSUME2(symbols_exports.LCurly);
+        MANY3(() => {
+          let parsedValues = 0;
+          const currentRow = {};
+          CONSUME2(symbols_exports.LParen);
+          MANY4(() => {
+            if (parsedValues >= vars.length) {
+              throw new Error("Number of dataBlockValues does not match number of variables. Too much values.");
+            }
+            const value = SUBRULE(dataBlockValue);
+            ACTION(() => {
+              currentRow[vars[parsedValues].value] = value;
+              parsedValues++;
+            });
+          });
+          CONSUME2(symbols_exports.RParen);
+          ACTION(() => {
+            res.push(currentRow);
+            if (vars.length !== parsedValues) {
+              throw new Error("Number of dataBlockValues does not match number of variables. Too few values.");
+            }
+          });
+        });
+        const close = CONSUME2(symbols_exports.RCurly);
+        return ACTION(() => C.factory.wrap(res, C.factory.sourceLocation(open, close)));
+      } }
     ]);
-    const closeToken = CONSUME(symbols_exports.RParen);
-    return ACTION(() => {
-      const F3 = C.factory;
-      if (C.factory.isWildcard(expressionVal)) {
-        return F3.aggregate(
-          operatorToken.image,
-          Boolean(distinctToken),
-          expressionVal,
-          void 0,
-          C.factory.sourceLocation(operatorToken, closeToken)
-        );
-      }
-      return F3.aggregate(
-        operatorToken.image,
-        Boolean(distinctToken),
-        expressionVal,
-        void 0,
-        C.factory.sourceLocation(operatorToken, closeToken)
-      );
-    });
   }
 };
-var aggregateSum = baseAggregateFunc(BuildinCalls_exports.sum);
-var aggregateMin = baseAggregateFunc(BuildinCalls_exports.min);
-var aggregateMax = baseAggregateFunc(BuildinCalls_exports.max);
-var aggregateAvg = baseAggregateFunc(BuildinCalls_exports.avg);
-var aggregateSample = baseAggregateFunc(BuildinCalls_exports.sample);
-var aggregateGroup_concat = {
-  name: unCapitalize(BuildinCalls_exports.groupConcat.name),
-  impl: ({ ACTION, CONSUME, OPTION1, SUBRULE, OPTION2 }) => (C) => {
-    const operatorToken = CONSUME(BuildinCalls_exports.groupConcat);
-    CONSUME(symbols_exports.LParen);
-    const distinctToken = OPTION1(() => CONSUME(distinct));
-    const expr = SUBRULE(expression, void 0);
-    const sep = OPTION2(() => {
-      CONSUME(symbols_exports.semi);
-      CONSUME(separator);
-      CONSUME(symbols_exports.equal);
-      return SUBRULE(string, void 0);
-    });
-    const closeToken = CONSUME(symbols_exports.RParen);
-    return ACTION(() => {
-      const F3 = C.factory;
-      return F3.aggregate(
-        operatorToken.image,
-        Boolean(distinctToken),
-        expr,
-        sep?.value ?? " ",
-        F3.sourceLocation(operatorToken, closeToken)
-      );
-    });
+var dataBlockValue = {
+  name: "dataBlockValue",
+  impl: ({ SUBRULE, CONSUME, OR }) => () => OR([
+    { ALT: () => SUBRULE(iri2) },
+    { ALT: () => SUBRULE(rdfLiteral) },
+    { ALT: () => SUBRULE(numericLiteral) },
+    { ALT: () => SUBRULE(booleanLiteral) },
+    { ALT: () => {
+      CONSUME(undef);
+      return void 0;
+    } }
+  ])
+};
+var minusGraphPattern = {
+  name: "minusGraphPattern",
+  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
+    const minus2 = CONSUME(minus);
+    const group = SUBRULE(groupGraphPattern);
+    return ACTION(() => C.factory.patternMinus(group.patterns, C.factory.sourceLocation(minus2, group)));
+  },
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+    F3.printFilter(ast, () => PRINT_WORD("MINUS"));
+    SUBRULE(groupGraphPattern, F3.patternGroup(ast.patterns, ast.loc));
   }
 };
-var aggregate = {
-  name: "aggregate",
-  impl: ({ ACTION, SUBRULE, OR }) => (C) => {
-    const wasInAggregate = ACTION(() => C.parseMode.has("inAggregate"));
-    ACTION(() => C.parseMode.add("inAggregate"));
-    const result = OR([
-      { ALT: () => SUBRULE(aggregateCount, void 0) },
-      { ALT: () => SUBRULE(aggregateSum, void 0) },
-      { ALT: () => SUBRULE(aggregateMin, void 0) },
-      { ALT: () => SUBRULE(aggregateMax, void 0) },
-      { ALT: () => SUBRULE(aggregateAvg, void 0) },
-      { ALT: () => SUBRULE(aggregateSample, void 0) },
-      { ALT: () => SUBRULE(aggregateGroup_concat, void 0) }
-    ]);
-    ACTION(() => !wasInAggregate && C.parseMode.delete("inAggregate"));
-    ACTION(() => {
-      if (!C.parseMode.has("canParseAggregate")) {
-        throw new Error("Aggregates are only allowed in SELECT, HAVING, and ORDER BY clauses.");
-      }
-      if (C.parseMode.has("inAggregate")) {
-        throw new Error("An aggregate function is not allowed within an aggregate function.");
-      }
+var groupOrUnionGraphPattern = {
+  name: "groupOrUnionGraphPattern",
+  impl: ({ ACTION, MANY, SUBRULE1, SUBRULE2, CONSUME }) => (C) => {
+    const groups = [];
+    const group = SUBRULE1(groupGraphPattern);
+    groups.push(group);
+    MANY(() => {
+      CONSUME(union);
+      const group2 = SUBRULE2(groupGraphPattern);
+      groups.push(group2);
     });
-    return result;
+    return ACTION(() => groups.length === 1 ? groups[0] : C.factory.patternUnion(
+      groups,
+      C.factory.sourceLocation(group, groups.at(-1))
+    ));
   },
   gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
-    F3.printFilter(ast, () => {
-      PRINT_WORD(ast.aggregation, "(");
-      if (ast.distinct) {
-        PRINT_WORD("DISTINCT");
+    if (F3.isPatternUnion(ast)) {
+      const [head2, ...tail] = ast.patterns;
+      SUBRULE(groupGraphPattern, head2);
+      for (const pattern of tail) {
+        F3.printFilter(ast, () => PRINT_WORD("UNION"));
+        SUBRULE(groupGraphPattern, pattern);
       }
-    });
-    const arg = ast.expression[0];
-    if (F3.isWildcard(arg)) {
-      F3.printFilter(ast, () => PRINT_WORD("*"));
     } else {
-      SUBRULE(expression, arg, void 0);
-    }
-    if (F3.isExpressionAggregateSeparator(ast)) {
-      F3.printFilter(ast, () => PRINT_WORD(";", "SEPARATOR", "=", stringEscapedLexical(ast.separator)));
+      SUBRULE(groupGraphPattern, ast);
     }
+  }
+};
+var filter3 = {
+  name: "filter",
+  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
+    const filterToken = CONSUME(filter2);
+    const expression2 = SUBRULE(constraint);
+    return ACTION(() => C.factory.patternFilter(expression2, C.factory.sourceLocation(filterToken, expression2)));
+  },
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
+    F3.printFilter(ast, () => PRINT_WORD("FILTER ("));
+    SUBRULE(expression, ast.expression);
     F3.printFilter(ast, () => PRINT_WORD(")"));
   }
 };
+var constraint = {
+  name: "constraint",
+  impl: ({ SUBRULE, OR }) => () => OR([
+    { ALT: () => SUBRULE(brackettedExpression) },
+    { ALT: () => SUBRULE(builtInCall) },
+    { ALT: () => SUBRULE(functionCall) }
+  ])
+};
+var functionCall = {
+  name: "functionCall",
+  impl: ({ ACTION, SUBRULE }) => (C) => {
+    const func = SUBRULE(iri2);
+    const args = SUBRULE(argList);
+    return ACTION(() => C.factory.expressionFunctionCall(
+      func,
+      args.val.args,
+      args.val.distinct,
+      C.factory.sourceLocation(func, args)
+    ));
+  }
+};
 
 // ../rules-sparql-1-1/lib/grammar/expression.ts
 var argList = {
@@ -13115,7 +13115,7 @@ var argList = {
       AT_LEAST_ONE_SEP({
         SEP: symbols_exports.comma,
         DEF: () => {
-          const arg = SUBRULE1(expression, void 0);
+          const arg = SUBRULE1(expression);
           args.push(arg);
         }
       });
@@ -13132,11 +13132,11 @@ var argList = {
     });
     const [head2, ...tail] = ast.val.args;
     if (head2) {
-      SUBRULE(expression, head2, void 0);
+      SUBRULE(expression, head2);
     }
     for (const expr of tail) {
       F3.printFilter(ast, () => PRINT_WORD(","));
-      SUBRULE(expression, expr, void 0);
+      SUBRULE(expression, expr);
     }
     F3.printFilter(ast, () => PRINT_WORD(")"));
   }
@@ -13150,11 +13150,11 @@ var expressionList = {
     } },
     { ALT: () => {
       const open = CONSUME(symbols_exports.LParen);
-      const expr1 = SUBRULE1(expression, void 0);
+      const expr1 = SUBRULE1(expression);
       const args = [expr1];
       MANY(() => {
         CONSUME(symbols_exports.comma);
-        const expr = SUBRULE2(expression, void 0);
+        const expr = SUBRULE2(expression);
         args.push(expr);
       });
       const close = CONSUME(symbols_exports.RParen);
@@ -13166,15 +13166,15 @@ var infixOperators = /* @__PURE__ */ new Set(["in", "notin", "||", "&&", "=", "!
 var prefixOperator = /* @__PURE__ */ new Set(["!", "UPLUS", "UMINUS"]);
 var expression = {
   name: "expression",
-  impl: ({ SUBRULE }) => () => SUBRULE(conditionalOrExpression, void 0),
+  impl: ({ SUBRULE }) => () => SUBRULE(conditionalOrExpression),
   gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
     if (F3.isTerm(ast)) {
-      SUBRULE(varOrTerm, ast, void 0);
+      SUBRULE(varOrTerm, ast);
     } else if (F3.isExpressionOperator(ast)) {
       if (infixOperators.has(ast.operator)) {
         const [left, ...right] = ast.args;
         F3.printFilter(ast, () => PRINT_WORD("("));
-        SUBRULE(expression, left, void 0);
+        SUBRULE(expression, left);
         F3.printFilter(ast, () => {
           if (ast.operator === "notin") {
             PRINT_WORD("NOT IN");
@@ -13185,35 +13185,35 @@ var expression = {
           }
         });
         if (right.length === 1) {
-          SUBRULE(expression, right[0], void 0);
+          SUBRULE(expression, right[0]);
         } else {
-          SUBRULE(argList, F3.wrap({ args: right, distinct: false }, ast.loc), void 0);
+          SUBRULE(argList, F3.wrap({ args: right, distinct: false }, ast.loc));
         }
         F3.printFilter(ast, () => PRINT_WORD(")"));
       } else if (prefixOperator.has(ast.operator)) {
         const [expr] = ast.args;
         F3.printFilter(ast, () => PRINT_WORD(ast.operator));
-        SUBRULE(expression, expr, void 0);
+        SUBRULE(expression, expr);
       } else {
         F3.printFilter(ast, () => PRINT_WORD(ast.operator, "("));
         const [head2, ...tail] = ast.args;
         if (head2) {
-          SUBRULE(expression, head2, void 0);
+          SUBRULE(expression, head2);
         }
         for (const arg of tail) {
           F3.printFilter(ast, () => PRINT_WORD(","));
-          SUBRULE(expression, arg, void 0);
+          SUBRULE(expression, arg);
         }
         F3.printFilter(ast, () => PRINT_WORD(")"));
       }
     } else if (F3.isExpressionPatternOperation(ast)) {
       const patterns = ast.args;
       F3.printFilter(ast, () => PRINT_WORD(ast.operator === "exists" ? "EXISTS" : "NOT EXISTS"));
-      SUBRULE(groupGraphPattern, patterns, void 0);
+      SUBRULE(groupGraphPattern, patterns);
     } else if (F3.isExpressionFunctionCall(ast)) {
-      SUBRULE(iriOrFunction, ast, void 0);
+      SUBRULE(iriOrFunction, ast);
     } else if (F3.isExpressionAggregate(ast)) {
-      SUBRULE(aggregate, ast, void 0);
+      SUBRULE(aggregate, ast);
     }
   }
 };
@@ -13230,10 +13230,10 @@ function constructLeftDeep(startGenerator, restGenerator, ACTION, MANY) {
 var conditionalOrExpression = {
   name: "conditionalOrExpression",
   impl: ({ ACTION, MANY, CONSUME, SUBRULE1, SUBRULE2 }) => (C) => constructLeftDeep(
-    () => SUBRULE1(conditionalAndExpression, void 0),
+    () => SUBRULE1(conditionalAndExpression),
     () => {
       CONSUME(symbols_exports.logicOr);
-      const args = SUBRULE2(conditionalAndExpression, void 0);
+      const args = SUBRULE2(conditionalAndExpression);
       return (left) => ACTION(() => C.factory.expressionOperation("||", [left, args], C.factory.sourceLocation(left, args)));
     },
     ACTION,
@@ -13243,10 +13243,10 @@ var conditionalOrExpression = {
 var conditionalAndExpression = {
   name: "conditionalAndExpression",
   impl: ({ ACTION, MANY, SUBRULE1, SUBRULE2, CONSUME }) => (C) => constructLeftDeep(
-    () => SUBRULE1(valueLogical, void 0),
+    () => SUBRULE1(valueLogical),
     () => {
       CONSUME(symbols_exports.logicAnd);
-      const arg = SUBRULE2(valueLogical, void 0);
+      const arg = SUBRULE2(valueLogical);
       return (left) => ACTION(() => C.factory.expressionOperation("&&", [left, arg], C.factory.sourceLocation(left, arg)));
     },
     ACTION,
@@ -13255,12 +13255,12 @@ var conditionalAndExpression = {
 };
 var valueLogical = {
   name: "valueLogical",
-  impl: ({ SUBRULE }) => () => SUBRULE(relationalExpression, void 0)
+  impl: ({ SUBRULE }) => () => SUBRULE(relationalExpression)
 };
 var relationalExpression = {
   name: "relationalExpression",
   impl: ({ ACTION, CONSUME, SUBRULE1, SUBRULE2, OPTION, OR1, OR2, OR3 }) => (C) => {
-    const args1 = SUBRULE1(numericExpression, void 0);
+    const args1 = SUBRULE1(numericExpression);
     const expression2 = OPTION(() => OR1([
       { ALT: () => {
         const operator = OR2([
@@ -13271,7 +13271,7 @@ var relationalExpression = {
           { ALT: () => CONSUME(symbols_exports.lessThanEqual) },
           { ALT: () => CONSUME(symbols_exports.greaterThanEqual) }
         ]);
-        const expr = SUBRULE2(numericExpression, void 0);
+        const expr = SUBRULE2(numericExpression);
         return ACTION(() => C.factory.expressionOperation(
           operator.image,
           [args1, expr],
@@ -13283,7 +13283,7 @@ var relationalExpression = {
           { ALT: () => CONSUME(in_) },
           { ALT: () => CONSUME(notIn) }
         ]);
-        const args = SUBRULE1(expressionList, void 0);
+        const args = SUBRULE1(expressionList);
         return ACTION(() => C.factory.expressionOperation(
           operator.image,
           [args1, ...args.val],
@@ -13296,25 +13296,25 @@ var relationalExpression = {
 };
 var numericExpression = {
   name: "numericExpression",
-  impl: ({ SUBRULE }) => () => SUBRULE(additiveExpression, void 0)
+  impl: ({ SUBRULE }) => () => SUBRULE(additiveExpression)
 };
 var additiveExpression = {
   name: "additiveExpression",
   impl: ({ ACTION, SUBRULE, CONSUME, SUBRULE1, SUBRULE2, MANY1, MANY2, OR1, OR2, OR3, OR4 }) => (C) => constructLeftDeep(
-    () => SUBRULE1(multiplicativeExpression, void 0),
+    () => SUBRULE1(multiplicativeExpression),
     () => OR1([
       { ALT: () => {
         const operator = OR2([
           { ALT: () => CONSUME(symbols_exports.opPlus) },
           { ALT: () => CONSUME(symbols_exports.opMinus) }
         ]);
-        const arg = SUBRULE2(multiplicativeExpression, void 0);
+        const arg = SUBRULE2(multiplicativeExpression);
         return ACTION(() => (left) => C.factory.expressionOperation(operator.image, [left, arg], C.factory.sourceLocation(left, arg)));
       } },
       { ALT: () => {
         const { operator, startInt } = OR3([
           { ALT: () => {
-            const integer2 = SUBRULE(numericLiteralPositive, void 0);
+            const integer2 = SUBRULE(numericLiteralPositive);
             return ACTION(() => {
               integer2.value = integer2.value.replace(/^\+/u, "");
               return {
@@ -13324,7 +13324,7 @@ var additiveExpression = {
             });
           } },
           { ALT: () => {
-            const integer2 = SUBRULE(numericLiteralNegative, void 0);
+            const integer2 = SUBRULE(numericLiteralNegative);
             return ACTION(() => {
               integer2.value = integer2.value.replace(/^-/u, "");
               return {
@@ -13341,7 +13341,7 @@ var additiveExpression = {
               { ALT: () => CONSUME(symbols_exports.star) },
               { ALT: () => CONSUME(symbols_exports.slash) }
             ]);
-            const innerExpr = SUBRULE1(unaryExpression, void 0);
+            const innerExpr = SUBRULE1(unaryExpression);
             return ACTION(() => (leftInner) => C.factory.expressionOperation(
               innerOperator.image,
               [leftInner, innerExpr],
@@ -13365,13 +13365,13 @@ var additiveExpression = {
 var multiplicativeExpression = {
   name: "multiplicativeExpression",
   impl: ({ ACTION, CONSUME, MANY, SUBRULE1, SUBRULE2, OR }) => (C) => constructLeftDeep(
-    () => SUBRULE1(unaryExpression, void 0),
+    () => SUBRULE1(unaryExpression),
     () => {
       const operator = OR([
         { ALT: () => CONSUME(symbols_exports.star) },
         { ALT: () => CONSUME(symbols_exports.slash) }
       ]);
-      const expr = SUBRULE2(unaryExpression, void 0);
+      const expr = SUBRULE2(unaryExpression);
       return (left) => ({
         type: "expression",
         subType: "operation",
@@ -13387,14 +13387,14 @@ var multiplicativeExpression = {
 var unaryExpression = {
   name: "unaryExpression",
   impl: ({ ACTION, CONSUME, SUBRULE1, SUBRULE2, OR1, OR2 }) => (C) => OR1([
-    { ALT: () => SUBRULE1(primaryExpression, void 0) },
+    { ALT: () => SUBRULE1(primaryExpression) },
     { ALT: () => {
       const operator = OR2([
         { ALT: () => CONSUME(symbols_exports.exclamation) },
         { ALT: () => CONSUME(symbols_exports.opPlus) },
         { ALT: () => CONSUME(symbols_exports.opMinus) }
       ]);
-      const expr = SUBRULE2(primaryExpression, void 0);
+      const expr = SUBRULE2(primaryExpression);
       return ACTION(() => ({
         type: "expression",
         subType: "operation",
@@ -13408,20 +13408,20 @@ var unaryExpression = {
 var primaryExpression = {
   name: "primaryExpression",
   impl: ({ SUBRULE, OR }) => () => OR([
-    { ALT: () => SUBRULE(brackettedExpression, void 0) },
-    { ALT: () => SUBRULE(builtInCall, void 0) },
-    { ALT: () => SUBRULE(iriOrFunction, void 0) },
-    { ALT: () => SUBRULE(rdfLiteral, void 0) },
-    { ALT: () => SUBRULE(numericLiteral, void 0) },
-    { ALT: () => SUBRULE(booleanLiteral, void 0) },
-    { ALT: () => SUBRULE(var_, void 0) }
+    { ALT: () => SUBRULE(brackettedExpression) },
+    { ALT: () => SUBRULE(builtInCall) },
+    { ALT: () => SUBRULE(iriOrFunction) },
+    { ALT: () => SUBRULE(rdfLiteral) },
+    { ALT: () => SUBRULE(numericLiteral) },
+    { ALT: () => SUBRULE(booleanLiteral) },
+    { ALT: () => SUBRULE(var_) }
   ])
 };
 var brackettedExpression = {
   name: "brackettedExpression",
   impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
     const open = CONSUME(symbols_exports.LParen);
-    const expr = SUBRULE(expression, void 0);
+    const expr = SUBRULE(expression);
     const close = CONSUME(symbols_exports.RParen);
     return ACTION(() => {
       expr.loc = C.factory.sourceLocation(open, close);
@@ -13432,9 +13432,9 @@ var brackettedExpression = {
 var iriOrFunction = {
   name: "iriOrFunction",
   impl: ({ ACTION, SUBRULE, OPTION }) => (C) => {
-    const iriVal = SUBRULE(iri2, void 0);
+    const iriVal = SUBRULE(iri2);
     const functionCall2 = OPTION(() => {
-      const args = SUBRULE(argList, void 0);
+      const args = SUBRULE(argList);
       return ACTION(() => {
         const distinct2 = args.val.distinct;
         if (!C.parseMode.has("canParseAggregate") && distinct2) {
@@ -13454,10 +13454,10 @@ var iriOrFunction = {
   },
   gImpl: ({ SUBRULE }) => (ast, { factory: F3 }) => {
     if (F3.isTermNamed(ast)) {
-      SUBRULE(iri2, ast, void 0);
+      SUBRULE(iri2, ast);
     } else {
-      SUBRULE(iri2, ast.function, void 0);
-      SUBRULE(argList, F3.wrap({ args: ast.args, distinct: ast.distinct }, ast.loc), void 0);
+      SUBRULE(iri2, ast.function);
+      SUBRULE(argList, F3.wrap({ args: ast.args, distinct: ast.distinct }, ast.loc));
     }
   }
 };
@@ -13466,10 +13466,10 @@ var iriOrFunction = {
 var solutionModifier = {
   name: "solutionModifier",
   impl: ({ ACTION, SUBRULE, OPTION1, OPTION2, OPTION3, OPTION4 }) => () => {
-    const group = OPTION1(() => SUBRULE(groupClause, void 0));
-    const having2 = OPTION2(() => SUBRULE(havingClause, void 0));
-    const order2 = OPTION3(() => SUBRULE(orderClause, void 0));
-    const limitOffset = OPTION4(() => SUBRULE(limitOffsetClauses, void 0));
+    const group = OPTION1(() => SUBRULE(groupClause));
+    const having2 = OPTION2(() => SUBRULE(havingClause));
+    const order2 = OPTION3(() => SUBRULE(orderClause));
+    const limitOffset = OPTION4(() => SUBRULE(limitOffsetClauses));
     return ACTION(() => ({
       ...limitOffset && { limitOffset },
       ...group && { group },
@@ -13479,16 +13479,16 @@ var solutionModifier = {
   },
   gImpl: ({ SUBRULE }) => (ast) => {
     if (ast.group) {
-      SUBRULE(groupClause, ast.group, void 0);
+      SUBRULE(groupClause, ast.group);
     }
     if (ast.having) {
-      SUBRULE(havingClause, ast.having, void 0);
+      SUBRULE(havingClause, ast.having);
     }
     if (ast.order) {
-      SUBRULE(orderClause, ast.order, void 0);
+      SUBRULE(orderClause, ast.order);
     }
     if (ast.limitOffset) {
-      SUBRULE(limitOffsetClauses, ast.limitOffset, void 0);
+      SUBRULE(limitOffsetClauses, ast.limitOffset);
     }
   }
 };
@@ -13499,7 +13499,7 @@ var groupClause = {
     const start = CONSUME(groupByGroup);
     CONSUME(by);
     AT_LEAST_ONE(() => {
-      groupings.push(SUBRULE1(groupCondition, void 0));
+      groupings.push(SUBRULE1(groupCondition));
     });
     return ACTION(() => ({
       type: "solutionModifier",
@@ -13512,12 +13512,12 @@ var groupClause = {
     F3.printFilter(ast, () => PRINT_WORDS("GROUP", "BY"));
     for (const grouping of ast.groupings) {
       if (F3.isExpression(grouping)) {
-        SUBRULE(expression, grouping, void 0);
+        SUBRULE(expression, grouping);
       } else {
         F3.printFilter(ast, () => PRINT_WORDS("("));
-        SUBRULE(expression, grouping.value, void 0);
+        SUBRULE(expression, grouping.value);
         F3.printFilter(ast, () => PRINT_WORDS("AS"));
-        SUBRULE(var_, grouping.variable, void 0);
+        SUBRULE(var_, grouping.variable);
         F3.printFilter(ast, () => PRINT_WORDS(")"));
       }
     }
@@ -13526,16 +13526,16 @@ var groupClause = {
 var groupCondition = {
   name: "groupCondition",
   impl: ({ ACTION, SUBRULE, CONSUME, SUBRULE1, SUBRULE2, OPTION, OR }) => (C) => OR([
-    { ALT: () => SUBRULE(builtInCall, void 0) },
-    { ALT: () => SUBRULE(functionCall, void 0) },
-    { ALT: () => SUBRULE2(var_, void 0) },
+    { ALT: () => SUBRULE(builtInCall) },
+    { ALT: () => SUBRULE(functionCall) },
+    { ALT: () => SUBRULE2(var_) },
     {
       ALT: () => {
         const open = CONSUME(symbols_exports.LParen);
-        const expressionValue = SUBRULE(expression, void 0);
+        const expressionValue = SUBRULE(expression);
         const variable = OPTION(() => {
           CONSUME(as);
-          return SUBRULE1(var_, void 0);
+          return SUBRULE1(var_);
         });
         const close = CONSUME(symbols_exports.RParen);
         return ACTION(() => {
@@ -13559,7 +13559,7 @@ var havingClause = {
     const expressions = [];
     const couldParseAgg = ACTION(() => C.parseMode.has("canParseAggregate") || !C.parseMode.add("canParseAggregate"));
     AT_LEAST_ONE(() => {
-      expressions.push(SUBRULE(havingCondition, void 0));
+      expressions.push(SUBRULE(havingCondition));
     });
     ACTION(() => !couldParseAgg && C.parseMode.delete("canParseAggregate"));
     return ACTION(() => C.factory.solutionModifierHaving(expressions, C.factory.sourceLocation(having2, expressions.at(-1))));
@@ -13567,13 +13567,13 @@ var havingClause = {
   gImpl: ({ PRINT_WORD, SUBRULE }) => (ast, { factory: F3 }) => {
     F3.printFilter(ast, () => PRINT_WORD("HAVING"));
     for (const having2 of ast.having) {
-      SUBRULE(expression, having2, void 0);
+      SUBRULE(expression, having2);
     }
   }
 };
 var havingCondition = {
   name: "havingCondition",
-  impl: ({ SUBRULE }) => () => SUBRULE(constraint, void 0)
+  impl: ({ SUBRULE }) => () => SUBRULE(constraint)
 };
 var orderClause = {
   name: "orderClause",
@@ -13583,7 +13583,7 @@ var orderClause = {
     const orderings = [];
     const couldParseAgg = ACTION(() => C.parseMode.has("canParseAggregate") || !C.parseMode.add("canParseAggregate"));
     AT_LEAST_ONE(() => {
-      orderings.push(SUBRULE1(orderCondition, void 0));
+      orderings.push(SUBRULE1(orderCondition));
     });
     ACTION(() => !couldParseAgg && C.parseMode.delete("canParseAggregate"));
     return ACTION(() => C.factory.solutionModifierOrder(orderings, C.factory.sourceLocation(order2, orderings.at(-1))));
@@ -13597,7 +13597,7 @@ var orderClause = {
         F3.printFilter(ast, () => PRINT_WORDS("ASC"));
       }
       F3.printFilter(ast, () => PRINT_WORDS("("));
-      SUBRULE(expression, ordering.expression, void 0);
+      SUBRULE(expression, ordering.expression);
       F3.printFilter(ast, () => PRINT_WORDS(")"));
     }
   }
@@ -13616,7 +13616,7 @@ var orderCondition = {
           return [true, token];
         } }
       ]);
-      const expr = SUBRULE(brackettedExpression, void 0);
+      const expr = SUBRULE(brackettedExpression);
       return ACTION(() => ({
         expression: expr,
         descending: descending[0],
@@ -13624,11 +13624,11 @@ var orderCondition = {
       }));
     } },
     { ALT: () => {
-      const expr = SUBRULE(constraint, void 0);
+      const expr = SUBRULE(constraint);
       return ACTION(() => ({ expression: expr, descending: false, loc: expr.loc }));
     } },
     { ALT: () => {
-      const expr = SUBRULE(var_, void 0);
+      const expr = SUBRULE(var_);
       return ACTION(() => ({ expression: expr, descending: false, loc: expr.loc }));
     } }
   ])
@@ -13637,8 +13637,8 @@ var limitOffsetClauses = {
   name: "limitOffsetClauses",
   impl: ({ ACTION, SUBRULE1, SUBRULE2, OPTION1, OPTION2, OR }) => (C) => OR([
     { ALT: () => {
-      const limit2 = SUBRULE1(limitClause, void 0);
-      const offset2 = OPTION1(() => SUBRULE1(offsetClause, void 0));
+      const limit2 = SUBRULE1(limitClause);
+      const offset2 = OPTION1(() => SUBRULE1(offsetClause));
       return ACTION(() => C.factory.solutionModifierLimitOffset(
         limit2.val,
         offset2?.val,
@@ -13646,8 +13646,8 @@ var limitOffsetClauses = {
       ));
     } },
     { ALT: () => {
-      const offset2 = SUBRULE2(offsetClause, void 0);
-      const limit2 = OPTION2(() => SUBRULE2(limitClause, void 0));
+      const offset2 = SUBRULE2(offsetClause);
+      const limit2 = OPTION2(() => SUBRULE2(limitClause));
       return ACTION(() => C.factory.solutionModifierLimitOffset(
         limit2?.val,
         offset2.val,
@@ -13685,22 +13685,22 @@ var offsetClause = {
   }
 };
 
-// ../rules-sparql-1-1/lib/grammar/queryUnit/queryUnit.ts
+// ../rules-sparql-1-1/lib/grammar/queryUnit.ts
 var queryUnit = {
   name: "queryUnit",
-  impl: ({ SUBRULE }) => () => SUBRULE(query, void 0)
+  impl: ({ SUBRULE }) => () => SUBRULE(query)
 };
 var query = {
   name: "query",
   impl: ({ ACTION, SUBRULE, OR }) => (C) => {
-    const prologueValues = SUBRULE(prologue, void 0);
+    const prologueValues = SUBRULE(prologue);
     const subType = OR([
-      { ALT: () => SUBRULE(selectQuery, void 0) },
-      { ALT: () => SUBRULE(constructQuery, void 0) },
-      { ALT: () => SUBRULE(describeQuery, void 0) },
-      { ALT: () => SUBRULE(askQuery, void 0) }
+      { ALT: () => SUBRULE(selectQuery) },
+      { ALT: () => SUBRULE(constructQuery) },
+      { ALT: () => SUBRULE(describeQuery) },
+      { ALT: () => SUBRULE(askQuery) }
     ]);
-    const values3 = SUBRULE(valuesClause, void 0);
+    const values3 = SUBRULE(valuesClause);
     return ACTION(() => ({
       context: prologueValues,
       ...subType,
@@ -13714,28 +13714,28 @@ var query = {
     }));
   },
   gImpl: ({ SUBRULE }) => (ast, { factory: F3 }) => {
-    SUBRULE(prologue, ast.context, void 0);
+    SUBRULE(prologue, ast.context);
     if (F3.isQuerySelect(ast)) {
-      SUBRULE(selectQuery, ast, void 0);
+      SUBRULE(selectQuery, ast);
     } else if (F3.isQueryConstruct(ast)) {
-      SUBRULE(constructQuery, ast, void 0);
+      SUBRULE(constructQuery, ast);
     } else if (F3.isQueryDescribe(ast)) {
-      SUBRULE(describeQuery, ast, void 0);
+      SUBRULE(describeQuery, ast);
     } else if (F3.isQueryAsk(ast)) {
-      SUBRULE(askQuery, ast, void 0);
+      SUBRULE(askQuery, ast);
     }
     if (ast.values) {
-      SUBRULE(inlineData, ast.values, void 0);
+      SUBRULE(inlineData, ast.values);
     }
   }
 };
 var selectQuery = {
   name: "selectQuery",
   impl: ({ ACTION, SUBRULE }) => (C) => {
-    const selectVal = SUBRULE(selectClause, void 0);
-    const from2 = SUBRULE(datasetClauseStar, void 0);
-    const where2 = SUBRULE(whereClause, void 0);
-    const modifiers = SUBRULE(solutionModifier, void 0);
+    const selectVal = SUBRULE(selectClause);
+    const from2 = SUBRULE(datasetClauseStar);
+    const where2 = SUBRULE(whereClause);
+    const modifiers = SUBRULE(solutionModifier);
     return ACTION(() => {
       const ret = {
         subType: "select",
@@ -13761,19 +13761,19 @@ var selectQuery = {
       variables: ast.variables,
       distinct: ast.distinct,
       reduced: ast.reduced
-    }, F3.sourceLocation(...ast.variables)), void 0);
-    SUBRULE(datasetClauseStar, ast.datasets, void 0);
-    SUBRULE(whereClause, F3.wrap(ast.where, ast.where.loc), void 0);
-    SUBRULE(solutionModifier, ast.solutionModifiers, void 0);
+    }, F3.sourceLocation(...ast.variables)));
+    SUBRULE(datasetClauseStar, ast.datasets);
+    SUBRULE(whereClause, F3.wrap(ast.where, ast.where.loc));
+    SUBRULE(solutionModifier, ast.solutionModifiers);
   }
 };
 var subSelect = {
   name: "subSelect",
   impl: ({ ACTION, SUBRULE }) => (C) => {
-    const selectVal = SUBRULE(selectClause, void 0);
-    const where2 = SUBRULE(whereClause, void 0);
-    const modifiers = SUBRULE(solutionModifier, void 0);
-    const values3 = SUBRULE(valuesClause, void 0);
+    const selectVal = SUBRULE(selectClause);
+    const where2 = SUBRULE(whereClause);
+    const modifiers = SUBRULE(solutionModifier);
+    const values3 = SUBRULE(valuesClause);
     return ACTION(() => C.factory.querySelect({
       where: where2.val,
       datasets: C.factory.datasetClauses([], C.factory.sourceLocation()),
@@ -13838,7 +13838,7 @@ var selectClause = {
         const variables = [];
         AT_LEAST_ONE(() => OR3([
           { ALT: () => {
-            const raw = SUBRULE1(var_, void 0);
+            const raw = SUBRULE1(var_);
             ACTION(() => {
               if (usedVars.some((v) => v.value === raw.value)) {
                 throw new Error(`Variable ${raw.value} used more than once in SELECT clause`);
@@ -13850,9 +13850,9 @@ var selectClause = {
           } },
           { ALT: () => {
             const open = CONSUME(symbols_exports.LParen);
-            const expr = SUBRULE1(expression, void 0);
+            const expr = SUBRULE1(expression);
             CONSUME(as);
-            const variable = SUBRULE2(var_, void 0);
+            const variable = SUBRULE2(var_);
             const close = CONSUME(symbols_exports.RParen);
             ACTION(() => {
               last2 = close;
@@ -13883,12 +13883,12 @@ var selectClause = {
       if (F3.isWildcard(variable)) {
         F3.printFilter(ast, () => PRINT_WORD("*"));
       } else if (F3.isTerm(variable)) {
-        SUBRULE(var_, variable, void 0);
+        SUBRULE(var_, variable);
       } else {
         F3.printFilter(ast, () => PRINT_WORD("("));
-        SUBRULE(expression, variable.expression, void 0);
+        SUBRULE(expression, variable.expression);
         F3.printFilter(ast, () => PRINT_WORD("AS"));
-        SUBRULE(var_, variable.variable, void 0);
+        SUBRULE(var_, variable.variable);
         F3.printFilter(ast, () => PRINT_WORD(")"));
       }
     }
@@ -13900,10 +13900,10 @@ var constructQuery = {
     const construct2 = CONSUME(construct);
     return OR([
       { ALT: () => {
-        const template = SUBRULE1(constructTemplate, void 0);
-        const from2 = SUBRULE1(datasetClauseStar, void 0);
-        const where2 = SUBRULE1(whereClause, void 0);
-        const modifiers = SUBRULE1(solutionModifier, void 0);
+        const template = SUBRULE1(constructTemplate);
+        const from2 = SUBRULE1(datasetClauseStar);
+        const where2 = SUBRULE1(whereClause);
+        const modifiers = SUBRULE1(solutionModifier);
         return ACTION(() => ({
           subType: "construct",
           template: template.val,
@@ -13921,10 +13921,10 @@ var constructQuery = {
         }));
       } },
       { ALT: () => {
-        const from2 = SUBRULE2(datasetClauseStar, void 0);
+        const from2 = SUBRULE2(datasetClauseStar);
         CONSUME(where);
-        const template = SUBRULE2(constructTemplate, void 0);
-        const modifiers = SUBRULE2(solutionModifier, void 0);
+        const template = SUBRULE2(constructTemplate);
+        const modifiers = SUBRULE2(solutionModifier);
         return ACTION(() => ({
           subType: "construct",
           template: template.val,
@@ -13947,16 +13947,16 @@ var constructQuery = {
     F3.printFilter(ast, () => PRINT_WORD("CONSTRUCT"));
     if (!F3.isSourceLocationNoMaterialize(ast.where.loc)) {
       F3.printFilter(ast, () => PRINT_WORD("{"));
-      SUBRULE(triplesBlock, ast.template, void 0);
+      SUBRULE(triplesBlock, ast.template);
       F3.printFilter(ast, () => PRINT_WORD("}"));
     }
-    SUBRULE(datasetClauseStar, ast.datasets, void 0);
+    SUBRULE(datasetClauseStar, ast.datasets);
     if (F3.isSourceLocationNoMaterialize(ast.where.loc)) {
-      SUBRULE(whereClause, F3.wrap(F3.patternGroup([ast.template], ast.template.loc), ast.template.loc), void 0);
+      SUBRULE(whereClause, F3.wrap(F3.patternGroup([ast.template], ast.template.loc), ast.template.loc));
     } else {
-      SUBRULE(whereClause, F3.wrap(ast.where, ast.where.loc), void 0);
+      SUBRULE(whereClause, F3.wrap(ast.where, ast.where.loc));
     }
-    SUBRULE(solutionModifier, ast.solutionModifiers, void 0);
+    SUBRULE(solutionModifier, ast.solutionModifiers);
   }
 };
 var describeQuery = {
@@ -13967,7 +13967,7 @@ var describeQuery = {
       { ALT: () => {
         const variables2 = [];
         AT_LEAST_ONE(() => {
-          variables2.push(SUBRULE1(varOrIri, void 0));
+          variables2.push(SUBRULE1(varOrIri));
         });
         return variables2;
       } },
@@ -13976,9 +13976,9 @@ var describeQuery = {
         return [ACTION(() => C.factory.wildcard(C.factory.sourceLocation(star2)))];
       } }
     ]);
-    const from2 = SUBRULE1(datasetClauseStar, void 0);
-    const where2 = OPTION(() => SUBRULE1(whereClause, void 0));
-    const modifiers = SUBRULE1(solutionModifier, void 0);
+    const from2 = SUBRULE1(datasetClauseStar);
+    const where2 = OPTION(() => SUBRULE1(whereClause));
+    const modifiers = SUBRULE1(solutionModifier);
     return ACTION(() => ({
       subType: "describe",
       variables,
@@ -14003,23 +14003,23 @@ var describeQuery = {
       F3.printFilter(ast, () => PRINT_WORD("*"));
     } else {
       for (const variable of ast.variables) {
-        SUBRULE(varOrTerm, variable, void 0);
+        SUBRULE(varOrTerm, variable);
       }
     }
-    SUBRULE(datasetClauseStar, ast.datasets, void 0);
+    SUBRULE(datasetClauseStar, ast.datasets);
     if (ast.where) {
-      SUBRULE(whereClause, F3.wrap(ast.where, ast.loc), void 0);
+      SUBRULE(whereClause, F3.wrap(ast.where, ast.loc));
     }
-    SUBRULE(solutionModifier, ast.solutionModifiers, void 0);
+    SUBRULE(solutionModifier, ast.solutionModifiers);
   }
 };
 var askQuery = {
   name: "askQuery",
   impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
     const ask2 = CONSUME(ask);
-    const from2 = SUBRULE(datasetClauseStar, void 0);
-    const where2 = SUBRULE(whereClause, void 0);
-    const modifiers = SUBRULE(solutionModifier, void 0);
+    const from2 = SUBRULE(datasetClauseStar);
+    const where2 = SUBRULE(whereClause);
+    const modifiers = SUBRULE(solutionModifier);
     return ACTION(() => ({
       subType: "ask",
       datasets: from2,
@@ -14038,20 +14038,20 @@ var askQuery = {
   },
   gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
     F3.printFilter(ast, () => PRINT_WORD("ASK"));
-    SUBRULE(datasetClauseStar, ast.datasets, void 0);
-    SUBRULE(whereClause, F3.wrap(ast.where, ast.loc), void 0);
-    SUBRULE(solutionModifier, ast.solutionModifiers, void 0);
+    SUBRULE(datasetClauseStar, ast.datasets);
+    SUBRULE(whereClause, F3.wrap(ast.where, ast.loc));
+    SUBRULE(solutionModifier, ast.solutionModifiers);
   }
 };
 var valuesClause = {
   name: "valuesClause",
-  impl: ({ OPTION, SUBRULE }) => () => OPTION(() => SUBRULE(inlineData, void 0))
+  impl: ({ OPTION, SUBRULE }) => () => OPTION(() => SUBRULE(inlineData))
 };
 var constructTemplate = {
   name: "constructTemplate",
   impl: ({ ACTION, SUBRULE1, CONSUME, OPTION }) => (C) => {
     const open = CONSUME(symbols_exports.LCurly);
-    const triples = OPTION(() => SUBRULE1(constructTriples, void 0));
+    const triples = OPTION(() => SUBRULE1(constructTriples));
     const close = CONSUME(symbols_exports.RCurly);
     return ACTION(() => C.factory.wrap(
       triples ?? C.factory.patternBgp([], C.factory.sourceLocation()),
@@ -14064,27 +14064,27 @@ var constructTriples = {
   impl: triplesTemplate.impl
 };
 
-// ../rules-sparql-1-1/lib/grammar/updateUnit/updateUnit.ts
+// ../rules-sparql-1-1/lib/grammar/updateUnit.ts
 var updateUnit = {
   name: "updateUnit",
-  impl: ({ SUBRULE }) => () => SUBRULE(update, void 0)
+  impl: ({ SUBRULE }) => () => SUBRULE(update)
 };
 var update = {
   name: "update",
   impl: ({ ACTION, SUBRULE, SUBRULE1, SUBRULE2, CONSUME, OPTION1, MANY }) => (C) => {
     const updates = [];
-    const prologueValues = SUBRULE1(prologue, void 0);
+    const prologueValues = SUBRULE1(prologue);
     updates.push({ context: prologueValues });
     let parsedSemi = true;
     MANY({
       GATE: () => parsedSemi,
       DEF: () => {
         parsedSemi = false;
-        updates.at(-1).operation = SUBRULE(update1, void 0);
+        updates.at(-1).operation = SUBRULE(update1);
         OPTION1(() => {
           CONSUME(symbols_exports.semi);
           parsedSemi = true;
-          const innerPrologue = SUBRULE2(prologue, void 0);
+          const innerPrologue = SUBRULE2(prologue);
           updates.push({ context: innerPrologue });
         });
       }
@@ -14106,9 +14106,9 @@ var update = {
   },
   gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
     for (const update2 of ast.updates) {
-      SUBRULE(prologue, update2.context, void 0);
+      SUBRULE(prologue, update2.context);
       if (update2.operation) {
-        SUBRULE(update1, update2.operation, void 0);
+        SUBRULE(update1, update2.operation);
         F3.printFilter(ast, () => PRINT_WORD(" ;\n"));
       }
     }
@@ -14117,52 +14117,52 @@ var update = {
 var update1 = {
   name: "update1",
   impl: ({ SUBRULE, OR }) => () => OR([
-    { ALT: () => SUBRULE(load2, void 0) },
-    { ALT: () => SUBRULE(clear2, void 0) },
-    { ALT: () => SUBRULE(drop3, void 0) },
-    { ALT: () => SUBRULE(add2, void 0) },
-    { ALT: () => SUBRULE(move2, void 0) },
-    { ALT: () => SUBRULE(copy2, void 0) },
-    { ALT: () => SUBRULE(create2, void 0) },
-    { ALT: () => SUBRULE(insertData, void 0) },
-    { ALT: () => SUBRULE(deleteData, void 0) },
-    { ALT: () => SUBRULE(deleteWhere, void 0) },
-    { ALT: () => SUBRULE(modify, void 0) }
+    { ALT: () => SUBRULE(load2) },
+    { ALT: () => SUBRULE(clear2) },
+    { ALT: () => SUBRULE(drop3) },
+    { ALT: () => SUBRULE(add2) },
+    { ALT: () => SUBRULE(move2) },
+    { ALT: () => SUBRULE(copy2) },
+    { ALT: () => SUBRULE(create2) },
+    { ALT: () => SUBRULE(insertData) },
+    { ALT: () => SUBRULE(deleteData) },
+    { ALT: () => SUBRULE(deleteWhere) },
+    { ALT: () => SUBRULE(modify) }
   ]),
   gImpl: ({ SUBRULE }) => (ast) => {
     switch (ast.subType) {
       case "load":
-        SUBRULE(load2, ast, void 0);
+        SUBRULE(load2, ast);
         break;
       case "clear":
-        SUBRULE(clear2, ast, void 0);
+        SUBRULE(clear2, ast);
         break;
       case "drop":
-        SUBRULE(drop3, ast, void 0);
+        SUBRULE(drop3, ast);
         break;
       case "add":
-        SUBRULE(add2, ast, void 0);
+        SUBRULE(add2, ast);
         break;
       case "move":
-        SUBRULE(move2, ast, void 0);
+        SUBRULE(move2, ast);
         break;
       case "copy":
-        SUBRULE(copy2, ast, void 0);
+        SUBRULE(copy2, ast);
         break;
       case "create":
-        SUBRULE(create2, ast, void 0);
+        SUBRULE(create2, ast);
         break;
       case "insertdata":
-        SUBRULE(insertData, ast, void 0);
+        SUBRULE(insertData, ast);
         break;
       case "deletedata":
-        SUBRULE(deleteData, ast, void 0);
+        SUBRULE(deleteData, ast);
         break;
       case "deletewhere":
-        SUBRULE(deleteWhere, ast, void 0);
+        SUBRULE(deleteWhere, ast);
         break;
       case "modify":
-        SUBRULE(modify, ast, void 0);
+        SUBRULE(modify, ast);
         break;
     }
   }
@@ -14172,10 +14172,10 @@ var load2 = {
   impl: ({ ACTION, SUBRULE1, CONSUME, OPTION1, OPTION2 }) => (C) => {
     const loadToken = CONSUME(load);
     const silent2 = OPTION1(() => CONSUME(silent));
-    const source = SUBRULE1(iri2, void 0);
+    const source = SUBRULE1(iri2);
     const destination = OPTION2(() => {
       CONSUME(loadInto);
-      return SUBRULE1(graphRef, void 0);
+      return SUBRULE1(graphRef);
     });
     return ACTION(() => C.factory.updateOperationLoad(
       C.factory.sourceLocation(loadToken, source, destination),
@@ -14191,10 +14191,10 @@ var load2 = {
         PRINT_WORD("SILENT");
       }
     });
-    SUBRULE(iri2, ast.source, void 0);
+    SUBRULE(iri2, ast.source);
     if (ast.destination) {
       F3.printFilter(ast, () => PRINT_WORD("INTO"));
-      SUBRULE(graphRefAll, ast.destination, void 0);
+      SUBRULE(graphRefAll, ast.destination);
     }
   }
 };
@@ -14204,7 +14204,7 @@ function clearOrDrop(operation) {
     impl: ({ ACTION, SUBRULE1, CONSUME, OPTION }) => (C) => {
       const opToken = CONSUME(operation);
       const silent2 = OPTION(() => CONSUME(silent));
-      const destination = SUBRULE1(graphRefAll, void 0);
+      const destination = SUBRULE1(graphRefAll);
       return ACTION(() => C.factory.updateOperationClearDrop(
         unCapitalize(operation.name),
         Boolean(silent2),
@@ -14219,7 +14219,7 @@ function clearOrDrop(operation) {
           PRINT_WORD("SILENT");
         }
       });
-      SUBRULE(graphRefAll, ast.destination, void 0);
+      SUBRULE(graphRefAll, ast.destination);
     }
   };
 }
@@ -14230,7 +14230,7 @@ var create2 = {
   impl: ({ ACTION, SUBRULE1, CONSUME, OPTION }) => (C) => {
     const createToken3 = CONSUME(create);
     const silent2 = OPTION(() => CONSUME(silent));
-    const destination = SUBRULE1(graphRef, void 0);
+    const destination = SUBRULE1(graphRef);
     return ACTION(() => C.factory.updateOperationCreate(
       destination,
       Boolean(silent2),
@@ -14244,7 +14244,7 @@ var create2 = {
         PRINT_WORD("SILENT");
       }
     });
-    SUBRULE(graphRefAll, ast.destination, void 0);
+    SUBRULE(graphRefAll, ast.destination);
   }
 };
 function copyMoveAddOperation(operation) {
@@ -14253,9 +14253,9 @@ function copyMoveAddOperation(operation) {
     impl: ({ ACTION, CONSUME, SUBRULE1, SUBRULE2, OPTION }) => (C) => {
       const op = CONSUME(operation);
       const silent2 = OPTION(() => CONSUME(silent));
-      const source = SUBRULE1(graphOrDefault, void 0);
+      const source = SUBRULE1(graphOrDefault);
       CONSUME(to);
-      const destination = SUBRULE2(graphOrDefault, void 0);
+      const destination = SUBRULE2(graphOrDefault);
       return ACTION(() => C.factory.updateOperationAddMoveCopy(
         unCapitalize(operation.name),
         source,
@@ -14271,9 +14271,9 @@ function copyMoveAddOperation(operation) {
           PRINT_WORD("SILENT");
         }
       });
-      SUBRULE(graphRefAll, ast.source, void 0);
+      SUBRULE(graphRefAll, ast.source);
       F3.printFilter(ast, () => PRINT_WORD("TO"));
-      SUBRULE(graphRefAll, ast.destination, void 0);
+      SUBRULE(graphRefAll, ast.destination);
     }
   };
 }
@@ -14284,7 +14284,7 @@ var quadPattern = {
   name: "quadPattern",
   impl: ({ ACTION, SUBRULE1, CONSUME }) => (C) => {
     const open = CONSUME(symbols_exports.LCurly);
-    const val = SUBRULE1(quads, void 0);
+    const val = SUBRULE1(quads);
     const close = CONSUME(symbols_exports.RCurly);
     return ACTION(() => C.factory.wrap(val.val, C.factory.sourceLocation(open, close)));
   }
@@ -14294,7 +14294,7 @@ var quadData = {
   impl: ({ ACTION, SUBRULE1, CONSUME }) => (C) => {
     const open = CONSUME(symbols_exports.LCurly);
     const couldParseVars = ACTION(() => C.parseMode.delete("canParseVars"));
-    const val = SUBRULE1(quads, void 0);
+    const val = SUBRULE1(quads);
     ACTION(() => couldParseVars && C.parseMode.add("canParseVars"));
     const close = CONSUME(symbols_exports.RCurly);
     return ACTION(() => C.factory.wrap(val.val, C.factory.sourceLocation(open, close)));
@@ -14310,7 +14310,7 @@ function insertDeleteDelWhere(name, subType, cons1, cons2, dataRule) {
       if (name !== "insertData") {
         couldCreateBlankNodes = ACTION(() => C.parseMode.delete("canCreateBlankNodes"));
       }
-      const data = SUBRULE1(dataRule, void 0);
+      const data = SUBRULE1(dataRule);
       if (name !== "insertData") {
         ACTION(() => couldCreateBlankNodes && C.parseMode.add("canCreateBlankNodes"));
       }
@@ -14321,7 +14321,7 @@ function insertDeleteDelWhere(name, subType, cons1, cons2, dataRule) {
         subType === "insertdata" ? "INSERT DATA" : subType === "deletedata" ? "DELETE DATA" : "DELETE WHERE",
         "{"
       ));
-      SUBRULE(quads, F3.wrap(ast.data, ast.loc), void 0);
+      SUBRULE(quads, F3.wrap(ast.data, ast.loc));
       F3.printFilter(ast, () => PRINT_WORD("}"));
     }
   };
@@ -14334,23 +14334,23 @@ var modify = {
   impl: ({ ACTION, CONSUME, SUBRULE1, SUBRULE2, OPTION1, OPTION2, OR }) => (C) => {
     const graph2 = OPTION1(() => {
       const withToken = CONSUME(modifyWith);
-      const graph3 = SUBRULE1(iri2, void 0);
+      const graph3 = SUBRULE1(iri2);
       return { withToken, graph: graph3 };
     });
     const { insert, del } = OR([
       { ALT: () => {
-        const del2 = SUBRULE1(deleteClause2, void 0);
-        const insert2 = OPTION2(() => SUBRULE1(insertClause2, void 0));
+        const del2 = SUBRULE1(deleteClause2);
+        const insert2 = OPTION2(() => SUBRULE1(insertClause2));
         return { del: del2, insert: insert2 };
       } },
       { ALT: () => {
-        const insert2 = SUBRULE2(insertClause2, void 0);
+        const insert2 = SUBRULE2(insertClause2);
         return { insert: insert2, del: void 0 };
       } }
     ]);
-    const using = SUBRULE1(usingClauseStar, void 0);
+    const using = SUBRULE1(usingClauseStar);
     CONSUME(where);
-    const where2 = SUBRULE1(groupGraphPattern, void 0);
+    const where2 = SUBRULE1(groupGraphPattern);
     return ACTION(() => C.factory.updateOperationModify(
       C.factory.sourceLocation(graph2?.withToken, del, insert, where2),
       insert?.val ?? [],
@@ -14363,21 +14363,21 @@ var modify = {
   gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
     if (ast.graph) {
       F3.printFilter(ast, () => PRINT_WORD("WITH"));
-      SUBRULE(iri2, ast.graph, void 0);
+      SUBRULE(iri2, ast.graph);
     }
     if (ast.delete.length > 0) {
       F3.printFilter(ast, () => PRINT_WORD("DELETE", "{"));
-      SUBRULE(quads, F3.wrap(ast.delete, ast.loc), void 0);
+      SUBRULE(quads, F3.wrap(ast.delete, ast.loc));
       F3.printFilter(ast, () => PRINT_WORD("}"));
     }
     if (ast.insert.length > 0) {
       F3.printFilter(ast, () => PRINT_WORD("INSERT", "{"));
-      SUBRULE(quads, F3.wrap(ast.insert, ast.loc), void 0);
+      SUBRULE(quads, F3.wrap(ast.insert, ast.loc));
       F3.printFilter(ast, () => PRINT_WORD("}"));
     }
-    SUBRULE(usingClauseStar, ast.from, void 0);
+    SUBRULE(usingClauseStar, ast.from);
     F3.printFilter(ast, () => PRINT_WORD("WHERE"));
-    SUBRULE(groupGraphPattern, ast.where, void 0);
+    SUBRULE(groupGraphPattern, ast.where);
   }
 };
 var deleteClause2 = {
@@ -14385,7 +14385,7 @@ var deleteClause2 = {
   impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
     const delToken = CONSUME(deleteClause);
     const couldCreateBlankNodes = ACTION(() => C.parseMode.delete("canCreateBlankNodes"));
-    const del = SUBRULE(quadPattern, void 0);
+    const del = SUBRULE(quadPattern);
     ACTION(() => couldCreateBlankNodes && C.parseMode.add("canCreateBlankNodes"));
     return ACTION(() => C.factory.wrap(del.val, C.factory.sourceLocation(delToken, del)));
   }
@@ -14394,7 +14394,7 @@ var insertClause2 = {
   name: "insertClause",
   impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
     const insertToken = CONSUME(insertClause);
-    const insert = SUBRULE(quadPattern, void 0);
+    const insert = SUBRULE(quadPattern);
     return ACTION(() => C.factory.wrap(insert.val, C.factory.sourceLocation(insertToken, insert)));
   }
 };
@@ -14407,7 +14407,7 @@ var graphOrDefault = {
     } },
     { ALT: () => {
       const graph2 = OPTION(() => CONSUME(graph_exports.graph));
-      const name = SUBRULE1(iri2, void 0);
+      const name = SUBRULE1(iri2);
       return ACTION(() => C.factory.graphRefSpecific(name, C.factory.sourceLocation(graph2, name)));
     } }
   ])
@@ -14416,18 +14416,18 @@ var graphRef = {
   name: "graphRef",
   impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
     const graph2 = CONSUME(graph_exports.graph);
-    const val = SUBRULE(iri2, void 0);
+    const val = SUBRULE(iri2);
     return ACTION(() => C.factory.graphRefSpecific(val, C.factory.sourceLocation(graph2, val)));
   },
   gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
     F3.printFilter(ast, () => PRINT_WORD("GRAPH"));
-    SUBRULE(iri2, ast.graph, void 0);
+    SUBRULE(iri2, ast.graph);
   }
 };
 var graphRefAll = {
   name: "graphRefAll",
   impl: ({ ACTION, SUBRULE, CONSUME, OR }) => (C) => OR([
-    { ALT: () => SUBRULE(graphRef, void 0) },
+    { ALT: () => SUBRULE(graphRef) },
     { ALT: () => {
       const def = CONSUME(graph_exports.default_);
       return ACTION(() => C.factory.graphRefDefault(C.factory.sourceLocation(def)));
@@ -14443,7 +14443,7 @@ var graphRefAll = {
   ]),
   gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
     if (F3.isGraphRefSpecific(ast)) {
-      SUBRULE(graphRef, ast, void 0);
+      SUBRULE(graphRef, ast);
     } else if (F3.isGraphRefDefault(ast)) {
       F3.printFilter(ast, () => PRINT_WORD("DEFAULT"));
     } else if (F3.isGraphRefNamed(ast)) {
@@ -14459,12 +14459,12 @@ var quads = {
     const quads2 = [];
     let last2;
     OPTION1(() => {
-      const triples = SUBRULE1(triplesTemplate, void 0);
+      const triples = SUBRULE1(triplesTemplate);
       last2 = triples;
       ACTION(() => quads2.push(triples));
     });
     MANY(() => {
-      const notTriples = SUBRULE(quadsNotTriples, void 0);
+      const notTriples = SUBRULE(quadsNotTriples);
       last2 = notTriples;
       quads2.push(notTriples);
       OPTION2(() => {
@@ -14473,7 +14473,7 @@ var quads = {
         return dotToken;
       });
       OPTION3(() => {
-        const triples = SUBRULE2(triplesTemplate, void 0);
+        const triples = SUBRULE2(triplesTemplate);
         last2 = triples;
         ACTION(() => quads2.push(triples));
       });
@@ -14483,9 +14483,9 @@ var quads = {
   gImpl: ({ SUBRULE }) => (ast, { factory: F3 }) => {
     for (const quad of ast.val) {
       if (F3.isPattern(quad)) {
-        SUBRULE(triplesBlock, quad, void 0);
+        SUBRULE(triplesBlock, quad);
       } else {
-        SUBRULE(quadsNotTriples, quad, void 0);
+        SUBRULE(quadsNotTriples, quad);
       }
     }
   }
@@ -14494,9 +14494,9 @@ var quadsNotTriples = {
   name: "quadsNotTriples",
   impl: ({ ACTION, SUBRULE1, CONSUME, OPTION }) => (C) => {
     const graph2 = CONSUME(graph_exports.graph);
-    const name = SUBRULE1(varOrIri, void 0);
+    const name = SUBRULE1(varOrIri);
     CONSUME(symbols_exports.LCurly);
-    const triples = OPTION(() => SUBRULE1(triplesTemplate, void 0));
+    const triples = OPTION(() => SUBRULE1(triplesTemplate));
     const close = CONSUME(symbols_exports.RCurly);
     return ACTION(() => C.factory.graphQuads(
       name,
@@ -14506,31 +14506,93 @@ var quadsNotTriples = {
   },
   gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
     F3.printFilter(ast, () => PRINT_WORD("GRAPH"));
-    SUBRULE(varOrTerm, ast.graph, void 0);
+    SUBRULE(varOrTerm, ast.graph);
     F3.printFilter(ast, () => PRINT_WORD("{"));
-    SUBRULE(triplesBlock, ast.triples, void 0);
+    SUBRULE(triplesBlock, ast.triples);
     F3.printFilter(ast, () => PRINT_WORD("}"));
   }
 };
 
+// ../rules-sparql-1-1/lib/grammar/index.ts
+var queryOrUpdate = {
+  name: "queryOrUpdate",
+  impl: ({ ACTION, SUBRULE, OR1, OR2, MANY, OPTION1, CONSUME, SUBRULE2 }) => (C) => {
+    const prologueValues = SUBRULE(prologue);
+    return OR1([
+      { ALT: () => {
+        const subType = OR2([
+          { ALT: () => SUBRULE(selectQuery) },
+          { ALT: () => SUBRULE(constructQuery) },
+          { ALT: () => SUBRULE(describeQuery) },
+          { ALT: () => SUBRULE(askQuery) }
+        ]);
+        const values3 = SUBRULE(valuesClause);
+        return ACTION(() => ({
+          context: prologueValues,
+          ...subType,
+          type: "query",
+          ...values3 && { values: values3 },
+          loc: C.factory.sourceLocation(
+            prologueValues.at(0),
+            subType,
+            values3
+          )
+        }));
+      } },
+      { ALT: () => {
+        const updates = [];
+        updates.push({ context: prologueValues });
+        let parsedSemi = true;
+        MANY({
+          GATE: () => parsedSemi,
+          DEF: () => {
+            parsedSemi = false;
+            updates.at(-1).operation = SUBRULE(update1);
+            OPTION1(() => {
+              CONSUME(symbols_exports.semi);
+              parsedSemi = true;
+              const innerPrologue = SUBRULE2(prologue);
+              updates.push({ context: innerPrologue });
+            });
+          }
+        });
+        return ACTION(() => {
+          const update2 = {
+            type: "update",
+            updates,
+            loc: C.factory.sourceLocation(
+              ...updates[0].context,
+              updates[0].operation,
+              ...updates.at(-1).context,
+              updates.at(-1)?.operation
+            )
+          };
+          updateNoReuseBlankNodeLabels(update2);
+          return update2;
+        });
+      } }
+    ]);
+  }
+};
+
 // lib/lexer.ts
 var lexer_exports2 = {};
 __export(lexer_exports2, {
   LANG_DIR: () => LANG_DIR,
   annotationClose: () => annotationClose,
   annotationOpen: () => annotationOpen,
-  builtinHasLang: () => builtinHasLang,
-  builtinHasLangDir: () => builtinHasLangDir,
-  builtinIsTRIPLE: () => builtinIsTRIPLE,
-  builtinLangDir: () => builtinLangDir,
-  builtinOBJECT: () => builtinOBJECT,
-  builtinPREDICATE: () => builtinPREDICATE,
-  builtinSUBJECT: () => builtinSUBJECT,
-  builtinStrLangDir: () => builtinStrLangDir,
-  builtinTRIPLE: () => builtinTRIPLE,
+  buildInHasLang: () => buildInHasLang,
+  buildInHasLangDir: () => buildInHasLangDir,
+  buildInIsTRIPLE: () => buildInIsTRIPLE,
+  buildInLangDir: () => buildInLangDir,
+  buildInOBJECT: () => buildInOBJECT,
+  buildInPREDICATE: () => buildInPREDICATE,
+  buildInSUBJECT: () => buildInSUBJECT,
+  buildInStrLangDir: () => buildInStrLangDir,
+  buildInTRIPLE: () => buildInTRIPLE,
   reificationClose: () => reificationClose,
   reificationOpen: () => reificationOpen,
-  sparql12Tokens: () => sparql12Tokens,
+  sparql12LexerBuilder: () => sparql12LexerBuilder,
   tilde: () => tilde,
   tripleTermClose: () => tripleTermClose,
   tripleTermOpen: () => tripleTermOpen,
@@ -14544,29 +14606,29 @@ var reificationOpen = createToken2({ name: "ReificationOpen", pattern: "<<", lab
 var reificationClose = createToken2({ name: "ReificationClose", pattern: ">>", label: "Reification close >>" });
 var tripleTermOpen = createToken2({ name: "TripleTermOpen", pattern: "<<(", label: "Triple Term Open <<(" });
 var tripleTermClose = createToken2({ name: "TripleTermClose", pattern: ")>>", label: "Triple Term Close )>>" });
-var builtinLangDir = createToken2({ name: "BuiltInLangdir", pattern: /langdir/i, label: "LANGDIR" });
-var builtinStrLangDir = createToken2({
+var buildInLangDir = createToken2({ name: "BuiltInLangdir", pattern: /langdir/i, label: "LANGDIR" });
+var buildInStrLangDir = createToken2({
   name: "BuiltInStrLangdir",
   pattern: /strlangdir/i,
   label: "STRLANGDIR"
 });
-var builtinHasLang = createToken2({ name: "BuiltInHasLang", pattern: /haslang/i, label: "hasLANG" });
-var builtinHasLangDir = createToken2({
+var buildInHasLang = createToken2({ name: "BuiltInHasLang", pattern: /haslang/i, label: "hasLANG" });
+var buildInHasLangDir = createToken2({
   name: "BuiltInHasLangdir",
   pattern: /haslangdir/i,
   label: "hasLANGDIR"
 });
-var builtinIsTRIPLE = createToken2({ name: "BuiltInIsTriple", pattern: /istriple/i, label: "isTRIPLE" });
-var builtinTRIPLE = createToken2({ name: "BuiltInTriple", pattern: /triple/i, label: "TRIPLE" });
-var builtinSUBJECT = createToken2({ name: "BuiltInSubject", pattern: /subject/i, label: "SUBJECT" });
-var builtinPREDICATE = createToken2({ name: "BuiltInPredicate", pattern: /predicate/i, label: "PREDICATE" });
-var builtinOBJECT = createToken2({ name: "BuiltInObject", pattern: /object/i, label: "OBJECT" });
+var buildInIsTRIPLE = createToken2({ name: "BuiltInIsTriple", pattern: /istriple/i, label: "isTRIPLE" });
+var buildInTRIPLE = createToken2({ name: "BuiltInTriple", pattern: /triple/i, label: "TRIPLE" });
+var buildInSUBJECT = createToken2({ name: "BuiltInSubject", pattern: /subject/i, label: "SUBJECT" });
+var buildInPREDICATE = createToken2({ name: "BuiltInPredicate", pattern: /predicate/i, label: "PREDICATE" });
+var buildInOBJECT = createToken2({ name: "BuiltInObject", pattern: /object/i, label: "OBJECT" });
 var LANG_DIR = createToken2({
   name: "LANG_DIR",
   pattern: /@[a-z]+(?:-[\da-z]+)*(?:--[a-z]+)?/i,
   label: "LANG_DIR"
 });
-var sparql12Tokens = LexerBuilder.create(lexer_exports.sparql11Tokens).addBefore(
+var sparql12LexerBuilder = LexerBuilder.create(lexer_exports.sparql11LexerBuilder).addBefore(
   lexer_exports.symbols.logicAnd,
   tilde,
   annotationOpen,
@@ -14578,15 +14640,15 @@ var sparql12Tokens = LexerBuilder.create(lexer_exports.sparql11Tokens).addBefore
   version
 ).addBefore(
   lexer_exports.builtIn.langmatches,
-  builtinLangDir,
-  builtinStrLangDir,
-  builtinHasLangDir,
-  builtinHasLang,
-  builtinIsTRIPLE,
-  builtinTRIPLE,
-  builtinSUBJECT,
-  builtinPREDICATE,
-  builtinOBJECT
+  buildInLangDir,
+  buildInStrLangDir,
+  buildInHasLangDir,
+  buildInHasLang,
+  buildInIsTRIPLE,
+  buildInTRIPLE,
+  buildInSUBJECT,
+  buildInPREDICATE,
+  buildInOBJECT
 ).addBefore(lexer_exports.terminals.langTag, LANG_DIR).delete(lexer_exports.terminals.langTag);
 
 // lib/validator.ts
@@ -14594,7 +14656,7 @@ var F2 = new Factory();
 function isLangDir(dir) {
   return dir === "ltr" || dir === "rtl";
 }
-function langTagHasCorrectDomain(literal) {
+function langTagHasCorrectRange(literal) {
   if (F2.isTermLiteralLangStr(literal)) {
     const dirSplit = literal.langOrIri.split("--");
     if (dirSplit.length > 1) {
@@ -14611,7 +14673,7 @@ var versionDecl = {
   name: "versionDecl",
   impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
     const versionToken = CONSUME(version);
-    const identifier = SUBRULE(versionSpecifier, void 0);
+    const identifier = SUBRULE(versionSpecifier);
     return ACTION(() => C.factory.contextDefinitionVersion(identifier.val, C.factory.sourceLocation(versionToken, identifier)));
   },
   gImpl: ({ PRINT_WORDS }) => (ast, { factory: F3 }) => {
@@ -14635,22 +14697,22 @@ var prologue2 = {
   impl: ({ SUBRULE, MANY, OR }) => () => {
     const result = [];
     MANY(() => OR([
-      { ALT: () => result.push(SUBRULE(grammar_exports.baseDecl, void 0)) },
+      { ALT: () => result.push(SUBRULE(grammar_exports.baseDecl)) },
       // TODO: the [spec](https://www.w3.org/TR/sparql11-query/#iriRefs) says you cannot redefine prefixes.
       //  We might need to check this.
-      { ALT: () => result.push(SUBRULE(grammar_exports.prefixDecl, void 0)) },
-      { ALT: () => result.push(SUBRULE(versionDecl, void 0)) }
+      { ALT: () => result.push(SUBRULE(grammar_exports.prefixDecl)) },
+      { ALT: () => result.push(SUBRULE(versionDecl)) }
     ]));
     return result;
   },
   gImpl: ({ SUBRULE }) => (ast, { factory: F3 }) => {
     for (const context of ast) {
       if (F3.isContextDefinitionBase(context)) {
-        SUBRULE(grammar_exports.baseDecl, context, void 0);
+        SUBRULE(grammar_exports.baseDecl, context);
       } else if (F3.isContextDefinitionPrefix(context)) {
-        SUBRULE(grammar_exports.prefixDecl, context, void 0);
+        SUBRULE(grammar_exports.prefixDecl, context);
       } else if (F3.isContextDefinitionVersion(context)) {
-        SUBRULE(versionDecl, context, void 0);
+        SUBRULE(versionDecl, context);
       }
     }
   }
@@ -14659,10 +14721,10 @@ function reifiedTripleBlockImpl(name, allowPath) {
   return {
     name,
     impl: ({ ACTION, SUBRULE }) => (C) => {
-      const triple = SUBRULE(reifiedTriple, void 0);
+      const triple = SUBRULE(reifiedTriple);
       const properties = SUBRULE(
         allowPath ? grammar_exports.propertyListPath : grammar_exports.propertyList,
-        { subject: ACTION(() => C.factory.dematerialized(triple.identifier)) }
+        ACTION(() => C.factory.dematerialized(triple.identifier))
       );
       return ACTION(() => [triple, ...properties]);
     }
@@ -14673,37 +14735,40 @@ var reifiedTripleBlockPath = reifiedTripleBlockImpl("reifiedTripleBlockPath", tr
 var dataBlockValue2 = {
   name: "dataBlockValue",
   impl: ($) => (C) => $.OR2([
-    { ALT: () => grammar_exports.dataBlockValue.impl($)(C, void 0) },
-    { ALT: () => $.SUBRULE(tripleTermData, void 0) }
+    { ALT: () => grammar_exports.dataBlockValue.impl($)(C) },
+    { ALT: () => $.SUBRULE(tripleTermData) }
   ])
 };
 var reifier = {
   name: "reifier",
   impl: ({ ACTION, CONSUME, SUBRULE, OPTION }) => (C) => {
-    CONSUME(tilde);
-    const reifier2 = OPTION(() => SUBRULE(varOrReifierId, void 0));
+    const tildeToken = CONSUME(tilde);
+    const reifier2 = OPTION(() => SUBRULE(varOrReifierId));
     return ACTION(() => {
       if (reifier2 === void 0 && !C.parseMode.has("canCreateBlankNodes")) {
         throw new Error("Cannot create blanknodes in current parse mode");
       }
-      return reifier2 ?? C.factory.blankNode(void 0, C.factory.sourceLocation());
+      return C.factory.wrap(
+        reifier2 ?? C.factory.blankNode(void 0, C.factory.sourceLocation()),
+        C.factory.sourceLocation(tildeToken, reifier2)
+      );
     });
   }
 };
 var varOrReifierId = {
   name: "varOrReifierId",
   impl: ({ SUBRULE, OR }) => (C) => OR([
-    { GATE: () => C.parseMode.has("canParseVars"), ALT: () => SUBRULE(grammar_exports.var_, void 0) },
-    { ALT: () => SUBRULE(grammar_exports.iri, void 0) },
-    { ALT: () => SUBRULE(grammar_exports.blankNode, void 0) }
+    { GATE: () => C.parseMode.has("canParseVars"), ALT: () => SUBRULE(grammar_exports.var_) },
+    { ALT: () => SUBRULE(grammar_exports.iri) },
+    { ALT: () => SUBRULE(grammar_exports.blankNode) }
   ])
 };
 function triplesSameSubjectImpl2(name, allowPaths) {
   return {
     name,
     impl: ($) => (C) => $.OR2([
-      { ALT: () => allowPaths ? grammar_exports.triplesSameSubjectPath.impl($)(C, void 0) : grammar_exports.triplesSameSubject.impl($)(C, void 0) },
-      { ALT: () => $.SUBRULE(allowPaths ? reifiedTripleBlockPath : reifiedTripleBlock, void 0) }
+      { ALT: () => allowPaths ? grammar_exports.triplesSameSubjectPath.impl($)(C) : grammar_exports.triplesSameSubject.impl($)(C) },
+      { ALT: () => $.SUBRULE(allowPaths ? reifiedTripleBlockPath : reifiedTripleBlock) }
     ])
   };
 }
@@ -14712,11 +14777,10 @@ var triplesSameSubjectPath2 = triplesSameSubjectImpl2("triplesSameSubjectPath",
 function objectImpl2(name, allowPaths) {
   return {
     name,
-    impl: ({ ACTION, SUBRULE }) => (C, arg) => {
-      const objectVal = SUBRULE(allowPaths ? graphNodePath2 : graphNode2, void 0);
-      const annotationVal = SUBRULE(allowPaths ? annotationPath : annotation, void 0);
+    impl: ({ ACTION, SUBRULE }) => (C, subject, predicate) => {
+      const objectVal = SUBRULE(allowPaths ? graphNodePath2 : graphNode2);
+      const annotationVal = SUBRULE(allowPaths ? annotationPath : annotation);
       return ACTION(() => {
-        const { subject, predicate } = arg;
         const F3 = C.factory;
         if (F3.isPathPure(predicate) && annotationVal.length > 0) {
           throw new Error("Note 17 violation");
@@ -14742,9 +14806,9 @@ function annotationImpl(name, allowPaths) {
       MANY(() => {
         OR([
           { ALT: () => {
-            const node = SUBRULE(reifier, void 0);
+            const node = SUBRULE(reifier);
             annotations.push(node);
-            currentReifier = node;
+            currentReifier = node.val;
           } },
           { ALT: () => {
             ACTION(() => {
@@ -14768,11 +14832,11 @@ function annotationImpl(name, allowPaths) {
     },
     gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
       for (const annotation2 of ast) {
-        if (F3.isTerm(annotation2)) {
-          F3.printFilter(annotation2, () => PRINT_WORD("~"));
-          SUBRULE(graphNodePath2, annotation2, void 0);
+        if (F3.isTripleCollectionBlankNodeProperties(annotation2)) {
+          SUBRULE(annotationBlockPath, annotation2);
         } else {
-          SUBRULE(annotationBlockPath, annotation2, void 0);
+          F3.printFilter(annotation2, () => PRINT_WORD("~"));
+          SUBRULE(graphNodePath2, annotation2.val);
         }
       }
     }
@@ -14787,7 +14851,7 @@ function annotationBlockImpl(name, allowPaths) {
       const open = CONSUME(annotationOpen);
       const res = SUBRULE(
         allowPaths ? grammar_exports.propertyListPathNotEmpty : grammar_exports.propertyListNotEmpty,
-        { subject: arg }
+        arg
       );
       const close = CONSUME(annotationClose);
       return ACTION(() => C.factory.tripleCollectionBlankNodeProperties(
@@ -14801,11 +14865,11 @@ function annotationBlockImpl(name, allowPaths) {
       for (const triple of ast.triples) {
         HANDLE_LOC(triple, () => {
           if (F3.isTerm(triple.predicate)) {
-            SUBRULE(graphNodePath2, triple.predicate, void 0);
+            SUBRULE(graphNodePath2, triple.predicate);
           } else {
             SUBRULE(grammar_exports.pathGenerator, triple.predicate, void 0);
           }
-          SUBRULE(graphNodePath2, triple.object, void 0);
+          SUBRULE(graphNodePath2, triple.object);
           F3.printFilter(ast, () => PRINT_WORD(";"));
         });
       }
@@ -14818,38 +14882,38 @@ var annotationBlock = annotationBlockImpl("annotationBlock", false);
 var graphNode2 = {
   name: "graphNode",
   impl: ($) => (C) => $.OR2([
-    { ALT: () => grammar_exports.graphNode.impl($)(C, void 0) },
-    { ALT: () => $.SUBRULE(reifiedTriple, void 0) }
+    { ALT: () => grammar_exports.graphNode.impl($)(C) },
+    { ALT: () => $.SUBRULE(reifiedTriple) }
   ])
 };
 var graphNodePath2 = {
   name: "graphNodePath",
   impl: ($) => (C) => $.OR2([
-    { ALT: () => grammar_exports.graphNodePath.impl($)(C, void 0) },
-    { ALT: () => $.SUBRULE(reifiedTriple, void 0) }
+    { ALT: () => grammar_exports.graphNodePath.impl($)(C) },
+    { ALT: () => $.SUBRULE(reifiedTriple) }
   ]),
-  gImpl: ($) => (ast, C, params) => {
+  gImpl: ($) => (ast, C) => {
     if (C.factory.isTripleCollectionReifiedTriple(ast)) {
-      $.SUBRULE(reifiedTriple, ast, void 0);
+      $.SUBRULE(reifiedTriple, ast);
     } else {
-      grammar_exports.graphNodePath.gImpl($)(ast, C, params);
+      grammar_exports.graphNodePath.gImpl($)(ast, C);
     }
   }
 };
 var varOrTerm2 = {
   name: "varOrTerm",
   impl: ({ ACTION, SUBRULE, OR, CONSUME }) => (C) => OR([
-    { GATE: () => C.parseMode.has("canParseVars"), ALT: () => SUBRULE(grammar_exports.var_, void 0) },
-    { ALT: () => SUBRULE(grammar_exports.iri, void 0) },
-    { ALT: () => SUBRULE(rdfLiteral2, void 0) },
-    { ALT: () => SUBRULE(grammar_exports.numericLiteral, void 0) },
-    { ALT: () => SUBRULE(grammar_exports.booleanLiteral, void 0) },
-    { ALT: () => SUBRULE(grammar_exports.blankNode, void 0) },
+    { GATE: () => C.parseMode.has("canParseVars"), ALT: () => SUBRULE(grammar_exports.var_) },
+    { ALT: () => SUBRULE(grammar_exports.iri) },
+    { ALT: () => SUBRULE(rdfLiteral2) },
+    { ALT: () => SUBRULE(grammar_exports.numericLiteral) },
+    { ALT: () => SUBRULE(grammar_exports.booleanLiteral) },
+    { ALT: () => SUBRULE(grammar_exports.blankNode) },
     { ALT: () => {
       const token = CONSUME(lexer_exports.terminals.nil);
       return ACTION(() => C.factory.namedNode(C.factory.sourceLocation(token), "http://www.w3.org/1999/02/22-rdf-syntax-ns#nil" /* NIL */));
     } },
-    { ALT: () => SUBRULE(tripleTerm, void 0) }
+    { ALT: () => SUBRULE(tripleTerm) }
   ])
   // Generation remains untouched - go through graphTerm
 };
@@ -14857,10 +14921,10 @@ var reifiedTriple = {
   name: "reifiedTriple",
   impl: ({ ACTION, CONSUME, SUBRULE, OPTION }) => (C) => {
     const open = CONSUME(reificationOpen);
-    const subject = SUBRULE(reifiedTripleSubject, void 0);
-    const predicate = SUBRULE(grammar_exports.verb, void 0);
-    const object3 = SUBRULE(reifiedTripleObject, void 0);
-    const reifierVal = OPTION(() => SUBRULE(reifier, void 0));
+    const subject = SUBRULE(reifiedTripleSubject);
+    const predicate = SUBRULE(grammar_exports.verb);
+    const object3 = SUBRULE(reifiedTripleObject);
+    const reifierVal = OPTION(() => SUBRULE(reifier));
     const close = CONSUME(reificationClose);
     return ACTION(() => {
       if (reifierVal === void 0 && !C.parseMode.has("canCreateBlankNodes")) {
@@ -14871,35 +14935,35 @@ var reifiedTriple = {
         subject,
         predicate,
         object3,
-        reifierVal
+        reifierVal?.val
       );
     });
   },
   gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
     F3.printFilter(ast, () => PRINT_WORD("<<"));
     const triple = ast.triples[0];
-    SUBRULE(graphNodePath2, triple.subject, void 0);
+    SUBRULE(graphNodePath2, triple.subject);
     if (F3.isPathPure(triple.predicate)) {
       SUBRULE(grammar_exports.pathGenerator, triple.predicate, void 0);
     } else {
-      SUBRULE(graphNodePath2, triple.predicate, void 0);
+      SUBRULE(graphNodePath2, triple.predicate);
     }
-    SUBRULE(graphNodePath2, triple.object, void 0);
-    SUBRULE(annotationPath, [ast.identifier], void 0);
+    SUBRULE(graphNodePath2, triple.object);
+    SUBRULE(annotationPath, [F3.wrap(ast.identifier, ast.identifier.loc)]);
     F3.printFilter(ast, () => PRINT_WORD(">>"));
   }
 };
 var reifiedTripleSubject = {
   name: "reifiedTripleSubject",
   impl: ({ OR, SUBRULE }) => (C) => OR([
-    { GATE: () => C.parseMode.has("canParseVars"), ALT: () => SUBRULE(grammar_exports.var_, void 0) },
-    { ALT: () => SUBRULE(grammar_exports.iri, void 0) },
-    { ALT: () => SUBRULE(rdfLiteral2, void 0) },
-    { ALT: () => SUBRULE(grammar_exports.numericLiteral, void 0) },
-    { ALT: () => SUBRULE(grammar_exports.booleanLiteral, void 0) },
-    { ALT: () => SUBRULE(grammar_exports.blankNode, void 0) },
-    { ALT: () => SUBRULE(reifiedTriple, void 0) },
-    { ALT: () => SUBRULE(tripleTerm, void 0) }
+    { GATE: () => C.parseMode.has("canParseVars"), ALT: () => SUBRULE(grammar_exports.var_) },
+    { ALT: () => SUBRULE(grammar_exports.iri) },
+    { ALT: () => SUBRULE(rdfLiteral2) },
+    { ALT: () => SUBRULE(grammar_exports.numericLiteral) },
+    { ALT: () => SUBRULE(grammar_exports.booleanLiteral) },
+    { ALT: () => SUBRULE(grammar_exports.blankNode) },
+    { ALT: () => SUBRULE(reifiedTriple) },
+    { ALT: () => SUBRULE(tripleTerm) }
   ])
 };
 var reifiedTripleObject = {
@@ -14910,30 +14974,30 @@ var tripleTerm = {
   name: "tripleTerm",
   impl: ({ ACTION, CONSUME, SUBRULE }) => (C) => {
     const open = CONSUME(tripleTermOpen);
-    const subject = SUBRULE(tripleTermSubject, void 0);
-    const predicate = SUBRULE(grammar_exports.verb, void 0);
-    const object3 = SUBRULE(tripleTermObject, void 0);
+    const subject = SUBRULE(tripleTermSubject);
+    const predicate = SUBRULE(grammar_exports.verb);
+    const object3 = SUBRULE(tripleTermObject);
     const close = CONSUME(tripleTermClose);
     return ACTION(() => C.factory.termTriple(subject, predicate, object3, C.factory.sourceLocation(open, close)));
   },
   gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
     F3.printFilter(ast, () => PRINT_WORD("<<("));
-    SUBRULE(graphNodePath2, ast.subject, void 0);
-    SUBRULE(graphNodePath2, ast.predicate, void 0);
-    SUBRULE(graphNodePath2, ast.object, void 0);
+    SUBRULE(graphNodePath2, ast.subject);
+    SUBRULE(graphNodePath2, ast.predicate);
+    SUBRULE(graphNodePath2, ast.object);
     F3.printFilter(ast, () => PRINT_WORD(")>>"));
   }
 };
 var tripleTermSubject = {
   name: "tripleTermSubject",
   impl: ({ SUBRULE, OR }) => (C) => OR([
-    { GATE: () => C.parseMode.has("canParseVars"), ALT: () => SUBRULE(grammar_exports.var_, void 0) },
-    { ALT: () => SUBRULE(grammar_exports.iri, void 0) },
-    { ALT: () => SUBRULE(rdfLiteral2, void 0) },
-    { ALT: () => SUBRULE(grammar_exports.numericLiteral, void 0) },
-    { ALT: () => SUBRULE(grammar_exports.booleanLiteral, void 0) },
-    { ALT: () => SUBRULE(grammar_exports.blankNode, void 0) },
-    { ALT: () => SUBRULE(tripleTerm, void 0) }
+    { GATE: () => C.parseMode.has("canParseVars"), ALT: () => SUBRULE(grammar_exports.var_) },
+    { ALT: () => SUBRULE(grammar_exports.iri) },
+    { ALT: () => SUBRULE(rdfLiteral2) },
+    { ALT: () => SUBRULE(grammar_exports.numericLiteral) },
+    { ALT: () => SUBRULE(grammar_exports.booleanLiteral) },
+    { ALT: () => SUBRULE(grammar_exports.blankNode) },
+    { ALT: () => SUBRULE(tripleTerm) }
   ])
 };
 var tripleTermObject = {
@@ -14944,15 +15008,15 @@ var tripleTermData = {
   name: "tripleTermData",
   impl: ({ ACTION, CONSUME, OR, SUBRULE }) => (C) => {
     const open = CONSUME(tripleTermOpen);
-    const subject = SUBRULE(tripleTermDataSubject, void 0);
+    const subject = SUBRULE(tripleTermDataSubject);
     const predicate = OR([
-      { ALT: () => SUBRULE(grammar_exports.iri, void 0) },
+      { ALT: () => SUBRULE(grammar_exports.iri) },
       { ALT: () => {
         const token = CONSUME(lexer_exports.a);
         return ACTION(() => C.factory.namedNode(C.factory.sourceLocation(token), "http://www.w3.org/1999/02/22-rdf-syntax-ns#type" /* TYPE */));
       } }
     ]);
-    const object3 = SUBRULE(tripleTermDataObject, void 0);
+    const object3 = SUBRULE(tripleTermDataObject);
     const close = CONSUME(tripleTermClose);
     return ACTION(() => C.factory.termTriple(subject, predicate, object3, C.factory.sourceLocation(open, close)));
   }
@@ -14960,11 +15024,11 @@ var tripleTermData = {
 var tripleTermDataSubject = {
   name: "tripleTermDataSubject",
   impl: ({ OR, SUBRULE }) => () => OR([
-    { ALT: () => SUBRULE(grammar_exports.iri, void 0) },
-    { ALT: () => SUBRULE(rdfLiteral2, void 0) },
-    { ALT: () => SUBRULE(grammar_exports.numericLiteral, void 0) },
-    { ALT: () => SUBRULE(grammar_exports.booleanLiteral, void 0) },
-    { ALT: () => SUBRULE(tripleTermData, void 0) }
+    { ALT: () => SUBRULE(grammar_exports.iri) },
+    { ALT: () => SUBRULE(rdfLiteral2) },
+    { ALT: () => SUBRULE(grammar_exports.numericLiteral) },
+    { ALT: () => SUBRULE(grammar_exports.booleanLiteral) },
+    { ALT: () => SUBRULE(tripleTermData) }
   ])
 };
 var tripleTermDataObject = {
@@ -14974,17 +15038,17 @@ var tripleTermDataObject = {
 var primaryExpression2 = {
   name: "primaryExpression",
   impl: ($) => (C) => $.OR2([
-    { ALT: () => grammar_exports.primaryExpression.impl($)(C, void 0) },
-    { ALT: () => $.SUBRULE(exprTripleTerm, void 0) }
+    { ALT: () => grammar_exports.primaryExpression.impl($)(C) },
+    { ALT: () => $.SUBRULE(exprTripleTerm) }
   ])
 };
 var exprTripleTerm = {
   name: "exprTripleTerm",
   impl: ({ ACTION, CONSUME, SUBRULE }) => (C) => {
     const open = CONSUME(tripleTermOpen);
-    const subject = SUBRULE(exprTripleTermSubject, void 0);
-    const predicate = SUBRULE(grammar_exports.verb, void 0);
-    const object3 = SUBRULE(exprTripleTermObject, void 0);
+    const subject = SUBRULE(exprTripleTermSubject);
+    const predicate = SUBRULE(grammar_exports.verb);
+    const object3 = SUBRULE(exprTripleTermObject);
     const close = CONSUME(tripleTermClose);
     return ACTION(() => C.factory.termTriple(
       subject,
@@ -14997,46 +15061,46 @@ var exprTripleTerm = {
 var exprTripleTermSubject = {
   name: "exprTripleTermSubject",
   impl: ({ OR, SUBRULE }) => (C) => OR([
-    { ALT: () => SUBRULE(grammar_exports.iri, void 0) },
-    { ALT: () => SUBRULE(rdfLiteral2, void 0) },
-    { ALT: () => SUBRULE(grammar_exports.numericLiteral, void 0) },
-    { ALT: () => SUBRULE(grammar_exports.booleanLiteral, void 0) },
-    { GATE: () => C.parseMode.has("canParseVars"), ALT: () => SUBRULE(grammar_exports.var_, void 0) },
-    { ALT: () => SUBRULE(exprTripleTerm, void 0) }
+    { ALT: () => SUBRULE(grammar_exports.iri) },
+    { ALT: () => SUBRULE(rdfLiteral2) },
+    { ALT: () => SUBRULE(grammar_exports.numericLiteral) },
+    { ALT: () => SUBRULE(grammar_exports.booleanLiteral) },
+    { GATE: () => C.parseMode.has("canParseVars"), ALT: () => SUBRULE(grammar_exports.var_) },
+    { ALT: () => SUBRULE(exprTripleTerm) }
   ])
 };
 var exprTripleTermObject = {
   name: "exprTripleTermObject",
   impl: exprTripleTermSubject.impl
 };
-var builtinLangDir2 = funcExpr1(builtinLangDir);
-var builtinLangStrDir = funcExpr3(builtinStrLangDir);
-var builtinHasLang2 = funcExpr1(builtinHasLang);
-var builtinHasLangDir2 = funcExpr1(builtinHasLangDir);
-var builtinIsTriple = funcExpr1(builtinIsTRIPLE);
-var builtinTriple = funcExpr3(builtinTRIPLE);
-var builtinSubject = funcExpr1(builtinSUBJECT);
-var builtinPredicate = funcExpr1(builtinPREDICATE);
-var builtinObject = funcExpr1(builtinOBJECT);
+var buildInLangDir2 = funcExpr1(buildInLangDir);
+var buildInLangStrDir = funcExpr3(buildInStrLangDir);
+var buildInHasLang2 = funcExpr1(buildInHasLang);
+var buildInHasLangDir2 = funcExpr1(buildInHasLangDir);
+var buildInIsTriple = funcExpr1(buildInIsTRIPLE);
+var buildInTriple = funcExpr3(buildInTRIPLE);
+var buildInSubject = funcExpr1(buildInSUBJECT);
+var buildInPredicate = funcExpr1(buildInPREDICATE);
+var buildInObject = funcExpr1(buildInOBJECT);
 var builtInCall2 = {
   name: "builtInCall",
   impl: ($) => (C) => $.OR2([
-    { ALT: () => grammar_exports.builtInCall.impl($)(C, void 0) },
-    { ALT: () => $.SUBRULE(builtinLangDir2, void 0) },
-    { ALT: () => $.SUBRULE(builtinLangStrDir, void 0) },
-    { ALT: () => $.SUBRULE(builtinHasLang2, void 0) },
-    { ALT: () => $.SUBRULE(builtinHasLangDir2, void 0) },
-    { ALT: () => $.SUBRULE(builtinIsTriple, void 0) },
-    { ALT: () => $.SUBRULE(builtinTriple, void 0) },
-    { ALT: () => $.SUBRULE(builtinSubject, void 0) },
-    { ALT: () => $.SUBRULE(builtinPredicate, void 0) },
-    { ALT: () => $.SUBRULE(builtinObject, void 0) }
+    { ALT: () => grammar_exports.builtInCall.impl($)(C) },
+    { ALT: () => $.SUBRULE(buildInLangDir2) },
+    { ALT: () => $.SUBRULE(buildInLangStrDir) },
+    { ALT: () => $.SUBRULE(buildInHasLang2) },
+    { ALT: () => $.SUBRULE(buildInHasLangDir2) },
+    { ALT: () => $.SUBRULE(buildInIsTriple) },
+    { ALT: () => $.SUBRULE(buildInTriple) },
+    { ALT: () => $.SUBRULE(buildInSubject) },
+    { ALT: () => $.SUBRULE(buildInPredicate) },
+    { ALT: () => $.SUBRULE(buildInObject) }
   ])
 };
 var rdfLiteral2 = {
   name: "rdfLiteral",
   impl: ({ ACTION, SUBRULE, OPTION, CONSUME, OR }) => (C) => {
-    const value = SUBRULE(grammar_exports.string, void 0);
+    const value = SUBRULE(grammar_exports.string);
     return OPTION(() => OR([
       { ALT: () => {
         const langTag2 = CONSUME(LANG_DIR);
@@ -15046,13 +15110,13 @@ var rdfLiteral2 = {
             value.value,
             langTag2.image.slice(1).toLowerCase()
           );
-          langTagHasCorrectDomain(literal);
+          langTagHasCorrectRange(literal);
           return literal;
         });
       } },
       { ALT: () => {
         CONSUME(lexer_exports.symbols.hathat);
-        const iriVal = SUBRULE(grammar_exports.iri, void 0);
+        const iriVal = SUBRULE(grammar_exports.iri);
         return ACTION(() => C.factory.literalTerm(
           C.factory.sourceLocation(value, iriVal),
           value.value,
@@ -15069,17 +15133,17 @@ var generateTriplesBlock = {
       HANDLE_LOC(triple, () => {
         const nextTriple = ast.triples.at(index);
         if (F3.isTripleCollection(triple)) {
-          SUBRULE(graphNodePath2, triple, void 0);
+          SUBRULE(graphNodePath2, triple);
           F3.printFilter(triple, () => PRINT_WORD("."));
         } else {
-          SUBRULE(graphNodePath2, triple.subject, void 0);
+          SUBRULE(graphNodePath2, triple.subject);
           if (F3.isPathPure(triple.predicate)) {
             SUBRULE(grammar_exports.pathGenerator, triple.predicate, void 0);
           } else {
-            SUBRULE(graphNodePath2, triple.predicate, void 0);
+            SUBRULE(graphNodePath2, triple.predicate);
           }
-          SUBRULE(graphNodePath2, triple.object, void 0);
-          SUBRULE(annotationPath, triple.annotations ?? [], void 0);
+          SUBRULE(graphNodePath2, triple.object);
+          SUBRULE(annotationPath, triple.annotations ?? []);
           if (nextTriple === void 0 || F3.isTripleCollection(nextTriple) || !F3.isSourceLocationNoMaterialize(nextTriple.subject.loc)) {
             F3.printFilter(ast, () => PRINT_WORD("."));
           } else if (F3.isSourceLocationNoMaterialize(nextTriple.predicate.loc)) {
@@ -15094,31 +15158,17 @@ var generateTriplesBlock = {
 };
 var generateGraphTerm = {
   name: "graphTerm",
-  gImpl: ($) => (ast, C, par) => {
+  gImpl: ($) => (ast, C) => {
     if (C.factory.isTermTriple(ast)) {
-      $.SUBRULE(tripleTerm, ast, void 0);
+      $.SUBRULE(tripleTerm, ast);
     } else {
-      grammar_exports.graphTerm.gImpl($)(ast, C, par);
+      grammar_exports.graphTerm.gImpl($)(ast, C);
     }
   }
 };
 
 // lib/Factory.ts
 var Factory2 = class extends Factory {
-  constructor() {
-    super(...arguments);
-    /**
-     * Overwritten triple constructor to always contain an empty annotations list
-     */
-    this.triple = (subject, predicate, object3, loc) => ({
-      type: "triple",
-      subject,
-      predicate,
-      object: object3,
-      annotations: [],
-      loc: loc ?? this.sourceLocation(subject, predicate, object3)
-    });
-  }
   termTriple(subject, predicate, object3, loc) {
     return {
       type: "term",
@@ -15153,6 +15203,17 @@ var Factory2 = class extends Factory {
       loc
     };
   }
+  /**
+   * Overwritten triple constructor to always contain an empty annotations list
+   */
+  triple = (subject, predicate, object3, loc) => ({
+    type: "triple",
+    subject,
+    predicate,
+    object: object3,
+    annotations: [],
+    loc: loc ?? this.sourceLocation(subject, predicate, object3)
+  });
   annotatedTriple(subject, predicate, object3, annotations, loc) {
     return {
       type: "triple",