@traqula/rules-sparql-1-2 0.0.1-alpha.143 → 0.0.1-alpha.148

package/lib/index.cjs

@@ -9523,8 +9523,6 @@ __export(grammar_exports, {
   builtInUuid: () => builtInUuid,
   builtInYear: () => builtInYear,
   canCreateBlankNodes: () => canCreateBlankNodes,
-  canParseAggregate: () => canParseAggregate,
-  canParseVars: () => canParseVars,
   clear: () => clear2,
   collection: () => collection,
   collectionPath: () => collectionPath,
@@ -9575,7 +9573,6 @@ __export(grammar_exports, {
   groupOrUnionGraphPattern: () => groupOrUnionGraphPattern,
   havingClause: () => havingClause,
   havingCondition: () => havingCondition,
-  inAggregate: () => inAggregate,
   inlineData: () => inlineData,
   inlineDataFull: () => inlineDataFull,
   inlineDataOneVar: () => inlineDataOneVar,
@@ -10170,7 +10167,7 @@ __export(terminals_exports, {
   integerNegative: () => integerNegative,
   integerNegativePattern: () => integerNegativePattern,
   integerPattern: () => integerPattern,
-  interferePositive: () => interferePositive,
+  integerPositive: () => integerPositive,
   interferePositivePattern: () => interferePositivePattern,
   iriRef: () => iriRef,
   iriRefPattern: () => iriRefPattern,
@@ -10250,7 +10247,7 @@ var langTag = createToken2({ name: "LangTag", pattern: langTagPattern });
 var integer = createToken2({ name: "Integer", pattern: integerPattern });
 var decimal = createToken2({ name: "Decimal", pattern: decimalPattern2 });
 var double = createToken2({ name: "Double", pattern: doublePattern });
-var interferePositive = createToken2({ name: "InterferePositive", pattern: interferePositivePattern });
+var integerPositive = createToken2({ name: "InterferePositive", pattern: interferePositivePattern });
 var decimalPositive = createToken2({ name: "DecimalPositive", pattern: decimalPositivePattern });
 var doublePositive = createToken2({ name: "DoublePositive", pattern: doublePositivePattern });
 var integerNegative = createToken2({ name: "IntegerNegative", pattern: integerNegativePattern });
@@ -10275,7 +10272,7 @@ var allTerminals = LexerBuilder.create().add(
   double,
   decimal,
   integer,
-  interferePositive,
+  integerPositive,
   decimalPositive,
   doublePositive,
   integerNegative,
@@ -10393,90 +10390,90 @@ var sparql11Tokens = LexerBuilder.create(allTerminals).merge(allBaseTokens).merg
 // ../rules-sparql-1-1/lib/grammar/literals.ts
 var rdfLiteral = {
   name: "rdfLiteral",
-  impl: ({ SUBRULE, CONSUME, OPTION, OR, context }) => () => {
-    const value = SUBRULE(string);
+  impl: ({ ACTION, SUBRULE, CONSUME, OPTION, OR }) => (C) => {
+    const value = SUBRULE(string, void 0);
     const languageOrDatatype = OPTION(() => OR([
       { ALT: () => CONSUME(terminals_exports.langTag).image.slice(1) },
       {
         ALT: () => {
           CONSUME(symbols_exports.hathat);
-          return SUBRULE(iri2);
+          return SUBRULE(iri2, void 0);
         }
       }
     ]));
-    return context.dataFactory.literal(value, languageOrDatatype);
+    return ACTION(() => C.dataFactory.literal(value, languageOrDatatype));
   }
 };
 var numericLiteral = {
   name: "numericLiteral",
   impl: ({ SUBRULE, OR }) => () => OR([
-    { ALT: () => SUBRULE(numericLiteralUnsigned) },
-    { ALT: () => SUBRULE(numericLiteralPositive) },
-    { ALT: () => SUBRULE(numericLiteralNegative) }
+    { ALT: () => SUBRULE(numericLiteralUnsigned, void 0) },
+    { ALT: () => SUBRULE(numericLiteralPositive, void 0) },
+    { ALT: () => SUBRULE(numericLiteralNegative, void 0) }
   ])
 };
 var numericLiteralUnsigned = {
   name: "numericLiteralUnsigned",
-  impl: ({ CONSUME, OR, context }) => () => OR([
-    { ALT: () => context.dataFactory.literal(
-      CONSUME(terminals_exports.integer).image,
-      context.dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#integer" /* INTEGER */)
-    ) },
-    { ALT: () => context.dataFactory.literal(
-      CONSUME(terminals_exports.decimal).image,
-      context.dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#decimal" /* DECIMAL */)
-    ) },
-    { ALT: () => context.dataFactory.literal(
-      CONSUME(terminals_exports.double).image,
-      context.dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#double" /* DOUBLE */)
-    ) }
+  impl: ({ ACTION, CONSUME, OR }) => (C) => OR([
+    { ALT: () => {
+      const val = CONSUME(terminals_exports.integer).image;
+      return ACTION(() => C.dataFactory.literal(val, C.dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#integer" /* INTEGER */)));
+    } },
+    { ALT: () => {
+      const val = CONSUME(terminals_exports.decimal).image;
+      return ACTION(() => C.dataFactory.literal(val, C.dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#decimal" /* DECIMAL */)));
+    } },
+    { ALT: () => {
+      const val = CONSUME(terminals_exports.double).image;
+      return ACTION(() => C.dataFactory.literal(val, C.dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#double" /* DOUBLE */)));
+    } }
   ])
 };
 var numericLiteralPositive = {
   name: "numericLiteralPositive",
-  impl: ({ CONSUME, OR, context }) => () => OR([
-    { ALT: () => context.dataFactory.literal(
-      CONSUME(terminals_exports.interferePositive).image,
-      context.dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#integer" /* INTEGER */)
-    ) },
-    { ALT: () => context.dataFactory.literal(
-      CONSUME(terminals_exports.decimalPositive).image,
-      context.dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#decimal" /* DECIMAL */)
-    ) },
-    { ALT: () => context.dataFactory.literal(
-      CONSUME(terminals_exports.doublePositive).image,
-      context.dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#double" /* DOUBLE */)
-    ) }
+  impl: ({ ACTION, CONSUME, OR }) => (C) => OR([
+    { ALT: () => {
+      const val = CONSUME(terminals_exports.integerPositive).image;
+      return ACTION(() => C.dataFactory.literal(val, C.dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#integer" /* INTEGER */)));
+    } },
+    { ALT: () => {
+      const val = CONSUME(terminals_exports.decimalPositive).image;
+      return ACTION(() => C.dataFactory.literal(val, C.dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#decimal" /* DECIMAL */)));
+    } },
+    { ALT: () => {
+      const val = CONSUME(terminals_exports.doublePositive).image;
+      return ACTION(() => C.dataFactory.literal(val, C.dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#double" /* DOUBLE */)));
+    } }
   ])
 };
 var numericLiteralNegative = {
   name: "numericLiteralNegative",
-  impl: ({ CONSUME, OR, context }) => () => OR([
-    { ALT: () => context.dataFactory.literal(
-      CONSUME(terminals_exports.integerNegative).image,
-      context.dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#integer" /* INTEGER */)
-    ) },
-    { ALT: () => context.dataFactory.literal(
-      CONSUME(terminals_exports.decimalNegative).image,
-      context.dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#decimal" /* DECIMAL */)
-    ) },
-    { ALT: () => context.dataFactory.literal(
-      CONSUME(terminals_exports.doubleNegative).image,
-      context.dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#double" /* DOUBLE */)
-    ) }
+  impl: ({ ACTION, CONSUME, OR }) => (C) => OR([
+    { ALT: () => {
+      const val = CONSUME(terminals_exports.integerNegative).image;
+      return ACTION(() => C.dataFactory.literal(val, C.dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#integer" /* INTEGER */)));
+    } },
+    { ALT: () => {
+      const val = CONSUME(terminals_exports.decimalNegative).image;
+      return ACTION(() => C.dataFactory.literal(val, C.dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#decimal" /* DECIMAL */)));
+    } },
+    { ALT: () => {
+      const val = CONSUME(terminals_exports.doubleNegative).image;
+      return ACTION(() => C.dataFactory.literal(val, C.dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#double" /* DOUBLE */)));
+    } }
   ])
 };
 var booleanLiteral = {
   name: "booleanLiteral",
-  impl: ({ CONSUME, OR, context }) => () => OR([
-    { ALT: () => context.dataFactory.literal(
-      CONSUME(true_).image.toLowerCase(),
-      context.dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#boolean" /* BOOLEAN */)
-    ) },
-    { ALT: () => context.dataFactory.literal(
-      CONSUME(false_).image.toLowerCase(),
-      context.dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#boolean" /* BOOLEAN */)
-    ) }
+  impl: ({ ACTION, CONSUME, OR }) => (C) => OR([
+    { ALT: () => {
+      const val = CONSUME(true_).image.toLowerCase();
+      return ACTION(() => C.dataFactory.literal(val, C.dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#boolean" /* BOOLEAN */)));
+    } },
+    { ALT: () => {
+      const val = CONSUME(false_).image.toLowerCase();
+      return ACTION(() => C.dataFactory.literal(val, C.dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#boolean" /* BOOLEAN */)));
+    } }
   ])
 };
 var string = {
@@ -10508,51 +10505,51 @@ var string = {
 };
 var iri2 = {
   name: "iri",
-  impl: ({ ACTION, SUBRULE, CONSUME, OR, context }) => () => OR([
+  impl: ({ ACTION, SUBRULE, CONSUME, OR }) => (C) => OR([
     { ALT: () => {
       const iriVal = CONSUME(terminals_exports.iriRef).image.slice(1, -1);
-      return ACTION(() => context.dataFactory.namedNode(resolveIRI(iriVal, context.baseIRI)));
+      return ACTION(() => C.dataFactory.namedNode(resolveIRI(iriVal, C.baseIRI)));
     } },
-    { ALT: () => SUBRULE(prefixedName) }
+    { ALT: () => SUBRULE(prefixedName, void 0) }
   ])
 };
 var prefixedName = {
   name: "prefixedName",
-  impl: ({ ACTION, CONSUME, OR, context }) => () => {
+  impl: ({ ACTION, CONSUME, OR }) => (C) => {
     const fullStr = OR([
       { ALT: () => CONSUME(terminals_exports.pNameLn).image },
       { ALT: () => CONSUME(terminals_exports.pNameNs).image }
     ]);
     return ACTION(() => {
       const [prefix, localName] = fullStr.split(":");
-      const value = context.prefixes[prefix];
+      const value = C.prefixes[prefix];
       if (value === void 0) {
         throw new Error(`Unknown prefix: ${prefix}`);
       }
-      return context.dataFactory.namedNode(resolveIRI(value + localName, context.baseIRI));
+      return C.dataFactory.namedNode(resolveIRI(value + localName, C.baseIRI));
     });
   }
 };
 var canCreateBlankNodes = Symbol("canCreateBlankNodes");
 var blankNode = {
   name: "blankNode",
-  impl: ({ ACTION, CONSUME, OR, context }) => () => {
+  impl: ({ ACTION, CONSUME, OR }) => (C) => {
     const result = OR([
       {
         ALT: () => {
           const label = CONSUME(terminals_exports.blankNodeLabel).image;
-          return ACTION(() => context.dataFactory.blankNode(label.replace("_:", "e_")));
+          return ACTION(() => C.dataFactory.blankNode(label.replace("_:", "e_")));
         }
       },
       {
         ALT: () => {
           CONSUME(terminals_exports.anon);
-          return ACTION(() => context.dataFactory.blankNode());
+          return ACTION(() => C.dataFactory.blankNode());
         }
       }
     ]);
     ACTION(() => {
-      if (!context.parseMode.has(canCreateBlankNodes)) {
+      if (!C.parseMode.has("canCreateBlankNodes")) {
         throw new Error("Blank nodes are not allowed in this context");
       }
     });
@@ -10560,10 +10557,37 @@ var blankNode = {
   }
 };
 
+// ../rules-sparql-1-1/lib/grammar/dataSetClause.ts
+var datasetClause = {
+  name: "datasetClause",
+  impl: ({ SUBRULE, CONSUME, OR }) => () => {
+    CONSUME(from);
+    return OR([
+      { ALT: () => ({ value: SUBRULE(defaultGraphClause, void 0), type: "default" }) },
+      { ALT: () => ({ value: SUBRULE(namedGraphClause, void 0), type: "named" }) }
+    ]);
+  }
+};
+var defaultGraphClause = {
+  name: "defaultGraphClause",
+  impl: ({ SUBRULE }) => () => SUBRULE(sourceSelector, void 0)
+};
+var namedGraphClause = {
+  name: "namedGraphClause",
+  impl: ({ SUBRULE, CONSUME }) => () => {
+    CONSUME(graph_exports.named);
+    return SUBRULE(sourceSelector, void 0);
+  }
+};
+var sourceSelector = {
+  name: "sourceSelector",
+  impl: ({ SUBRULE }) => () => SUBRULE(iri2, void 0)
+};
+
 // ../rules-sparql-1-1/lib/grammar/propertyPaths.ts
 var path = {
   name: "path",
-  impl: ({ SUBRULE }) => () => SUBRULE(pathAlternative)
+  impl: ({ SUBRULE }) => () => SUBRULE(pathAlternative, void 0)
 };
 function pathHelper(name, SEP, pathType, subRule) {
   return {
@@ -10572,7 +10596,7 @@ function pathHelper(name, SEP, pathType, subRule) {
       const alternatives = [];
       AT_LEAST_ONE_SEP({
         DEF: () => {
-          alternatives.push(SUBRULE2(subRule));
+          alternatives.push(SUBRULE2(subRule, void 0));
         },
         SEP
       });
@@ -10588,12 +10612,12 @@ var pathEltOrInverse = {
   name: "pathEltOrInverse",
   impl: ({ CONSUME, SUBRULE1, SUBRULE2, OR }) => () => OR([
     {
-      ALT: () => SUBRULE1(pathElt)
+      ALT: () => SUBRULE1(pathElt, void 0)
     },
     {
       ALT: () => {
         CONSUME(symbols_exports.hat);
-        const item = SUBRULE2(pathElt);
+        const item = SUBRULE2(pathElt, void 0);
         return {
           type: "path",
           pathType: "^",
@@ -10610,8 +10634,8 @@ var pathAlternative = pathHelper("pathAlternative", symbols_exports.pipe, "|", p
 var pathElt = {
   name: "pathElt",
   impl: ({ SUBRULE, OPTION }) => () => {
-    const item = SUBRULE(pathPrimary);
-    const modification = OPTION(() => SUBRULE(pathMod));
+    const item = SUBRULE(pathPrimary, void 0);
+    const modification = OPTION(() => SUBRULE(pathMod, void 0));
     return modification === void 0 ? item : {
       type: "path",
       pathType: modification,
@@ -10645,14 +10669,14 @@ var pathMod = {
 var pathPrimary = {
   name: "pathPrimary",
   impl: ({ SUBRULE, CONSUME, OR }) => () => OR([
-    { ALT: () => SUBRULE(iri2) },
+    { ALT: () => SUBRULE(iri2, void 0) },
     {
-      ALT: () => SUBRULE(verbA)
+      ALT: () => SUBRULE(verbA, void 0)
     },
     {
       ALT: () => {
         CONSUME(symbols_exports.exclamation);
-        const negatedPath = SUBRULE(pathNegatedPropertySet);
+        const negatedPath = SUBRULE(pathNegatedPropertySet, void 0);
         return {
           type: "path",
           pathType: "!",
@@ -10663,7 +10687,7 @@ var pathPrimary = {
     {
       ALT: () => {
         CONSUME(symbols_exports.LParen);
-        const resRecursive = SUBRULE(path);
+        const resRecursive = SUBRULE(path, void 0);
         CONSUME(symbols_exports.RParen);
         return resRecursive;
       }
@@ -10674,7 +10698,7 @@ var pathNegatedPropertySet = {
   name: "pathNegatedPropertySet",
   impl: ({ CONSUME, SUBRULE1, SUBRULE2, OR, MANY_SEP }) => () => OR([
     {
-      ALT: () => [SUBRULE1(pathOneInPropertySet)]
+      ALT: () => [SUBRULE1(pathOneInPropertySet, void 0)]
     },
     {
       ALT: () => {
@@ -10682,7 +10706,7 @@ var pathNegatedPropertySet = {
         const items = [];
         MANY_SEP({
           DEF: () => {
-            items.push(SUBRULE2(pathOneInPropertySet));
+            items.push(SUBRULE2(pathOneInPropertySet, void 0));
           },
           SEP: symbols_exports.pipe
         });
@@ -10699,14 +10723,14 @@ var pathNegatedPropertySet = {
 var pathOneInPropertySet = {
   name: "pathOneInPropertySet",
   impl: ({ CONSUME, SUBRULE1, SUBRULE2, OR1, OR2 }) => () => OR1([
-    { ALT: () => SUBRULE1(iri2) },
-    { ALT: () => SUBRULE1(verbA) },
+    { ALT: () => SUBRULE1(iri2, void 0) },
+    { ALT: () => SUBRULE1(verbA, void 0) },
     {
       ALT: () => {
         CONSUME(symbols_exports.hat);
         const item = OR2([
-          { ALT: () => SUBRULE2(iri2) },
-          { ALT: () => SUBRULE2(verbA) }
+          { ALT: () => SUBRULE2(iri2, void 0) },
+          { ALT: () => SUBRULE2(verbA, void 0) }
         ]);
         return {
           type: "path",
@@ -10722,10 +10746,10 @@ var pathOneInPropertySet = {
 var triplesBlock = {
   name: "triplesBlock",
   impl: ({ ACTION, SUBRULE, CONSUME, OPTION1, OPTION2 }) => () => {
-    const triples = SUBRULE(triplesSameSubjectPath);
+    const triples = SUBRULE(triplesSameSubjectPath, void 0);
     const pattern = OPTION1(() => {
       CONSUME(symbols_exports.dot);
-      return OPTION2(() => SUBRULE(triplesBlock));
+      return OPTION2(() => SUBRULE(triplesBlock, void 0));
     });
     return ACTION(() => ({
       type: "bgp",
@@ -10739,17 +10763,16 @@ function triplesSameSubjectImpl(name, allowPaths) {
     impl: ({ ACTION, SUBRULE, OR }) => () => OR([
       {
         ALT: () => {
-          const subject = SUBRULE(varOrTerm);
-          const propNotEmpty = SUBRULE(allowPaths ? propertyListPathNotEmpty : propertyListNotEmpty);
-          return ACTION(() => propNotEmpty.map((partial) => partial({ subject })));
+          const subject = SUBRULE(varOrTerm, void 0);
+          return SUBRULE(allowPaths ? propertyListPathNotEmpty : propertyListNotEmpty, { subject });
         }
       },
       {
         ALT: () => {
-          const subjectNode = SUBRULE(allowPaths ? triplesNodePath : triplesNode);
-          const restNode = SUBRULE(allowPaths ? propertyListPath : propertyList);
+          const subjectNode = SUBRULE(allowPaths ? triplesNodePath : triplesNode, void 0);
+          const restNode = SUBRULE(allowPaths ? propertyListPath : propertyList, { subject: subjectNode.node });
           return ACTION(() => [
-            ...restNode.map((partial) => partial({ subject: subjectNode.node })),
+            ...restNode,
             ...subjectNode.triples
           ]);
         }
@@ -10762,7 +10785,7 @@ var triplesSameSubjectPath = triplesSameSubjectImpl("triplesSameSubjectPath", tr
 function propertyListImpl(name, allowPaths) {
   return {
     name,
-    impl: ({ SUBRULE, OPTION }) => () => OPTION(() => SUBRULE(allowPaths ? propertyListPathNotEmpty : propertyListNotEmpty)) ?? []
+    impl: ({ SUBRULE, OPTION }) => (_, arg) => OPTION(() => SUBRULE(allowPaths ? propertyListPathNotEmpty : propertyListNotEmpty, arg)) ?? []
   };
 }
 var propertyList = propertyListImpl("propertyList", false);
@@ -10770,42 +10793,29 @@ var propertyListPath = propertyListImpl("propertyListPath", true);
 function propertyListNotEmptyImplementation(name, allowPaths) {
   return {
     name,
-    impl: ({ ACTION, CONSUME, MANY, SUBRULE1, SUBRULE2, OPTION, OR1, OR2, context }) => () => {
+    impl: ({ ACTION, CONSUME, AT_LEAST_ONE, SUBRULE1, MANY2, OR1 }) => (_, arg) => {
       const result = [];
-      const resultAppendage = [];
-      const firstProperty = allowPaths ? OR1([
-        { ALT: () => SUBRULE1(verbPath) },
-        { ALT: () => SUBRULE1(verbSimple) }
-      ]) : SUBRULE1(verb);
-      const firstObjects = SUBRULE1(allowPaths ? objectListPath : objectList);
-      ACTION(() => {
-        const filterSubject = context.dataFactory.namedNode("internal:filterSubject");
-        for (const cObject of firstObjects) {
-          const triple = cObject({ subject: filterSubject, predicate: firstProperty });
-          const generator = (rest) => cObject({ ...rest, predicate: firstProperty });
-          if (triple.subject === filterSubject) {
-            result.push(generator);
-          } else {
-            resultAppendage.push(generator);
-          }
-        }
-      });
-      MANY(() => {
-        CONSUME(symbols_exports.semi);
-        OPTION(() => {
-          const predicate = allowPaths ? OR2([
-            { ALT: () => SUBRULE2(verbPath) },
-            { ALT: () => SUBRULE2(verbSimple) }
-          ]) : SUBRULE2(verb);
-          const objects = SUBRULE2(allowPaths ? objectListPath : objectList);
-          ACTION(() => {
-            result.push(
-              ...objects.map((object3) => (partS) => object3({ ...partS, predicate }))
-            );
+      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 }))
+          );
+          ACTION(() => result.push(...triples));
+          MANY2(() => {
+            CONSUME(symbols_exports.semi);
+            parsedSemi = true;
           });
-        });
+        }
       });
-      return [...result, ...resultAppendage];
+      return result;
     }
   };
 }
@@ -10813,20 +10823,20 @@ var propertyListNotEmpty = propertyListNotEmptyImplementation("propertyListNotEm
 var propertyListPathNotEmpty = propertyListNotEmptyImplementation("propertyListPathNotEmpty", true);
 var verbPath = {
   name: "verbPath",
-  impl: ({ SUBRULE }) => () => SUBRULE(path)
+  impl: ({ SUBRULE }) => () => SUBRULE(path, void 0)
 };
 var verbSimple = {
   name: "verbSimple",
-  impl: ({ SUBRULE }) => () => SUBRULE(var_)
+  impl: ({ SUBRULE }) => () => SUBRULE(var_, void 0)
 };
 function objectListImpl(name, allowPaths) {
   return {
     name,
-    impl: ({ ACTION, SUBRULE, AT_LEAST_ONE_SEP }) => () => {
+    impl: ({ ACTION, SUBRULE, AT_LEAST_ONE_SEP }) => (_, arg) => {
       const objects = [];
       AT_LEAST_ONE_SEP({
         DEF: () => {
-          const objectTriples = SUBRULE(allowPaths ? objectPath : object);
+          const objectTriples = SUBRULE(allowPaths ? objectPath : object, arg);
           ACTION(() => objects.push(...objectTriples));
         },
         SEP: symbols_exports.comma
@@ -10840,11 +10850,11 @@ var objectListPath = objectListImpl("objectListPath", true);
 function objectImpl(name, allowPaths) {
   return {
     name,
-    impl: ({ ACTION, SUBRULE }) => () => {
-      const node = SUBRULE(allowPaths ? graphNodePath : graphNode);
+    impl: ({ ACTION, SUBRULE }) => (_, arg) => {
+      const node = SUBRULE(allowPaths ? graphNodePath : graphNode, void 0);
       return ACTION(() => [
-        (part) => ({ ...part, object: node.node }),
-        ...node.triples.map((val) => () => val)
+        { subject: arg.subject, predicate: arg.predicate, object: node.node },
+        ...node.triples
       ]);
     }
   };
@@ -10854,29 +10864,32 @@ var objectPath = objectImpl("objectPath", true);
 var triplesNode = {
   name: "triplesNode",
   impl: ({ SUBRULE, OR }) => () => OR([
-    { ALT: () => SUBRULE(collection) },
-    { ALT: () => SUBRULE(blankNodePropertyList) }
+    { ALT: () => SUBRULE(collection, void 0) },
+    { ALT: () => SUBRULE(blankNodePropertyList, void 0) }
   ])
 };
 var triplesNodePath = {
   name: "triplesNodePath",
   impl: ({ SUBRULE, OR }) => () => OR([
-    { ALT: () => SUBRULE(collectionPath) },
-    { ALT: () => SUBRULE(blankNodePropertyListPath) }
+    { ALT: () => SUBRULE(collectionPath, void 0) },
+    { ALT: () => SUBRULE(blankNodePropertyListPath, void 0) }
   ])
 };
 function blankNodePropertyListImpl(name, allowPaths) {
   return {
     name,
-    impl: ({ ACTION, SUBRULE, CONSUME, context }) => () => {
+    impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
       CONSUME(symbols_exports.LSquare);
-      const propList = SUBRULE(allowPaths ? propertyListPathNotEmpty : propertyListNotEmpty);
+      let blankNode2;
+      const propList = SUBRULE(
+        allowPaths ? propertyListPathNotEmpty : propertyListNotEmpty,
+        { subject: ACTION(() => blankNode2 = C.dataFactory.blankNode()) }
+      );
       CONSUME(symbols_exports.RSquare);
       return ACTION(() => {
-        const subject = context.dataFactory.blankNode();
         return {
-          node: subject,
-          triples: propList.map((part) => part({ subject }))
+          node: blankNode2,
+          triples: propList
         };
       });
     }
@@ -10887,21 +10900,20 @@ var blankNodePropertyListPath = blankNodePropertyListImpl("blankNodePropertyList
 function collectionImpl(name, allowPaths) {
   return {
     name,
-    impl: ({ ACTION, AT_LEAST_ONE, SUBRULE, CONSUME, context }) => () => {
+    impl: ({ ACTION, AT_LEAST_ONE, SUBRULE, CONSUME }) => (C) => {
       const terms = [];
-      const dataFactory = context.dataFactory;
       CONSUME(symbols_exports.LParen);
       AT_LEAST_ONE(() => {
-        terms.push(SUBRULE(allowPaths ? graphNodePath : graphNode));
+        terms.push(SUBRULE(allowPaths ? graphNodePath : graphNode, void 0));
       });
       CONSUME(symbols_exports.RParen);
       return ACTION(() => {
         const triples = [];
         const appendTriples = [];
-        const listHead = dataFactory.blankNode();
+        const listHead = C.dataFactory.blankNode();
         let iterHead = listHead;
-        const predFirst = dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#first" /* FIRST */);
-        const predRest = dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#rest" /* REST */);
+        const predFirst = C.dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#first" /* FIRST */);
+        const predRest = C.dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#rest" /* REST */);
         for (const [index, term] of terms.entries()) {
           const headTriple = {
             subject: iterHead,
@@ -10914,11 +10926,11 @@ function collectionImpl(name, allowPaths) {
             const nilTriple = {
               subject: iterHead,
               predicate: predRest,
-              object: dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#nil" /* NIL */)
+              object: C.dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#nil" /* NIL */)
             };
             triples.push(nilTriple);
           } else {
-            const tail = dataFactory.blankNode();
+            const tail = C.dataFactory.blankNode();
             const linkTriple = {
               subject: iterHead,
               predicate: predRest,
@@ -10941,10 +10953,10 @@ var collectionPath = collectionImpl("collectionPath", true);
 function graphNodeImpl(name, allowPaths) {
   return {
     name,
-    impl: ({ SUBRULE, OR, context }) => () => OR([
+    impl: ({ SUBRULE, OR }) => (C) => OR([
       {
         ALT: () => {
-          const val = SUBRULE(varOrTerm);
+          const val = SUBRULE(varOrTerm, void 0);
           return {
             node: val,
             triples: []
@@ -10952,8 +10964,8 @@ function graphNodeImpl(name, allowPaths) {
         }
       },
       {
-        GATE: () => context.parseMode.has(canCreateBlankNodes),
-        ALT: () => SUBRULE(allowPaths ? triplesNodePath : triplesNode)
+        GATE: () => C.parseMode.has("canCreateBlankNodes"),
+        ALT: () => SUBRULE(allowPaths ? triplesNodePath : triplesNode, void 0)
       }
     ])
   };
@@ -10964,21 +10976,22 @@ var graphNodePath = graphNodeImpl("graphNodePath", true);
 // ../rules-sparql-1-1/lib/grammar/general.ts
 var prologue = {
   name: "prologue",
-  impl: ({ ACTION, SUBRULE, MANY, OR, context }) => () => {
-    const result = {
+  impl: ({ ACTION, SUBRULE, MANY, OR }) => (C) => {
+    const result = ACTION(() => ({
       prefixes: {},
-      ...context.baseIRI && { base: context.baseIRI }
-    };
+      ...C.baseIRI && { base: C.baseIRI }
+    }));
     MANY(() => {
       OR([
         {
           ALT: () => {
-            result.base = SUBRULE(baseDecl2);
+            const base = SUBRULE(baseDecl2, void 0);
+            ACTION(() => result.base = base);
           }
         },
         {
           ALT: () => {
-            const pref = SUBRULE(prefixDecl2);
+            const pref = SUBRULE(prefixDecl2, void 0);
             ACTION(() => {
               const [name, value] = pref;
               result.prefixes[name] = value;
@@ -10992,683 +11005,318 @@ var prologue = {
 };
 var baseDecl2 = {
   name: "baseDecl",
-  impl: ({ CONSUME, ACTION, context }) => () => {
+  impl: ({ CONSUME, ACTION }) => (C) => {
     CONSUME(baseDecl);
     const base = CONSUME(terminals_exports.iriRef).image.slice(1, -1);
     return ACTION(() => {
-      context.baseIRI = base;
+      C.baseIRI = base;
       return base;
     });
   }
 };
 var prefixDecl2 = {
   name: "prefixDecl",
-  impl: ({ CONSUME, ACTION, context }) => () => {
+  impl: ({ CONSUME, ACTION }) => (C) => {
     CONSUME(prefixDecl);
     const name = CONSUME(terminals_exports.pNameNs).image.slice(0, -1);
     const value = CONSUME(terminals_exports.iriRef).image.slice(1, -1);
     return ACTION(() => {
-      const fullIri = resolveIRI(value, context.baseIRI);
-      context.prefixes[name] = fullIri;
+      const fullIri = resolveIRI(value, C.baseIRI);
+      C.prefixes[name] = fullIri;
       return [name, fullIri];
     });
   }
 };
 var triplesTemplate = {
   name: "triplesTemplate",
-  impl: ({ SUBRULE, CONSUME, OPTION1, OPTION2 }) => () => {
+  impl: ({ ACTION, AT_LEAST_ONE, SUBRULE, CONSUME, OPTION }) => () => {
     const triples = [];
-    triples.push(SUBRULE(triplesSameSubject));
-    OPTION1(() => {
-      CONSUME(symbols_exports.dot);
-      OPTION2(() => {
-        triples.push(SUBRULE(triplesTemplate));
-      });
+    let parsedDot = true;
+    AT_LEAST_ONE({
+      GATE: () => parsedDot,
+      DEF: () => {
+        parsedDot = false;
+        const template = SUBRULE(triplesSameSubject, void 0);
+        ACTION(() => {
+          triples.push(...template);
+        });
+        OPTION(() => {
+          CONSUME(symbols_exports.dot);
+          parsedDot = true;
+        });
+      }
     });
-    return triples.flat(1);
+    return triples;
   }
 };
 var verb = {
   name: "verb",
   impl: ({ SUBRULE, OR }) => () => OR([
-    { ALT: () => SUBRULE(varOrIri) },
+    { ALT: () => SUBRULE(varOrIri, void 0) },
     {
-      ALT: () => SUBRULE(verbA)
+      ALT: () => SUBRULE(verbA, void 0)
     }
   ])
 };
 var verbA = {
   name: "VerbA",
-  impl: ({ CONSUME, context }) => () => {
+  impl: ({ ACTION, CONSUME }) => (C) => {
     CONSUME(a);
-    return context.dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#type" /* TYPE */);
+    return ACTION(() => C.dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#type" /* TYPE */));
   }
 };
 var varOrTerm = {
   name: "varOrTerm",
-  impl: ({ SUBRULE, OR, context }) => () => OR([
-    { GATE: () => context.parseMode.has(canParseVars), ALT: () => SUBRULE(var_) },
-    { ALT: () => SUBRULE(graphTerm) }
+  impl: ({ SUBRULE, OR }) => (C) => OR([
+    { GATE: () => C.parseMode.has("canParseVars"), ALT: () => SUBRULE(var_, void 0) },
+    { ALT: () => SUBRULE(graphTerm, void 0) }
   ])
 };
 var varOrIri = {
   name: "varOrIri",
-  impl: ({ SUBRULE, OR, context }) => () => OR([
-    { GATE: () => context.parseMode.has(canParseVars), ALT: () => SUBRULE(var_) },
-    { ALT: () => SUBRULE(iri2) }
+  impl: ({ SUBRULE, OR }) => (C) => OR([
+    { GATE: () => C.parseMode.has("canParseVars"), ALT: () => SUBRULE(var_, void 0) },
+    { ALT: () => SUBRULE(iri2, void 0) }
   ])
 };
-var canParseVars = Symbol("canParseVars");
 var var_ = {
   name: "var",
-  impl: ({ ACTION, CONSUME, OR, context }) => () => {
-    const result = OR([
-      { ALT: () => context.dataFactory.variable(CONSUME(terminals_exports.var1).image.slice(1)) },
-      { ALT: () => context.dataFactory.variable(CONSUME(terminals_exports.var2).image.slice(1)) }
+  impl: ({ ACTION, CONSUME, OR }) => (C) => {
+    const varVal = OR([
+      { ALT: () => CONSUME(terminals_exports.var1).image.slice(1) },
+      { ALT: () => CONSUME(terminals_exports.var2).image.slice(1) }
     ]);
     ACTION(() => {
-      if (!context.parseMode.has(canParseVars)) {
+      if (!C.parseMode.has("canParseVars")) {
         throw new Error("Variables are not allowed here");
       }
     });
-    return result;
+    return ACTION(() => C.dataFactory.variable(varVal));
   }
 };
 var graphTerm = {
   name: "graphTerm",
-  impl: ({ SUBRULE, CONSUME, OR, context }) => () => OR([
-    { ALT: () => SUBRULE(iri2) },
-    { ALT: () => SUBRULE(rdfLiteral) },
-    { ALT: () => SUBRULE(numericLiteral) },
-    { ALT: () => SUBRULE(booleanLiteral) },
-    { GATE: () => context.parseMode.has(canCreateBlankNodes), ALT: () => SUBRULE(blankNode) },
+  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: () => {
         CONSUME(terminals_exports.nil);
-        return context.dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#nil" /* NIL */);
+        return ACTION(() => C.dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#nil" /* NIL */));
       }
     }
   ])
 };
 
-// ../rules-sparql-1-1/lib/grammar/expression.ts
-var argList = {
-  name: "argList",
-  impl: ({ CONSUME, SUBRULE1, OPTION, OR, MANY_SEP }) => () => OR([
-    {
-      ALT: () => {
-        CONSUME(terminals_exports.nil);
-        return {
-          type: "functionCall",
-          args: [],
-          distinct: false
-        };
+// ../rules-sparql-1-1/lib/utils.ts
+function deGroupSingle(group) {
+  return group.patterns.length === 1 ? group.patterns[0] : group;
+}
+function isVariable(term) {
+  return "termType" in term && term.termType === "Variable";
+}
+
+// ../rules-sparql-1-1/lib/grammar/whereClause.ts
+var whereClause = {
+  name: "whereClause",
+  impl: ({ ACTION, SUBRULE, CONSUME, OPTION }) => () => {
+    OPTION(() => {
+      CONSUME(where);
+    });
+    const group = SUBRULE(groupGraphPattern, void 0);
+    return ACTION(() => group.patterns);
+  }
+};
+var groupGraphPattern = {
+  name: "groupGraphPattern",
+  impl: ({ SUBRULE, CONSUME, OR }) => () => {
+    CONSUME(symbols_exports.LCurly);
+    const patterns = OR([
+      { ALT: () => [SUBRULE(subSelect, void 0)] },
+      { ALT: () => SUBRULE(groupGraphPatternSub, void 0) }
+    ]);
+    CONSUME(symbols_exports.RCurly);
+    return {
+      type: "group",
+      patterns
+    };
+  }
+};
+function findBoundVarsFromGroupGraphPattern(pattern, boundedVars) {
+  if ("triples" in pattern) {
+    for (const triple of pattern.triples) {
+      if (isVariable(triple.subject)) {
+        boundedVars.add(triple.subject.value);
       }
-    },
-    {
-      ALT: () => {
-        const args = [];
-        CONSUME(symbols_exports.LParen);
-        const distinct2 = OPTION(() => CONSUME(distinct)) && true;
-        MANY_SEP({
-          DEF: () => args.push(SUBRULE1(expression)),
-          SEP: symbols_exports.comma
-        });
-        CONSUME(symbols_exports.RParen);
-        return {
-          type: "functionCall",
-          args,
-          distinct: Boolean(distinct2)
-        };
+      if (isVariable(triple.predicate)) {
+        boundedVars.add(triple.predicate.value);
+      }
+      if (isVariable(triple.object)) {
+        boundedVars.add(triple.object.value);
       }
     }
-  ])
-};
-var expressionList = {
-  name: "expressionList",
-  impl: ({ CONSUME, SUBRULE, MANY_SEP, OR }) => () => OR([
-    {
-      ALT: () => {
-        CONSUME(terminals_exports.nil);
-        return [];
+  } else if ("patterns" in pattern) {
+    for (const pat of pattern.patterns) {
+      findBoundVarsFromGroupGraphPattern(pat, boundedVars);
+    }
+  }
+}
+var groupGraphPatternSub = {
+  name: "groupGraphPatternSub",
+  impl: ({ ACTION, SUBRULE, CONSUME, MANY, SUBRULE1, SUBRULE2, OPTION1, OPTION2, OPTION3 }) => () => {
+    const patterns = [];
+    const bgpPattern = OPTION1(() => SUBRULE1(triplesBlock, void 0));
+    ACTION(() => {
+      if (bgpPattern) {
+        patterns.push(bgpPattern);
       }
-    },
-    {
-      ALT: () => {
-        const args = [];
-        CONSUME(symbols_exports.LParen);
-        MANY_SEP({
-          SEP: symbols_exports.comma,
-          DEF: () => {
-            args.push(SUBRULE(expression));
+    });
+    MANY(() => {
+      const notTriples = SUBRULE(graphPatternNotTriples, void 0);
+      patterns.push(notTriples);
+      OPTION2(() => CONSUME(symbols_exports.dot));
+      const moreTriples = OPTION3(() => SUBRULE2(triplesBlock, void 0));
+      ACTION(() => {
+        if (moreTriples) {
+          patterns.push(moreTriples);
+        }
+      });
+    });
+    ACTION(() => {
+      const boundedVars = /* @__PURE__ */ new Set();
+      for (const pattern of patterns) {
+        if (pattern.type === "bind") {
+          if (boundedVars.has(pattern.variable.value)) {
+            throw new Error(`Variable used to bind is already bound (?${pattern.variable.value})`);
           }
-        });
-        CONSUME(symbols_exports.RParen);
-        return args;
+        } else if (pattern.type === "group" || pattern.type === "bgp") {
+          findBoundVarsFromGroupGraphPattern(pattern, boundedVars);
+        }
       }
-    }
+    });
+    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) }
   ])
 };
-var expression = {
-  name: "expression",
-  impl: ({ SUBRULE }) => () => SUBRULE(conditionalOrExpression)
+var optionalGraphPattern = {
+  name: "optionalGraphPattern",
+  impl: ({ ACTION, SUBRULE, CONSUME }) => () => {
+    CONSUME(optional);
+    const group = SUBRULE(groupGraphPattern, void 0);
+    return ACTION(() => ({
+      type: "optional",
+      patterns: group.patterns
+    }));
+  }
 };
-function constructLeftDeep(startGenerator, restGenerator, ACTION, MANY) {
-  let iterExpr = startGenerator();
-  MANY(() => {
-    const res = restGenerator();
-    ACTION(() => {
-      iterExpr = {
-        type: "operation",
-        operator: res.operator,
-        args: [iterExpr, res.expr]
-      };
-    });
-  });
-  return iterExpr;
-}
-var conditionalOrExpression = {
-  name: "conditionalOrExpression",
-  impl: ({ ACTION, MANY, CONSUME, SUBRULE1, SUBRULE2 }) => () => constructLeftDeep(() => SUBRULE1(conditionalAndExpression), () => {
-    CONSUME(symbols_exports.logicOr);
+var graphGraphPattern = {
+  name: "graphGraphPattern",
+  impl: ({ ACTION, SUBRULE, CONSUME }) => () => {
+    CONSUME(graph_exports.graph);
+    const name = SUBRULE(varOrIri, void 0);
+    const group = SUBRULE(groupGraphPattern, void 0);
+    return ACTION(() => ({
+      type: "graph",
+      name,
+      patterns: group.patterns
+    }));
+  }
+};
+var serviceGraphPattern = {
+  name: "serviceGraphPattern",
+  impl: ({ SUBRULE, CONSUME, OPTION }) => () => {
+    CONSUME(service);
+    const silent2 = Boolean(OPTION(() => CONSUME(silent)));
+    const name = SUBRULE(varOrIri, void 0);
+    const group = SUBRULE(groupGraphPattern, void 0);
     return {
-      expr: SUBRULE2(conditionalAndExpression),
-      operator: "||"
+      type: "service",
+      name,
+      silent: silent2,
+      patterns: group.patterns
     };
-  }, ACTION, MANY)
-};
-var conditionalAndExpression = {
-  name: "conditionalAndExpression",
-  impl: ({ ACTION, MANY, SUBRULE1, SUBRULE2, CONSUME }) => () => constructLeftDeep(
-    () => SUBRULE1(valueLogical),
-    () => {
-      CONSUME(symbols_exports.logicAnd);
-      return {
-        expr: SUBRULE2(valueLogical),
-        operator: "&&"
-      };
-    },
-    ACTION,
-    MANY
-  )
-};
-var valueLogical = {
-  name: "valueLogical",
-  impl: ({ SUBRULE }) => () => SUBRULE(relationalExpression)
+  }
 };
-var relationalExpression = {
-  name: "relationalExpression",
-  impl: ({ ACTION, CONSUME, SUBRULE1, SUBRULE2, OPTION, OR, SUBRULE3, SUBRULE4, SUBRULE5, SUBRULE6, SUBRULE7 }) => () => {
-    const args1 = SUBRULE1(numericExpression);
-    const arg2 = OPTION(() => OR([
-      {
-        ALT: () => {
-          CONSUME(symbols_exports.equal);
-          const expr = SUBRULE2(numericExpression);
-          return { operator: "=", args: expr };
-        }
-      },
-      {
-        ALT: () => {
-          CONSUME(symbols_exports.notEqual);
-          const expr = SUBRULE3(numericExpression);
-          return { operator: "!=", args: expr };
-        }
-      },
-      {
-        ALT: () => {
-          CONSUME(symbols_exports.lessThan);
-          const expr = SUBRULE4(numericExpression);
-          return { operator: "<", args: expr };
-        }
-      },
-      {
-        ALT: () => {
-          CONSUME(symbols_exports.greaterThan);
-          const expr = SUBRULE5(numericExpression);
-          return { operator: ">", args: expr };
-        }
-      },
-      {
-        ALT: () => {
-          CONSUME(symbols_exports.lessThanEqual);
-          const expr = SUBRULE6(numericExpression);
-          return { operator: "<=", args: expr };
-        }
-      },
-      {
-        ALT: () => {
-          CONSUME(symbols_exports.greaterThanEqual);
-          const expr = SUBRULE7(numericExpression);
-          return { operator: ">=", args: expr };
-        }
-      },
-      {
-        ALT: () => {
-          CONSUME(in_);
-          const args = SUBRULE1(expressionList);
-          return { operator: "in", args };
-        }
-      },
-      {
-        ALT: () => {
-          CONSUME(notIn);
-          const args = SUBRULE2(expressionList);
-          return { operator: "notin", args };
-        }
-      }
-    ]));
-    if (!arg2) {
-      return args1;
-    }
-    return ACTION(() => ({
-      type: "operation",
-      operator: arg2.operator,
-      args: [args1, arg2.args]
-    }));
+var bind2 = {
+  name: "bind",
+  impl: ({ SUBRULE, CONSUME }) => () => {
+    CONSUME(bind);
+    CONSUME(symbols_exports.LParen);
+    const expressionVal = SUBRULE(expression, void 0);
+    CONSUME(as);
+    const variable = SUBRULE(var_, void 0);
+    CONSUME(symbols_exports.RParen);
+    return {
+      type: "bind",
+      variable,
+      expression: expressionVal
+    };
   }
 };
-var numericExpression = {
-  name: "numericExpression",
-  impl: ({ SUBRULE }) => () => SUBRULE(additiveExpression)
+var inlineData = {
+  name: "inlineData",
+  impl: ({ SUBRULE, CONSUME }) => () => {
+    CONSUME(values2);
+    const values3 = SUBRULE(dataBlock, void 0);
+    return {
+      type: "values",
+      values: values3
+    };
+  }
 };
-var additiveExpression = {
-  name: "additiveExpression",
-  impl: ({ ACTION, SUBRULE, CONSUME, SUBRULE1, SUBRULE2, SUBRULE3, MANY1, MANY2, OR1, OR2, OR3 }) => () => constructLeftDeep(
-    () => SUBRULE1(multiplicativeExpression),
-    () => OR1([
-      {
-        ALT: () => {
-          CONSUME(symbols_exports.opPlus);
-          return {
-            operator: "+",
-            expr: SUBRULE2(multiplicativeExpression)
-          };
-        }
-      },
-      {
-        ALT: () => {
-          CONSUME(symbols_exports.opMinus);
-          return {
-            operator: "-",
-            expr: SUBRULE3(multiplicativeExpression)
-          };
-        }
-      },
-      {
-        ALT: () => {
-          const { operator, args } = OR2([
-            {
-              ALT: () => {
-                const integer2 = SUBRULE(numericLiteralPositive);
-                return ACTION(() => {
-                  integer2.value = integer2.value.replace(/^\+/u, "");
-                  return {
-                    operator: "+",
-                    args: [integer2]
-                  };
-                });
-              }
-            },
-            {
-              ALT: () => {
-                const integer2 = SUBRULE(numericLiteralNegative);
-                return ACTION(() => {
-                  integer2.value = integer2.value.replace(/^-/u, "");
-                  return {
-                    operator: "-",
-                    args: [integer2]
-                  };
-                });
-              }
-            }
-          ]);
-          const expr = constructLeftDeep(
-            () => ACTION(() => args[0]),
-            () => OR3([
-              {
-                ALT: () => {
-                  CONSUME(symbols_exports.star);
-                  const expr2 = SUBRULE1(unaryExpression);
-                  return {
-                    operator: "*",
-                    expr: expr2
-                  };
-                }
-              },
-              {
-                ALT: () => {
-                  CONSUME(symbols_exports.slash);
-                  const expr2 = SUBRULE2(unaryExpression);
-                  return {
-                    operator: "/",
-                    expr: expr2
-                  };
-                }
-              }
-            ]),
-            ACTION,
-            MANY2
-          );
-          return {
-            operator,
-            expr
-          };
-        }
-      }
-    ]),
-    ACTION,
-    MANY1
-  )
+var dataBlock = {
+  name: "dataBlock",
+  impl: ({ SUBRULE, OR }) => () => OR([
+    { ALT: () => SUBRULE(inlineDataOneVar, void 0) },
+    { ALT: () => SUBRULE(inlineDataFull, void 0) }
+  ])
 };
-var multiplicativeExpression = {
-  name: "multiplicativeExpression",
-  impl: ({ ACTION, CONSUME, MANY, SUBRULE1, SUBRULE2, SUBRULE3, OR }) => () => constructLeftDeep(
-    () => SUBRULE1(unaryExpression),
-    () => OR([
-      {
-        ALT: () => {
-          CONSUME(symbols_exports.star);
-          const expr = SUBRULE2(unaryExpression);
-          return {
-            operator: "*",
-            expr
-          };
-        }
-      },
-      {
-        ALT: () => {
-          CONSUME(symbols_exports.slash);
-          const expr = SUBRULE3(unaryExpression);
-          return {
-            operator: "/",
-            expr
-          };
-        }
-      }
-    ]),
-    ACTION,
-    MANY
-  )
+var inlineDataOneVar = {
+  name: "inlineDataOneVar",
+  impl: ({ ACTION, SUBRULE, CONSUME, MANY }) => () => {
+    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
+      }));
+    });
+    CONSUME(symbols_exports.RCurly);
+    return res;
+  }
 };
-var unaryExpression = {
-  name: "unaryExpression",
-  impl: ({ CONSUME, SUBRULE1, SUBRULE2, SUBRULE3, SUBRULE4, OR }) => () => OR([
+var inlineDataFull = {
+  name: "inlineDataFull",
+  impl: ({ ACTION, OR, MANY1, MANY2, MANY3, MANY4, SUBRULE, CONSUME1, CONSUME2 }) => () => OR([
+    // Grammar rule 64 together with note 11 learns us that a nil should be followed by a nil in DataBlock.
     {
       ALT: () => {
-        CONSUME(symbols_exports.exclamation);
-        const expr = SUBRULE1(primaryExpression);
-        return {
-          type: "operation",
-          operator: "!",
-          args: [expr]
-        };
-      }
-    },
-    {
-      ALT: () => {
-        CONSUME(symbols_exports.opPlus);
-        const expr = SUBRULE2(primaryExpression);
-        return {
-          type: "operation",
-          operator: "UPLUS",
-          args: [expr]
-        };
-      }
-    },
-    {
-      ALT: () => {
-        CONSUME(symbols_exports.opMinus);
-        const expr = SUBRULE3(primaryExpression);
-        return {
-          type: "operation",
-          operator: "UMINUS",
-          args: [expr]
-        };
-      }
-    },
-    { ALT: () => SUBRULE4(primaryExpression) }
-  ])
-};
-var primaryExpression = {
-  name: "primaryExpression",
-  impl: ({ SUBRULE, OR }) => () => OR([
-    { 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: ({ SUBRULE, CONSUME }) => () => {
-    CONSUME(symbols_exports.LParen);
-    const expr = SUBRULE(expression);
-    CONSUME(symbols_exports.RParen);
-    return expr;
-  }
-};
-var iriOrFunction = {
-  name: "iriOrFunction",
-  impl: ({ SUBRULE, OPTION }) => () => {
-    const iriVal = SUBRULE(iri2);
-    const args = OPTION(() => SUBRULE(argList));
-    return args ? {
-      ...args,
-      function: iriVal
-    } : iriVal;
-  }
-};
-
-// ../rules-sparql-1-1/lib/utils.ts
-function deGroupSingle(group) {
-  return group.patterns.length === 1 ? group.patterns[0] : group;
-}
-function isVariable(term) {
-  return "termType" in term && term.termType === "Variable";
-}
-
-// ../rules-sparql-1-1/lib/grammar/whereClause.ts
-var whereClause = {
-  name: "whereClause",
-  impl: ({ ACTION, SUBRULE, CONSUME, OPTION }) => () => {
-    OPTION(() => {
-      CONSUME(where);
-    });
-    const group = SUBRULE(groupGraphPattern);
-    return ACTION(() => group.patterns);
-  }
-};
-var groupGraphPattern = {
-  name: "groupGraphPattern",
-  impl: ({ SUBRULE, CONSUME, OR }) => () => {
-    CONSUME(symbols_exports.LCurly);
-    const patterns = OR([
-      { ALT: () => [SUBRULE(subSelect)] },
-      { ALT: () => SUBRULE(groupGraphPatternSub) }
-    ]);
-    CONSUME(symbols_exports.RCurly);
-    return {
-      type: "group",
-      patterns
-    };
-  }
-};
-function findBoundVarsFromGroupGraphPattern(pattern, boundedVars) {
-  if ("triples" in pattern) {
-    for (const triple of pattern.triples) {
-      if (isVariable(triple.subject)) {
-        boundedVars.add(triple.subject.value);
-      }
-      if (isVariable(triple.predicate)) {
-        boundedVars.add(triple.predicate.value);
-      }
-      if (isVariable(triple.object)) {
-        boundedVars.add(triple.object.value);
-      }
-    }
-  } else if ("patterns" in pattern) {
-    for (const pat of pattern.patterns) {
-      findBoundVarsFromGroupGraphPattern(pat, boundedVars);
-    }
-  }
-}
-var groupGraphPatternSub = {
-  name: "groupGraphPatternSub",
-  impl: ({ ACTION, SUBRULE, CONSUME, MANY, SUBRULE1, SUBRULE2, OPTION1, OPTION2, OPTION3 }) => () => {
-    const patterns = [];
-    const bgpPattern = OPTION1(() => SUBRULE1(triplesBlock));
-    ACTION(() => {
-      if (bgpPattern) {
-        patterns.push(bgpPattern);
-      }
-    });
-    MANY(() => {
-      const notTriples = SUBRULE(graphPatternNotTriples);
-      patterns.push(notTriples);
-      OPTION2(() => CONSUME(symbols_exports.dot));
-      const moreTriples = OPTION3(() => SUBRULE2(triplesBlock));
-      ACTION(() => {
-        if (moreTriples) {
-          patterns.push(moreTriples);
-        }
-      });
-    });
-    ACTION(() => {
-      const boundedVars = /* @__PURE__ */ new Set();
-      for (const pattern of patterns) {
-        if (pattern.type === "bind") {
-          if (boundedVars.has(pattern.variable.value)) {
-            throw new Error(`Variable used to bind is already bound (?${pattern.variable.value})`);
-          }
-        } else if (pattern.type === "group" || pattern.type === "bgp") {
-          findBoundVarsFromGroupGraphPattern(pattern, boundedVars);
-        }
-      }
-    });
-    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) }
-  ])
-};
-var optionalGraphPattern = {
-  name: "optionalGraphPattern",
-  impl: ({ ACTION, SUBRULE, CONSUME }) => () => {
-    CONSUME(optional);
-    const group = SUBRULE(groupGraphPattern);
-    return ACTION(() => ({
-      type: "optional",
-      patterns: group.patterns
-    }));
-  }
-};
-var graphGraphPattern = {
-  name: "graphGraphPattern",
-  impl: ({ ACTION, SUBRULE, CONSUME }) => () => {
-    CONSUME(graph_exports.graph);
-    const name = SUBRULE(varOrIri);
-    const group = SUBRULE(groupGraphPattern);
-    return ACTION(() => ({
-      type: "graph",
-      name,
-      patterns: group.patterns
-    }));
-  }
-};
-var serviceGraphPattern = {
-  name: "serviceGraphPattern",
-  impl: ({ SUBRULE, CONSUME, OPTION }) => () => {
-    CONSUME(service);
-    const silent2 = Boolean(OPTION(() => CONSUME(silent)));
-    const name = SUBRULE(varOrIri);
-    const group = SUBRULE(groupGraphPattern);
-    return {
-      type: "service",
-      name,
-      silent: silent2,
-      patterns: group.patterns
-    };
-  }
-};
-var bind2 = {
-  name: "bind",
-  impl: ({ SUBRULE, CONSUME }) => () => {
-    CONSUME(bind);
-    CONSUME(symbols_exports.LParen);
-    const expressionVal = SUBRULE(expression);
-    CONSUME(as);
-    const variable = SUBRULE(var_);
-    CONSUME(symbols_exports.RParen);
-    return {
-      type: "bind",
-      variable,
-      expression: expressionVal
-    };
-  }
-};
-var inlineData = {
-  name: "inlineData",
-  impl: ({ SUBRULE, CONSUME }) => () => {
-    CONSUME(values2);
-    const values3 = SUBRULE(dataBlock);
-    return {
-      type: "values",
-      values: values3
-    };
-  }
-};
-var dataBlock = {
-  name: "dataBlock",
-  impl: ({ SUBRULE, OR }) => () => OR([
-    { ALT: () => SUBRULE(inlineDataOneVar) },
-    { ALT: () => SUBRULE(inlineDataFull) }
-  ])
-};
-var inlineDataOneVar = {
-  name: "inlineDataOneVar",
-  impl: ({ ACTION, SUBRULE, CONSUME, MANY }) => () => {
-    const res = [];
-    const varVal = SUBRULE(var_);
-    CONSUME(symbols_exports.LCurly);
-    MANY(() => {
-      const value = SUBRULE(dataBlockValue);
-      ACTION(() => res.push({
-        [`?${varVal.value}`]: value
-      }));
-    });
-    CONSUME(symbols_exports.RCurly);
-    return res;
-  }
-};
-var inlineDataFull = {
-  name: "inlineDataFull",
-  impl: ({ ACTION, OR, MANY1, MANY2, MANY3, MANY4, SUBRULE, CONSUME1, CONSUME2 }) => () => OR([
-    // Grammar rule 64 together with note 11 learns us that a nil should be followed by a nil in DataBlock.
-    {
-      ALT: () => {
-        const res = [];
-        CONSUME1(terminals_exports.nil);
-        CONSUME1(symbols_exports.LCurly);
-        MANY1(() => {
-          CONSUME2(terminals_exports.nil);
-          res.push({});
-        });
-        CONSUME1(symbols_exports.RCurly);
-        return res;
+        const res = [];
+        CONSUME1(terminals_exports.nil);
+        CONSUME1(symbols_exports.LCurly);
+        MANY1(() => {
+          CONSUME2(terminals_exports.nil);
+          res.push({});
+        });
+        CONSUME1(symbols_exports.RCurly);
+        return res;
       }
     },
     {
@@ -11677,7 +11325,7 @@ var inlineDataFull = {
         const vars = [];
         CONSUME1(symbols_exports.LParen);
         MANY2(() => {
-          vars.push(SUBRULE(var_));
+          vars.push(SUBRULE(var_, void 0));
         });
         CONSUME1(symbols_exports.RParen);
         CONSUME2(symbols_exports.LCurly);
@@ -11691,7 +11339,7 @@ var inlineDataFull = {
                   throw new Error("Number of dataBlockValues does not match number of variables. Too much values.");
                 }
               });
-              varBinds.push(SUBRULE(dataBlockValue));
+              varBinds.push(SUBRULE(dataBlockValue, void 0));
             }
           });
           CONSUME2(symbols_exports.RParen);
@@ -11715,10 +11363,10 @@ var inlineDataFull = {
 var dataBlockValue = {
   name: "dataBlockValue",
   impl: ({ SUBRULE, CONSUME, OR }) => () => OR([
-    { ALT: () => SUBRULE(iri2) },
-    { ALT: () => SUBRULE(rdfLiteral) },
-    { ALT: () => SUBRULE(numericLiteral) },
-    { ALT: () => SUBRULE(booleanLiteral) },
+    { ALT: () => SUBRULE(iri2, void 0) },
+    { ALT: () => SUBRULE(rdfLiteral, void 0) },
+    { ALT: () => SUBRULE(numericLiteral, void 0) },
+    { ALT: () => SUBRULE(booleanLiteral, void 0) },
     {
       ALT: () => {
         CONSUME(undef);
@@ -11731,7 +11379,7 @@ var minusGraphPattern = {
   name: "minusGraphPattern",
   impl: ({ ACTION, SUBRULE, CONSUME }) => () => {
     CONSUME(minus);
-    const group = SUBRULE(groupGraphPattern);
+    const group = SUBRULE(groupGraphPattern, void 0);
     return ACTION(() => ({
       type: "minus",
       patterns: group.patterns
@@ -11744,7 +11392,7 @@ var groupOrUnionGraphPattern = {
     const groups = [];
     AT_LEAST_ONE_SEP({
       DEF: () => {
-        const group = SUBRULE(groupGraphPattern);
+        const group = SUBRULE(groupGraphPattern, void 0);
         groups.push(group);
       },
       SEP: union
@@ -11759,7 +11407,7 @@ var filter3 = {
   name: "filter",
   impl: ({ SUBRULE, CONSUME }) => () => {
     CONSUME(filter2);
-    const expression2 = SUBRULE(constraint);
+    const expression2 = SUBRULE(constraint, void 0);
     return {
       type: "filter",
       expression: expression2
@@ -11769,16 +11417,16 @@ var filter3 = {
 var constraint = {
   name: "constraint",
   impl: ({ SUBRULE, OR }) => () => OR([
-    { ALT: () => SUBRULE(brackettedExpression) },
-    { ALT: () => SUBRULE(builtInCall) },
-    { ALT: () => SUBRULE(functionCall) }
+    { ALT: () => SUBRULE(brackettedExpression, void 0) },
+    { ALT: () => SUBRULE(builtInCall, void 0) },
+    { ALT: () => SUBRULE(functionCall, void 0) }
   ])
 };
 var functionCall = {
   name: "functionCall",
   impl: ({ ACTION, SUBRULE }) => () => {
-    const func = SUBRULE(iri2);
-    const args = SUBRULE(argList);
+    const func = SUBRULE(iri2, void 0);
+    const args = SUBRULE(argList, void 0);
     return ACTION(() => ({
       ...args,
       function: func
@@ -11796,7 +11444,7 @@ function funcExpr1(func) {
     impl: ({ SUBRULE, CONSUME }) => () => {
       const operator = CONSUME(func);
       CONSUME(symbols_exports.LParen);
-      const arg = SUBRULE(expression);
+      const arg = SUBRULE(expression, void 0);
       CONSUME(symbols_exports.RParen);
       return {
         type: "operation",
@@ -11812,9 +11460,9 @@ function funcExpr2(func) {
     impl: ({ SUBRULE1, SUBRULE2, CONSUME }) => () => {
       const operator = CONSUME(func);
       CONSUME(symbols_exports.LParen);
-      const arg1 = SUBRULE1(expression);
+      const arg1 = SUBRULE1(expression, void 0);
       CONSUME(symbols_exports.comma);
-      const arg2 = SUBRULE2(expression);
+      const arg2 = SUBRULE2(expression, void 0);
       CONSUME(symbols_exports.RParen);
       return {
         type: "operation",
@@ -11830,11 +11478,11 @@ function funcExpr3(func) {
     impl: ({ SUBRULE1, SUBRULE2, SUBRULE3, CONSUME, CONSUME1, CONSUME2 }) => () => {
       const operator = CONSUME(func);
       CONSUME(symbols_exports.LParen);
-      const arg1 = SUBRULE1(expression);
+      const arg1 = SUBRULE1(expression, void 0);
       CONSUME1(symbols_exports.comma);
-      const arg2 = SUBRULE2(expression);
+      const arg2 = SUBRULE2(expression, void 0);
       CONSUME2(symbols_exports.comma);
-      const arg3 = SUBRULE3(expression);
+      const arg3 = SUBRULE3(expression, void 0);
       CONSUME(symbols_exports.RParen);
       return {
         type: "operation",
@@ -11850,7 +11498,7 @@ function funcVar1(func) {
     impl: ({ SUBRULE, CONSUME }) => () => {
       const operator = CONSUME(func);
       CONSUME(symbols_exports.LParen);
-      const arg = SUBRULE(var_);
+      const arg = SUBRULE(var_, void 0);
       CONSUME(symbols_exports.RParen);
       return {
         type: "operation",
@@ -11869,7 +11517,7 @@ function funcExprOrNil1(func) {
         {
           ALT: () => {
             CONSUME(symbols_exports.LParen);
-            const arg = SUBRULE(expression);
+            const arg = SUBRULE(expression, void 0);
             CONSUME(symbols_exports.RParen);
             return [arg];
           }
@@ -11908,7 +11556,7 @@ function funcExprList1(func) {
     name: unCapitalize(func.name),
     impl: ({ CONSUME, SUBRULE }) => () => {
       const operator = CONSUME(func);
-      const args = SUBRULE(expressionList);
+      const args = SUBRULE(expressionList, void 0);
       return {
         type: "operation",
         operator: formatOperator(operator.image),
@@ -11923,12 +11571,12 @@ function funcExpr2or3(func) {
     impl: ({ CONSUME, SUBRULE1, SUBRULE2, SUBRULE3, CONSUME1, OPTION, CONSUME2 }) => () => {
       const operator = CONSUME(func);
       CONSUME(symbols_exports.LParen);
-      const arg1 = SUBRULE1(expression);
+      const arg1 = SUBRULE1(expression, void 0);
       CONSUME1(symbols_exports.comma);
-      const arg2 = SUBRULE2(expression);
+      const arg2 = SUBRULE2(expression, void 0);
       const arg3 = OPTION(() => {
         CONSUME2(symbols_exports.comma);
-        return SUBRULE3(expression);
+        return SUBRULE3(expression, void 0);
       });
       CONSUME(symbols_exports.RParen);
       return {
@@ -11945,14 +11593,14 @@ function funcExpr3or4(func) {
     impl: ({ CONSUME, SUBRULE1, SUBRULE2, SUBRULE3, CONSUME1, OPTION, CONSUME2, SUBRULE4, CONSUME3 }) => () => {
       const operator = CONSUME(func);
       CONSUME(symbols_exports.LParen);
-      const arg1 = SUBRULE1(expression);
+      const arg1 = SUBRULE1(expression, void 0);
       CONSUME1(symbols_exports.comma);
-      const arg2 = SUBRULE2(expression);
+      const arg2 = SUBRULE2(expression, void 0);
       CONSUME2(symbols_exports.comma);
-      const arg3 = SUBRULE3(expression);
+      const arg3 = SUBRULE3(expression, void 0);
       const arg4 = OPTION(() => {
         CONSUME3(symbols_exports.comma);
-        return SUBRULE4(expression);
+        return SUBRULE4(expression, void 0);
       });
       CONSUME(symbols_exports.RParen);
       return {
@@ -11968,7 +11616,7 @@ function funcGroupGraphPattern(func) {
     name: unCapitalize(func.name),
     impl: ({ ACTION, SUBRULE, CONSUME }) => () => {
       const operator = CONSUME(func);
-      const group = SUBRULE(groupGraphPattern);
+      const group = SUBRULE(groupGraphPattern, void 0);
       return ACTION(() => ({
         type: "operation",
         operator: formatOperator(operator.image),
@@ -11991,7 +11639,7 @@ function baseAggregateFunc(func) {
             return new Wildcard();
           }
         },
-        { ALT: () => SUBRULE(expression) }
+        { ALT: () => SUBRULE(expression, void 0) }
       ]);
       CONSUME(symbols_exports.RParen);
       return {
@@ -12019,236 +11667,579 @@ var builtInBnodeSparqlJs = {
     const args = OR([
       {
         ALT: () => {
-          CONSUME(symbols_exports.LParen);
-          const arg = SUBRULE(expression);
-          CONSUME(symbols_exports.RParen);
-          return [arg];
+          CONSUME(symbols_exports.LParen);
+          const arg = SUBRULE(expression, void 0);
+          CONSUME(symbols_exports.RParen);
+          return [arg];
+        }
+      },
+      {
+        ALT: () => {
+          CONSUME(terminals_exports.nil);
+          return [];
+        }
+      }
+    ]);
+    return {
+      type: "operation",
+      operator: operator.image,
+      args
+    };
+  }
+};
+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);
+    }
+    const builtIns = builtInCallList(SUBRULE);
+    cache.set(builtInCall, builtIns);
+    return OR(builtIns);
+  }
+};
+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 = baseAggregateFunc(BuildinCalls_exports.count);
+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: ({ CONSUME, OPTION1, SUBRULE, OPTION2 }) => () => {
+    CONSUME(BuildinCalls_exports.groupConcat);
+    CONSUME(symbols_exports.LParen);
+    const distinct2 = OPTION1(() => CONSUME(distinct));
+    const expr = SUBRULE(expression, void 0);
+    const separator2 = OPTION2(() => {
+      CONSUME(symbols_exports.semi);
+      CONSUME(separator);
+      CONSUME(symbols_exports.equal);
+      return SUBRULE(string, void 0);
+    }) ?? " ";
+    CONSUME(symbols_exports.RParen);
+    return {
+      type: "aggregate",
+      aggregation: "group_concat",
+      expression: expr,
+      distinct: Boolean(distinct2),
+      separator: separator2
+    };
+  }
+};
+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.");
+      }
+    });
+    return result;
+  }
+};
+
+// ../rules-sparql-1-1/lib/grammar/expression.ts
+var argList = {
+  name: "argList",
+  impl: ({ CONSUME, SUBRULE1, OPTION, OR, MANY_SEP }) => () => OR([
+    {
+      ALT: () => {
+        CONSUME(terminals_exports.nil);
+        return {
+          type: "functionCall",
+          args: [],
+          distinct: false
+        };
+      }
+    },
+    {
+      ALT: () => {
+        const args = [];
+        CONSUME(symbols_exports.LParen);
+        const distinct2 = OPTION(() => CONSUME(distinct)) && true;
+        MANY_SEP({
+          DEF: () => args.push(SUBRULE1(expression, void 0)),
+          SEP: symbols_exports.comma
+        });
+        CONSUME(symbols_exports.RParen);
+        return {
+          type: "functionCall",
+          args,
+          distinct: Boolean(distinct2)
+        };
+      }
+    }
+  ])
+};
+var expressionList = {
+  name: "expressionList",
+  impl: ({ CONSUME, SUBRULE, MANY_SEP, OR }) => () => OR([
+    {
+      ALT: () => {
+        CONSUME(terminals_exports.nil);
+        return [];
+      }
+    },
+    {
+      ALT: () => {
+        const args = [];
+        CONSUME(symbols_exports.LParen);
+        MANY_SEP({
+          SEP: symbols_exports.comma,
+          DEF: () => {
+            args.push(SUBRULE(expression, void 0));
+          }
+        });
+        CONSUME(symbols_exports.RParen);
+        return args;
+      }
+    }
+  ])
+};
+var expression = {
+  name: "expression",
+  impl: ({ SUBRULE }) => () => SUBRULE(conditionalOrExpression, void 0)
+};
+function constructLeftDeep(startGenerator, restGenerator, ACTION, MANY) {
+  let iterExpr = startGenerator();
+  MANY(() => {
+    const res = restGenerator();
+    ACTION(() => {
+      iterExpr = {
+        type: "operation",
+        operator: res.operator,
+        args: [iterExpr, res.expr]
+      };
+    });
+  });
+  return iterExpr;
+}
+var conditionalOrExpression = {
+  name: "conditionalOrExpression",
+  impl: ({ ACTION, MANY, CONSUME, SUBRULE1, SUBRULE2 }) => () => constructLeftDeep(() => SUBRULE1(conditionalAndExpression, void 0), () => {
+    CONSUME(symbols_exports.logicOr);
+    return {
+      expr: SUBRULE2(conditionalAndExpression, void 0),
+      operator: "||"
+    };
+  }, ACTION, MANY)
+};
+var conditionalAndExpression = {
+  name: "conditionalAndExpression",
+  impl: ({ ACTION, MANY, SUBRULE1, SUBRULE2, CONSUME }) => () => constructLeftDeep(
+    () => SUBRULE1(valueLogical, void 0),
+    () => {
+      CONSUME(symbols_exports.logicAnd);
+      return {
+        expr: SUBRULE2(valueLogical, void 0),
+        operator: "&&"
+      };
+    },
+    ACTION,
+    MANY
+  )
+};
+var valueLogical = {
+  name: "valueLogical",
+  impl: ({ SUBRULE }) => () => SUBRULE(relationalExpression, void 0)
+};
+var relationalExpression = {
+  name: "relationalExpression",
+  impl: ({ ACTION, CONSUME, SUBRULE1, SUBRULE2, OPTION, OR, SUBRULE3, SUBRULE4, SUBRULE5, SUBRULE6, SUBRULE7 }) => () => {
+    const args1 = SUBRULE1(numericExpression, void 0);
+    const arg2 = OPTION(() => OR([
+      {
+        ALT: () => {
+          CONSUME(symbols_exports.equal);
+          const expr = SUBRULE2(numericExpression, void 0);
+          return { operator: "=", args: expr };
+        }
+      },
+      {
+        ALT: () => {
+          CONSUME(symbols_exports.notEqual);
+          const expr = SUBRULE3(numericExpression, void 0);
+          return { operator: "!=", args: expr };
+        }
+      },
+      {
+        ALT: () => {
+          CONSUME(symbols_exports.lessThan);
+          const expr = SUBRULE4(numericExpression, void 0);
+          return { operator: "<", args: expr };
+        }
+      },
+      {
+        ALT: () => {
+          CONSUME(symbols_exports.greaterThan);
+          const expr = SUBRULE5(numericExpression, void 0);
+          return { operator: ">", args: expr };
+        }
+      },
+      {
+        ALT: () => {
+          CONSUME(symbols_exports.lessThanEqual);
+          const expr = SUBRULE6(numericExpression, void 0);
+          return { operator: "<=", args: expr };
+        }
+      },
+      {
+        ALT: () => {
+          CONSUME(symbols_exports.greaterThanEqual);
+          const expr = SUBRULE7(numericExpression, void 0);
+          return { operator: ">=", args: expr };
+        }
+      },
+      {
+        ALT: () => {
+          CONSUME(in_);
+          const args = SUBRULE1(expressionList, void 0);
+          return { operator: "in", args };
+        }
+      },
+      {
+        ALT: () => {
+          CONSUME(notIn);
+          const args = SUBRULE2(expressionList, void 0);
+          return { operator: "notin", args };
+        }
+      }
+    ]));
+    if (!arg2) {
+      return args1;
+    }
+    return ACTION(() => ({
+      type: "operation",
+      operator: arg2.operator,
+      args: [args1, arg2.args]
+    }));
+  }
+};
+var numericExpression = {
+  name: "numericExpression",
+  impl: ({ SUBRULE }) => () => SUBRULE(additiveExpression, void 0)
+};
+var additiveExpression = {
+  name: "additiveExpression",
+  impl: ({ ACTION, SUBRULE, CONSUME, SUBRULE1, SUBRULE2, SUBRULE3, MANY1, MANY2, OR1, OR2, OR3 }) => () => constructLeftDeep(
+    () => SUBRULE1(multiplicativeExpression, void 0),
+    () => OR1([
+      {
+        ALT: () => {
+          CONSUME(symbols_exports.opPlus);
+          return {
+            operator: "+",
+            expr: SUBRULE2(multiplicativeExpression, void 0)
+          };
+        }
+      },
+      {
+        ALT: () => {
+          CONSUME(symbols_exports.opMinus);
+          return {
+            operator: "-",
+            expr: SUBRULE3(multiplicativeExpression, void 0)
+          };
+        }
+      },
+      {
+        ALT: () => {
+          const { operator, args } = OR2([
+            {
+              ALT: () => {
+                const integer2 = SUBRULE(numericLiteralPositive, void 0);
+                return ACTION(() => {
+                  integer2.value = integer2.value.replace(/^\+/u, "");
+                  return {
+                    operator: "+",
+                    args: [integer2]
+                  };
+                });
+              }
+            },
+            {
+              ALT: () => {
+                const integer2 = SUBRULE(numericLiteralNegative, void 0);
+                return ACTION(() => {
+                  integer2.value = integer2.value.replace(/^-/u, "");
+                  return {
+                    operator: "-",
+                    args: [integer2]
+                  };
+                });
+              }
+            }
+          ]);
+          const expr = constructLeftDeep(
+            () => ACTION(() => args[0]),
+            () => OR3([
+              {
+                ALT: () => {
+                  CONSUME(symbols_exports.star);
+                  const expr2 = SUBRULE1(unaryExpression, void 0);
+                  return {
+                    operator: "*",
+                    expr: expr2
+                  };
+                }
+              },
+              {
+                ALT: () => {
+                  CONSUME(symbols_exports.slash);
+                  const expr2 = SUBRULE2(unaryExpression, void 0);
+                  return {
+                    operator: "/",
+                    expr: expr2
+                  };
+                }
+              }
+            ]),
+            ACTION,
+            MANY2
+          );
+          return {
+            operator,
+            expr
+          };
+        }
+      }
+    ]),
+    ACTION,
+    MANY1
+  )
+};
+var multiplicativeExpression = {
+  name: "multiplicativeExpression",
+  impl: ({ ACTION, CONSUME, MANY, SUBRULE1, SUBRULE2, SUBRULE3, OR }) => () => constructLeftDeep(
+    () => SUBRULE1(unaryExpression, void 0),
+    () => OR([
+      {
+        ALT: () => {
+          CONSUME(symbols_exports.star);
+          const expr = SUBRULE2(unaryExpression, void 0);
+          return {
+            operator: "*",
+            expr
+          };
         }
       },
       {
         ALT: () => {
-          CONSUME(terminals_exports.nil);
-          return [];
+          CONSUME(symbols_exports.slash);
+          const expr = SUBRULE3(unaryExpression, void 0);
+          return {
+            operator: "/",
+            expr
+          };
         }
       }
-    ]);
-    return {
-      type: "operation",
-      operator: operator.image,
-      args
-    };
-  }
-};
-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) },
-    { 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 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 = baseAggregateFunc(BuildinCalls_exports.count);
-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: ({ CONSUME, OPTION1, SUBRULE, OPTION2 }) => () => {
-    CONSUME(BuildinCalls_exports.groupConcat);
-    CONSUME(symbols_exports.LParen);
-    const distinct2 = OPTION1(() => CONSUME(distinct));
-    const expr = SUBRULE(expression);
-    const separator2 = OPTION2(() => {
-      CONSUME(symbols_exports.semi);
-      CONSUME(separator);
-      CONSUME(symbols_exports.equal);
-      return SUBRULE(string);
-    }) ?? " ";
-    CONSUME(symbols_exports.RParen);
-    return {
-      type: "aggregate",
-      aggregation: "group_concat",
-      expression: expr,
-      distinct: Boolean(distinct2),
-      separator: separator2
-    };
-  }
+    ]),
+    ACTION,
+    MANY
+  )
 };
-var canParseAggregate = Symbol("canParseAggregate");
-var inAggregate = Symbol("inAggregate");
-var aggregate = {
-  name: "aggregate",
-  impl: ({ ACTION, SUBRULE, OR, context }) => () => {
-    const wasInAggregate = context.parseMode.has(inAggregate);
-    ACTION(() => context.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 && context.parseMode.delete(inAggregate));
-    ACTION(() => {
-      if (!context.parseMode.has(canParseAggregate)) {
-        throw new Error("Aggregates are only allowed in SELECT, HAVING, and ORDER BY clauses.");
+var unaryExpression = {
+  name: "unaryExpression",
+  impl: ({ CONSUME, SUBRULE1, SUBRULE2, SUBRULE3, SUBRULE4, OR }) => () => OR([
+    {
+      ALT: () => {
+        CONSUME(symbols_exports.exclamation);
+        const expr = SUBRULE1(primaryExpression, void 0);
+        return {
+          type: "operation",
+          operator: "!",
+          args: [expr]
+        };
       }
-      if (context.parseMode.has(inAggregate)) {
-        throw new Error("An aggregate function is not allowed within an aggregate function.");
+    },
+    {
+      ALT: () => {
+        CONSUME(symbols_exports.opPlus);
+        const expr = SUBRULE2(primaryExpression, void 0);
+        return {
+          type: "operation",
+          operator: "UPLUS",
+          args: [expr]
+        };
       }
-    });
-    return result;
-  }
-};
-
-// ../rules-sparql-1-1/lib/grammar/dataSetClause.ts
-var datasetClause = {
-  name: "datasetClause",
-  impl: ({ SUBRULE, CONSUME, OR }) => () => {
-    CONSUME(from);
-    return OR([
-      { ALT: () => ({ value: SUBRULE(defaultGraphClause), type: "default" }) },
-      { ALT: () => ({ value: SUBRULE(namedGraphClause), type: "named" }) }
-    ]);
-  }
+    },
+    {
+      ALT: () => {
+        CONSUME(symbols_exports.opMinus);
+        const expr = SUBRULE3(primaryExpression, void 0);
+        return {
+          type: "operation",
+          operator: "UMINUS",
+          args: [expr]
+        };
+      }
+    },
+    { ALT: () => SUBRULE4(primaryExpression, void 0) }
+  ])
 };
-var defaultGraphClause = {
-  name: "defaultGraphClause",
-  impl: ({ SUBRULE }) => () => SUBRULE(sourceSelector)
+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) }
+  ])
 };
-var namedGraphClause = {
-  name: "namedGraphClause",
+var brackettedExpression = {
+  name: "brackettedExpression",
   impl: ({ SUBRULE, CONSUME }) => () => {
-    CONSUME(graph_exports.named);
-    return SUBRULE(sourceSelector);
+    CONSUME(symbols_exports.LParen);
+    const expr = SUBRULE(expression, void 0);
+    CONSUME(symbols_exports.RParen);
+    return expr;
   }
 };
-var sourceSelector = {
-  name: "sourceSelector",
-  impl: ({ SUBRULE }) => () => SUBRULE(iri2)
+var iriOrFunction = {
+  name: "iriOrFunction",
+  impl: ({ SUBRULE, OPTION }) => () => {
+    const iriVal = SUBRULE(iri2, void 0);
+    const args = OPTION(() => SUBRULE(argList, void 0));
+    return args ? {
+      ...args,
+      function: iriVal
+    } : iriVal;
+  }
 };
 
 // ../rules-sparql-1-1/lib/grammar/solutionModifier.ts
 var solutionModifier = {
   name: "solutionModifier",
   impl: ({ ACTION, SUBRULE, OPTION1, OPTION2, OPTION3, OPTION4 }) => () => {
-    const group = OPTION1(() => SUBRULE(groupClause));
-    const having2 = OPTION2(() => SUBRULE(havingClause));
-    const order2 = OPTION3(() => SUBRULE(orderClause));
-    const limitAndOffset = OPTION4(() => SUBRULE(limitOffsetClauses));
+    const group = OPTION1(() => SUBRULE(groupClause, void 0));
+    const having2 = OPTION2(() => SUBRULE(havingClause, void 0));
+    const order2 = OPTION3(() => SUBRULE(orderClause, void 0));
+    const limitAndOffset = OPTION4(() => SUBRULE(limitOffsetClauses, void 0));
     return ACTION(() => ({
       ...limitAndOffset,
       ...group && { group },
@@ -12263,7 +12254,7 @@ var groupClause = {
     const groupings = [];
     CONSUME(groupBy2);
     AT_LEAST_ONE(() => {
-      groupings.push(SUBRULE(groupCondition));
+      groupings.push(SUBRULE(groupCondition, void 0));
     });
     return groupings;
   }
@@ -12272,13 +12263,13 @@ var groupCondition = {
   name: "groupCondition",
   impl: ({ SUBRULE, CONSUME, SUBRULE1, SUBRULE2, OPTION, OR }) => () => OR([
     { ALT: () => {
-      const expression2 = SUBRULE(builtInCall);
+      const expression2 = SUBRULE(builtInCall, void 0);
       return {
         expression: expression2
       };
     } },
     { ALT: () => {
-      const expression2 = SUBRULE(functionCall);
+      const expression2 = SUBRULE(functionCall, void 0);
       return {
         expression: expression2
       };
@@ -12286,10 +12277,10 @@ var groupCondition = {
     {
       ALT: () => {
         CONSUME(symbols_exports.LParen);
-        const expressionValue = SUBRULE(expression);
+        const expressionValue = SUBRULE(expression, void 0);
         const variable = OPTION(() => {
           CONSUME(as);
-          return SUBRULE1(var_);
+          return SUBRULE1(var_, void 0);
         });
         CONSUME(symbols_exports.RParen);
         return {
@@ -12299,7 +12290,7 @@ var groupCondition = {
       }
     },
     { ALT: () => {
-      const expression2 = SUBRULE2(var_);
+      const expression2 = SUBRULE2(var_, void 0);
       return {
         expression: expression2
       };
@@ -12308,31 +12299,31 @@ var groupCondition = {
 };
 var havingClause = {
   name: "havingClause",
-  impl: ({ ACTION, AT_LEAST_ONE, SUBRULE, CONSUME, context }) => () => {
+  impl: ({ ACTION, AT_LEAST_ONE, SUBRULE, CONSUME }) => (C) => {
     const expressions = [];
     CONSUME(having);
-    const couldParseAgg = ACTION(() => context.parseMode.has(canParseAggregate) || !context.parseMode.add(canParseAggregate));
+    const couldParseAgg = ACTION(() => C.parseMode.has("canParseAggregate") || !C.parseMode.add("canParseAggregate"));
     AT_LEAST_ONE(() => {
-      expressions.push(SUBRULE(havingCondition));
+      expressions.push(SUBRULE(havingCondition, void 0));
     });
-    ACTION(() => !couldParseAgg && context.parseMode.delete(canParseAggregate));
+    ACTION(() => !couldParseAgg && C.parseMode.delete("canParseAggregate"));
     return expressions;
   }
 };
 var havingCondition = {
   name: "havingCondition",
-  impl: ({ SUBRULE }) => () => SUBRULE(constraint)
+  impl: ({ SUBRULE }) => () => SUBRULE(constraint, void 0)
 };
 var orderClause = {
   name: "orderClause",
-  impl: ({ ACTION, AT_LEAST_ONE, SUBRULE, CONSUME, context }) => () => {
+  impl: ({ ACTION, AT_LEAST_ONE, SUBRULE, CONSUME }) => (C) => {
     const orderings = [];
     CONSUME(order);
-    const couldParseAgg = ACTION(() => context.parseMode.has(canParseAggregate) || !context.parseMode.add(canParseAggregate));
+    const couldParseAgg = ACTION(() => C.parseMode.has("canParseAggregate") || !C.parseMode.add("canParseAggregate"));
     AT_LEAST_ONE(() => {
-      orderings.push(SUBRULE(orderCondition));
+      orderings.push(SUBRULE(orderCondition, void 0));
     });
-    ACTION(() => !couldParseAgg && context.parseMode.delete(canParseAggregate));
+    ACTION(() => !couldParseAgg && C.parseMode.delete("canParseAggregate"));
     return orderings;
   }
 };
@@ -12351,7 +12342,7 @@ var orderCondition = {
             return true;
           } }
         ]);
-        const expr = SUBRULE(brackettedExpression);
+        const expr = SUBRULE(brackettedExpression, void 0);
         return {
           expression: expr,
           descending
@@ -12359,13 +12350,13 @@ var orderCondition = {
       }
     },
     { ALT: () => {
-      const expr = SUBRULE(constraint);
+      const expr = SUBRULE(constraint, void 0);
       return {
         expression: expr
       };
     } },
     { ALT: () => {
-      const expr = SUBRULE(var_);
+      const expr = SUBRULE(var_, void 0);
       return {
         expression: expr
       };
@@ -12377,8 +12368,8 @@ var limitOffsetClauses = {
   impl: ({ SUBRULE1, SUBRULE2, OPTION1, OPTION2, OR }) => () => OR([
     {
       ALT: () => {
-        const limit2 = SUBRULE1(limitClause);
-        const offset2 = OPTION1(() => SUBRULE1(offsetClause));
+        const limit2 = SUBRULE1(limitClause, void 0);
+        const offset2 = OPTION1(() => SUBRULE1(offsetClause, void 0));
         return {
           limit: limit2,
           offset: offset2
@@ -12387,8 +12378,8 @@ var limitOffsetClauses = {
     },
     {
       ALT: () => {
-        const offset2 = SUBRULE2(offsetClause);
-        const limit2 = OPTION2(() => SUBRULE2(limitClause));
+        const offset2 = SUBRULE2(offsetClause, void 0);
+        const limit2 = OPTION2(() => SUBRULE2(limitClause, void 0));
         return {
           limit: limit2,
           offset: offset2
@@ -12415,19 +12406,19 @@ var offsetClause = {
 // ../rules-sparql-1-1/lib/grammar/queryUnit/queryUnit.ts
 var queryUnit = {
   name: "queryUnit",
-  impl: ({ SUBRULE }) => () => SUBRULE(query)
+  impl: ({ SUBRULE }) => () => SUBRULE(query, void 0)
 };
 var query = {
   name: "query",
   impl: ({ ACTION, SUBRULE, OR }) => () => {
-    const prologueValues = SUBRULE(prologue);
+    const prologueValues = SUBRULE(prologue, void 0);
     const queryType = OR([
-      { ALT: () => SUBRULE(selectQuery) },
-      { ALT: () => SUBRULE(constructQuery) },
-      { ALT: () => SUBRULE(describeQuery) },
-      { ALT: () => SUBRULE(askQuery) }
+      { ALT: () => SUBRULE(selectQuery, void 0) },
+      { ALT: () => SUBRULE(constructQuery, void 0) },
+      { ALT: () => SUBRULE(describeQuery, void 0) },
+      { ALT: () => SUBRULE(askQuery, void 0) }
     ]);
-    const values3 = SUBRULE(valuesClause);
+    const values3 = SUBRULE(valuesClause, void 0);
     return ACTION(() => ({
       ...prologueValues,
       ...queryType,
@@ -12439,7 +12430,7 @@ var query = {
 function extractFromOfDataSetClauses(ACTION, MANY, SUBRULE) {
   const datasetClauses = [];
   MANY(() => {
-    datasetClauses.push(SUBRULE(datasetClause));
+    datasetClauses.push(SUBRULE(datasetClause, void 0));
   });
   return ACTION(() => {
     const from2 = {
@@ -12499,11 +12490,11 @@ function getVariablesFromExpression(expression2) {
 }
 var selectQuery = {
   name: "selectQuery",
-  impl: ({ ACTION, SUBRULE, MANY, context }) => () => {
-    const selectVal = SUBRULE(selectClause);
+  impl: ({ ACTION, SUBRULE, MANY }) => (C) => {
+    const selectVal = SUBRULE(selectClause, void 0);
     const from2 = extractFromOfDataSetClauses(ACTION, MANY, SUBRULE);
-    const where2 = SUBRULE(whereClause);
-    const modifier = SUBRULE(solutionModifier);
+    const where2 = SUBRULE(whereClause, void 0);
+    const modifier = SUBRULE(solutionModifier, void 0);
     ACTION(() => {
       if (selectVal.variables.length === 1 && selectVal.variables[0] instanceof Wildcard) {
         if (modifier.group !== void 0) {
@@ -12512,7 +12503,7 @@ var selectQuery = {
         return;
       }
       const variables = selectVal.variables;
-      if (!context.skipValidation) {
+      if (!C.skipValidation) {
         const hasCountAggregate = variables.flatMap(
           (varVal) => "termType" in varVal ? [] : getAggregatesOfExpression(varVal.expression)
         ).some((agg) => agg.aggregation === "count" && !(agg.expression instanceof Wildcard));
@@ -12562,10 +12553,10 @@ var selectQuery = {
 var subSelect = {
   name: "subSelect",
   impl: ({ ACTION, SUBRULE }) => () => {
-    const clause = SUBRULE(selectClause);
-    const where2 = SUBRULE(whereClause);
-    const modifiers = SUBRULE(solutionModifier);
-    const values3 = SUBRULE(valuesClause);
+    const clause = SUBRULE(selectClause, void 0);
+    const where2 = SUBRULE(whereClause, void 0);
+    const modifiers = SUBRULE(solutionModifier, void 0);
+    const values3 = SUBRULE(valuesClause, void 0);
     return ACTION(() => ({
       ...modifiers,
       ...clause,
@@ -12578,9 +12569,9 @@ var subSelect = {
 };
 var selectClause = {
   name: "selectClause",
-  impl: ({ ACTION, AT_LEAST_ONE, SUBRULE, CONSUME, SUBRULE1, SUBRULE2, OPTION, OR1, OR2, OR3, context }) => () => {
+  impl: ({ ACTION, AT_LEAST_ONE, SUBRULE, CONSUME, SUBRULE1, SUBRULE2, OPTION, OR1, OR2, OR3 }) => (C) => {
     CONSUME(select);
-    const couldParseAgg = ACTION(() => context.parseMode.has(canParseAggregate) || !context.parseMode.add(canParseAggregate));
+    const couldParseAgg = ACTION(() => C.parseMode.has("canParseAggregate") || !C.parseMode.add("canParseAggregate"));
     const distinctOrReduced = OPTION(() => OR1([
       { ALT: () => {
         CONSUME(distinct);
@@ -12601,7 +12592,7 @@ var selectClause = {
         const result = [];
         AT_LEAST_ONE(() => OR3([
           { ALT: () => {
-            const raw = SUBRULE1(var_);
+            const raw = SUBRULE1(var_, void 0);
             ACTION(() => {
               if (usedVars.some((v) => v.equals(raw))) {
                 throw new Error(`Variable ${raw.value} used more than once in SELECT clause`);
@@ -12612,9 +12603,9 @@ var selectClause = {
           } },
           { ALT: () => {
             CONSUME(symbols_exports.LParen);
-            const expr = SUBRULE(expression);
+            const expr = SUBRULE(expression, void 0);
             CONSUME(as);
-            const variable = SUBRULE2(var_);
+            const variable = SUBRULE2(var_, void 0);
             CONSUME(symbols_exports.RParen);
             ACTION(() => {
               if (usedVars.some((v) => v.equals(variable))) {
@@ -12631,7 +12622,7 @@ var selectClause = {
         return result;
       } }
     ]);
-    ACTION(() => !couldParseAgg && context.parseMode.delete(canParseAggregate));
+    ACTION(() => !couldParseAgg && C.parseMode.delete("canParseAggregate"));
     return ACTION(() => ({
       ...distinctOrReduced,
       variables
@@ -12645,10 +12636,10 @@ var constructQuery = {
     return OR([
       {
         ALT: () => {
-          const template = SUBRULE(constructTemplate);
+          const template = SUBRULE(constructTemplate, void 0);
           const from2 = extractFromOfDataSetClauses(ACTION, MANY1, SUBRULE1);
-          const where2 = SUBRULE(whereClause);
-          const modifiers = SUBRULE1(solutionModifier);
+          const where2 = SUBRULE(whereClause, void 0);
+          const modifiers = SUBRULE1(solutionModifier, void 0);
           return ACTION(() => ({
             ...modifiers,
             queryType: "CONSTRUCT",
@@ -12663,9 +12654,9 @@ var constructQuery = {
           const from2 = extractFromOfDataSetClauses(ACTION, MANY2, SUBRULE2);
           CONSUME(where);
           CONSUME(symbols_exports.LCurly);
-          const template = OPTION(() => SUBRULE(triplesTemplate));
+          const template = OPTION(() => SUBRULE(triplesTemplate, void 0));
           CONSUME(symbols_exports.RCurly);
-          const modifiers = SUBRULE2(solutionModifier);
+          const modifiers = SUBRULE2(solutionModifier, void 0);
           const where2 = template ? [{
             type: "bgp",
             triples: template
@@ -12690,7 +12681,7 @@ var describeQuery = {
       { ALT: () => {
         const variables2 = [];
         AT_LEAST_ONE(() => {
-          variables2.push(SUBRULE(varOrIri));
+          variables2.push(SUBRULE(varOrIri, void 0));
         });
         return variables2;
       } },
@@ -12700,8 +12691,8 @@ var describeQuery = {
       } }
     ]);
     const from2 = extractFromOfDataSetClauses(ACTION, MANY, SUBRULE);
-    const where2 = OPTION(() => SUBRULE(whereClause));
-    const modifiers = SUBRULE(solutionModifier);
+    const where2 = OPTION(() => SUBRULE(whereClause, void 0));
+    const modifiers = SUBRULE(solutionModifier, void 0);
     return ACTION(() => ({
       ...modifiers,
       queryType: "DESCRIBE",
@@ -12716,8 +12707,8 @@ var askQuery = {
   impl: ({ ACTION, SUBRULE, CONSUME, MANY }) => () => {
     CONSUME(ask);
     const from2 = extractFromOfDataSetClauses(ACTION, MANY, SUBRULE);
-    const where2 = SUBRULE(whereClause);
-    const modifiers = SUBRULE(solutionModifier);
+    const where2 = SUBRULE(whereClause, void 0);
+    const modifiers = SUBRULE(solutionModifier, void 0);
     return ACTION(() => ({
       ...modifiers,
       queryType: "ASK",
@@ -12730,14 +12721,14 @@ var valuesClause = {
   name: "valuesClause",
   impl: ({ SUBRULE, CONSUME, OPTION }) => () => OPTION(() => {
     CONSUME(values2);
-    return SUBRULE(dataBlock);
+    return SUBRULE(dataBlock, void 0);
   })
 };
 var constructTemplate = {
   name: "constructTemplate",
   impl: ({ SUBRULE, CONSUME, OPTION }) => () => {
     CONSUME(symbols_exports.LCurly);
-    const triples = OPTION(() => SUBRULE(constructTriples));
+    const triples = OPTION(() => SUBRULE(constructTriples, void 0));
     CONSUME(symbols_exports.RCurly);
     return triples;
   }
@@ -12746,11 +12737,11 @@ var constructTriples = {
   name: "constructTriples",
   impl: ({ SUBRULE, CONSUME, OPTION1, OPTION2 }) => () => {
     const triples = [];
-    triples.push(SUBRULE(triplesSameSubject));
+    triples.push(SUBRULE(triplesSameSubject, void 0));
     OPTION1(() => {
       CONSUME(symbols_exports.dot);
       OPTION2(() => {
-        triples.push(SUBRULE(constructTriples));
+        triples.push(SUBRULE(constructTriples, void 0));
       });
     });
     return triples.flat(1);
@@ -12761,16 +12752,15 @@ var constructTriples = {
 var updateUnit = {
   name: "updateUnit",
   impl: ({ ACTION, SUBRULE }) => () => {
-    const data = SUBRULE(update);
+    const data = SUBRULE(update, void 0);
     ACTION(() => data.updates.reverse());
     return data;
   }
 };
 var update = {
   name: "update",
-  impl: ({ ACTION, SUBRULE, CONSUME, OPTION1, OPTION2, context }) => () => {
-    const blankLabelsUsedInInsertData = /* @__PURE__ */ new Set();
-    const prologueValues = SUBRULE(prologue);
+  impl: ({ ACTION, SUBRULE, CONSUME, OPTION1, OPTION2 }) => () => {
+    const prologueValues = SUBRULE(prologue, void 0);
     const result = {
       type: "update",
       base: prologueValues.base,
@@ -12778,10 +12768,10 @@ var update = {
       updates: []
     };
     OPTION1(() => {
-      const updateOperation = SUBRULE(update1);
+      const updateOperation = SUBRULE(update1, void 0);
       const recursiveRes = OPTION2(() => {
         CONSUME(symbols_exports.semi);
-        return SUBRULE(update);
+        return SUBRULE(update, void 0);
       });
       return ACTION(() => {
         result.updates.push(updateOperation);
@@ -12798,17 +12788,17 @@ var update = {
 var update1 = {
   name: "update1",
   impl: ({ SUBRULE, OR }) => () => OR([
-    { 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) }
+    { 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) }
   ])
 };
 var load2 = {
@@ -12816,10 +12806,10 @@ var load2 = {
   impl: ({ SUBRULE, CONSUME, OPTION1, OPTION2 }) => () => {
     CONSUME(load);
     const silent2 = Boolean(OPTION1(() => CONSUME(silent)));
-    const source = SUBRULE(iri2);
+    const source = SUBRULE(iri2, void 0);
     const destination = OPTION2(() => {
       CONSUME(loadInto);
-      return SUBRULE(graphRef);
+      return SUBRULE(graphRef, void 0);
     });
     return {
       type: "load",
@@ -12834,7 +12824,7 @@ var clear2 = {
   impl: ({ SUBRULE, CONSUME, OPTION }) => () => {
     CONSUME(clear);
     const silent2 = Boolean(OPTION(() => CONSUME(silent)));
-    const graph2 = SUBRULE(graphRefAll);
+    const graph2 = SUBRULE(graphRefAll, void 0);
     return {
       type: "clear",
       silent: silent2,
@@ -12847,7 +12837,7 @@ var drop3 = {
   impl: ({ SUBRULE, CONSUME, OPTION }) => () => {
     CONSUME(drop2);
     const silent2 = Boolean(OPTION(() => CONSUME(silent)));
-    const graph2 = SUBRULE(graphRefAll);
+    const graph2 = SUBRULE(graphRefAll, void 0);
     return {
       type: "drop",
       silent: silent2,
@@ -12860,7 +12850,7 @@ var create2 = {
   impl: ({ SUBRULE, CONSUME, OPTION }) => () => {
     CONSUME(create);
     const silent2 = Boolean(OPTION(() => CONSUME(silent)));
-    const graph2 = SUBRULE(graphRef);
+    const graph2 = SUBRULE(graphRef, void 0);
     return {
       type: "create",
       silent: silent2,
@@ -12877,9 +12867,9 @@ function copyMoveAddOperation(operation) {
     impl: ({ CONSUME, SUBRULE1, SUBRULE2, OPTION }) => () => {
       CONSUME(operation);
       const silent2 = Boolean(OPTION(() => CONSUME(silent)));
-      const source = SUBRULE1(graphOrDefault);
+      const source = SUBRULE1(graphOrDefault, void 0);
       CONSUME(to);
-      const destination = SUBRULE2(graphOrDefault);
+      const destination = SUBRULE2(graphOrDefault, void 0);
       return {
         type: unCapitalize(operation.name),
         silent: silent2,
@@ -12897,7 +12887,7 @@ var insertData = {
   impl: ({ SUBRULE, CONSUME }) => () => {
     CONSUME(insertClause);
     CONSUME(dataClause);
-    const insert = SUBRULE(quadData);
+    const insert = SUBRULE(quadData, void 0);
     return {
       updateType: "insert",
       insert
@@ -12906,12 +12896,12 @@ var insertData = {
 };
 var deleteData = {
   name: "deleteData",
-  impl: ({ ACTION, SUBRULE, CONSUME, context }) => () => {
+  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
     CONSUME(deleteClause);
     CONSUME(dataClause);
-    const couldCreateBlankNodes = ACTION(() => context.parseMode.delete(canCreateBlankNodes));
-    const del = SUBRULE(quadData);
-    ACTION(() => couldCreateBlankNodes && context.parseMode.add(canCreateBlankNodes));
+    const couldCreateBlankNodes = ACTION(() => C.parseMode.delete("canCreateBlankNodes"));
+    const del = SUBRULE(quadData, void 0);
+    ACTION(() => couldCreateBlankNodes && C.parseMode.add("canCreateBlankNodes"));
     return {
       updateType: "delete",
       delete: del
@@ -12920,12 +12910,12 @@ var deleteData = {
 };
 var deleteWhere = {
   name: "deleteWhere",
-  impl: ({ ACTION, SUBRULE, CONSUME, context }) => () => {
+  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
     CONSUME(deleteClause);
     CONSUME(where);
-    const couldCreateBlankNodes = ACTION(() => context.parseMode.delete(canCreateBlankNodes));
-    const del = SUBRULE(quadPattern);
-    ACTION(() => couldCreateBlankNodes && context.parseMode.add(canCreateBlankNodes));
+    const couldCreateBlankNodes = ACTION(() => C.parseMode.delete("canCreateBlankNodes"));
+    const del = SUBRULE(quadPattern, void 0);
+    ACTION(() => couldCreateBlankNodes && C.parseMode.add("canCreateBlankNodes"));
     return {
       updateType: "deletewhere",
       delete: del
@@ -12937,27 +12927,27 @@ var modify = {
   impl: ({ ACTION, SUBRULE, CONSUME, MANY, SUBRULE1, SUBRULE2, OPTION1, OPTION2, OR }) => () => {
     const graph2 = OPTION1(() => {
       CONSUME(modifyWith);
-      return SUBRULE(iri2);
+      return SUBRULE(iri2, void 0);
     });
     const { insert, delete: del } = OR([
       {
         ALT: () => {
-          const del2 = SUBRULE(deleteClause2);
-          const insert2 = OPTION2(() => SUBRULE1(insertClause2)) ?? [];
+          const del2 = SUBRULE(deleteClause2, void 0);
+          const insert2 = OPTION2(() => SUBRULE1(insertClause2, void 0)) ?? [];
           return { delete: del2, insert: insert2 };
         }
       },
       { ALT: () => {
-        const insert2 = SUBRULE2(insertClause2);
+        const insert2 = SUBRULE2(insertClause2, void 0);
         return { insert: insert2, delete: [] };
       } }
     ]);
     const usingArr = [];
     MANY(() => {
-      usingArr.push(SUBRULE(usingClause2));
+      usingArr.push(SUBRULE(usingClause2, void 0));
     });
     CONSUME(where);
-    const where2 = SUBRULE(groupGraphPattern);
+    const where2 = SUBRULE(groupGraphPattern, void 0);
     return ACTION(() => {
       const def = [];
       const named2 = [];
@@ -12981,11 +12971,11 @@ var modify = {
 };
 var deleteClause2 = {
   name: "deleteClause",
-  impl: ({ ACTION, SUBRULE, CONSUME, context }) => () => {
+  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
     CONSUME(deleteClause);
-    const couldCreateBlankNodes = ACTION(() => context.parseMode.delete(canCreateBlankNodes));
-    const del = SUBRULE(quadPattern);
-    ACTION(() => couldCreateBlankNodes && context.parseMode.add(canCreateBlankNodes));
+    const couldCreateBlankNodes = ACTION(() => C.parseMode.delete("canCreateBlankNodes"));
+    const del = SUBRULE(quadPattern, void 0);
+    ACTION(() => couldCreateBlankNodes && C.parseMode.add("canCreateBlankNodes"));
     return del;
   }
 };
@@ -12993,7 +12983,7 @@ var insertClause2 = {
   name: "insertClause",
   impl: ({ SUBRULE, CONSUME }) => () => {
     CONSUME(insertClause);
-    return SUBRULE(quadPattern);
+    return SUBRULE(quadPattern, void 0);
   }
 };
 var usingClause2 = {
@@ -13002,13 +12992,13 @@ var usingClause2 = {
     CONSUME(usingClause);
     return OR([
       { ALT: () => {
-        const value = SUBRULE1(iri2);
+        const value = SUBRULE1(iri2, void 0);
         return { value, type: "default" };
       } },
       {
         ALT: () => {
           CONSUME(graph_exports.named);
-          const value = SUBRULE2(iri2);
+          const value = SUBRULE2(iri2, void 0);
           return { value, type: "named" };
         }
       }
@@ -13025,7 +13015,7 @@ var graphOrDefault = {
     {
       ALT: () => {
         OPTION(() => CONSUME(graph_exports.graph));
-        const name = SUBRULE(iri2);
+        const name = SUBRULE(iri2, void 0);
         return {
           type: "graph",
           name
@@ -13038,14 +13028,14 @@ var graphRef = {
   name: "graphRef",
   impl: ({ SUBRULE, CONSUME }) => () => {
     CONSUME(graph_exports.graph);
-    return SUBRULE(iri2);
+    return SUBRULE(iri2, void 0);
   }
 };
 var graphRefAll = {
   name: "graphRefAll",
   impl: ({ SUBRULE, CONSUME, OR }) => () => OR([
     { ALT: () => {
-      const name = SUBRULE(graphRef);
+      const name = SUBRULE(graphRef, void 0);
       return { type: "graph", name };
     } },
     { ALT: () => {
@@ -13066,18 +13056,18 @@ var quadPattern = {
   name: "quadPattern",
   impl: ({ SUBRULE, CONSUME }) => () => {
     CONSUME(symbols_exports.LCurly);
-    const val = SUBRULE(quads);
+    const val = SUBRULE(quads, void 0);
     CONSUME(symbols_exports.RCurly);
     return val;
   }
 };
 var quadData = {
   name: "quadData",
-  impl: ({ ACTION, SUBRULE, CONSUME, context }) => () => {
+  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
     CONSUME(symbols_exports.LCurly);
-    const couldParseVars = ACTION(() => context.parseMode.delete(canParseVars));
-    const val = SUBRULE(quads);
-    ACTION(() => couldParseVars && context.parseMode.add(canParseVars));
+    const couldParseVars = ACTION(() => C.parseMode.delete("canParseVars"));
+    const val = SUBRULE(quads, void 0);
+    ACTION(() => couldParseVars && C.parseMode.add("canParseVars"));
     CONSUME(symbols_exports.RCurly);
     return val;
   }
@@ -13087,17 +13077,17 @@ var quads = {
   impl: ({ SUBRULE, CONSUME, MANY, SUBRULE1, SUBRULE2, OPTION1, OPTION2, OPTION3 }) => () => {
     const quads2 = [];
     OPTION1(() => {
-      const triples = SUBRULE1(triplesTemplate);
+      const triples = SUBRULE1(triplesTemplate, void 0);
       quads2.push({
         type: "bgp",
         triples
       });
     });
     MANY(() => {
-      quads2.push(SUBRULE(quadsNotTriples));
+      quads2.push(SUBRULE(quadsNotTriples, void 0));
       OPTION2(() => CONSUME(symbols_exports.dot));
       OPTION3(() => {
-        const triples = SUBRULE2(triplesTemplate);
+        const triples = SUBRULE2(triplesTemplate, void 0);
         quads2.push({
           type: "bgp",
           triples
@@ -13111,9 +13101,9 @@ var quadsNotTriples = {
   name: "quadsNotTriples",
   impl: ({ SUBRULE, CONSUME, OPTION }) => () => {
     CONSUME(graph_exports.graph);
-    const name = SUBRULE(varOrIri);
+    const name = SUBRULE(varOrIri, void 0);
     CONSUME(symbols_exports.LCurly);
-    const triples = OPTION(() => SUBRULE(triplesTemplate)) ?? [];
+    const triples = OPTION(() => SUBRULE(triplesTemplate, void 0)) ?? [];
     CONSUME(symbols_exports.RCurly);
     return {
       type: "graph",
@@ -13180,11 +13170,11 @@ function reifiedTripleBlockImpl(name, allowPath) {
   return {
     name,
     impl: ({ ACTION, SUBRULE }) => () => {
-      const triple = SUBRULE(reifiedTriple);
-      const properties = SUBRULE(allowPath ? grammar_exports.propertyListPath : grammar_exports.propertyList);
+      const triple = SUBRULE(reifiedTriple, void 0);
+      const properties = SUBRULE(allowPath ? grammar_exports.propertyListPath : grammar_exports.propertyList, { subject: triple.node });
       return ACTION(() => [
         ...triple.triples,
-        ...properties.map((partial) => partial({ subject: triple.node }))
+        ...properties
       ]);
     }
   };
@@ -13193,38 +13183,38 @@ var reifiedTripleBlock = reifiedTripleBlockImpl("reifiedTripleBlock", false);
 var reifiedTripleBlockPath = reifiedTripleBlockImpl("reifiedTripleBlockPath", true);
 var dataBlockValue2 = {
   name: "dataBlockValue",
-  impl: ($) => () => $.OR2([
-    { ALT: () => grammar_exports.dataBlockValue.impl($)() },
-    { ALT: () => $.SUBRULE(tripleTermData) }
+  impl: ($) => (C) => $.OR2([
+    { ALT: () => grammar_exports.dataBlockValue.impl($)(C, void 0) },
+    { ALT: () => $.SUBRULE(tripleTermData, void 0) }
   ])
 };
 var reifier = {
   name: "reifier",
-  impl: ({ ACTION, CONSUME, SUBRULE, OPTION, context }) => () => {
+  impl: ({ ACTION, CONSUME, SUBRULE, OPTION }) => (C) => {
     CONSUME(tilde);
-    const reifier2 = OPTION(() => SUBRULE(varOrReifierId));
+    const reifier2 = OPTION(() => SUBRULE(varOrReifierId, void 0));
     return ACTION(() => {
-      if (reifier2 === void 0 && !context.parseMode.has(grammar_exports.canCreateBlankNodes)) {
+      if (reifier2 === void 0 && !C.parseMode.has("canCreateBlankNodes")) {
         throw new Error("Cannot create blanknodes in current parse mode");
       }
-      return reifier2 ?? context.dataFactory.blankNode();
+      return reifier2 ?? C.dataFactory.blankNode();
     });
   }
 };
 var varOrReifierId = {
   name: "varOrReifierId",
   impl: ({ SUBRULE, OR }) => () => OR([
-    { ALT: () => SUBRULE(grammar_exports.var_) },
-    { ALT: () => SUBRULE(grammar_exports.iri) },
-    { ALT: () => SUBRULE(grammar_exports.blankNode) }
+    { ALT: () => SUBRULE(grammar_exports.var_, void 0) },
+    { ALT: () => SUBRULE(grammar_exports.iri, void 0) },
+    { ALT: () => SUBRULE(grammar_exports.blankNode, void 0) }
   ])
 };
 function triplesSameSubjectImpl2(name, allowPaths) {
   return {
     name,
-    impl: ($) => () => $.OR2([
-      { ALT: () => allowPaths ? grammar_exports.triplesSameSubjectPath.impl($)() : grammar_exports.triplesSameSubject.impl($)() },
-      { ALT: () => $.SUBRULE(allowPaths ? reifiedTripleBlockPath : reifiedTripleBlock) }
+    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) }
     ])
   };
 }
@@ -13233,32 +13223,31 @@ var triplesSameSubjectPath2 = triplesSameSubjectImpl2("triplesSameSubjectPath",
 function objectImpl2(name, allowPaths) {
   return {
     name,
-    impl: ({ ACTION, SUBRULE, context }) => () => {
-      const objectVal = SUBRULE(allowPaths ? graphNodePath2 : graphNode2);
-      const annotationVal = SUBRULE(allowPaths ? annotationPath : annotation);
+    impl: ({ ACTION, SUBRULE }) => (C, arg) => {
+      const objectVal = SUBRULE(allowPaths ? graphNodePath2 : graphNode2, void 0);
+      const annotationVal = SUBRULE(allowPaths ? annotationPath : annotation, void 0);
       return ACTION(() => {
+        const { subject, predicate } = arg;
+        if ("type" in predicate && predicate.type === "path" && annotationVal.length > 0) {
+          throw new Error("Note 17 violation");
+        }
         const result = [
           // You parse the object
-          ({ subject, predicate }) => ({ subject, predicate, object: objectVal.node }),
+          { subject, predicate, object: objectVal.node },
           // You might get some additional triples from parsing the object (like when it's a collection)
-          ...objectVal.triples.map((triple) => () => triple)
+          ...objectVal.triples
         ];
         for (const annotation2 of annotationVal) {
-          result.push(({ subject, predicate }) => {
-            if ("type" in predicate && predicate.type === "path") {
-              throw new Error("Note 17 violation");
-            }
-            return context.dataFactory.quad(
-              annotation2.node,
-              context.dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#reifies" /* REIFIES */),
-              context.dataFactory.quad(
-                subject,
-                predicate,
-                objectVal.node
-              )
-            );
-          });
-          result.push(...annotation2.triples.map((triple) => () => triple));
+          result.push(C.dataFactory.quad(
+            annotation2.node,
+            C.dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#reifies" /* REIFIES */),
+            C.dataFactory.quad(
+              subject,
+              predicate,
+              objectVal.node
+            )
+          ));
+          result.push(...annotation2.triples);
         }
         return result;
       });
@@ -13270,7 +13259,7 @@ var objectPath2 = objectImpl2("objectPath", true);
 function annotationImpl(name, allowPaths) {
   return {
     name,
-    impl: ({ ACTION, SUBRULE, OR, MANY, context }) => () => {
+    impl: ({ ACTION, SUBRULE, OR, MANY }) => (C) => {
       const annotations = [];
       let currentReifier;
       function flush() {
@@ -13282,20 +13271,26 @@ function annotationImpl(name, allowPaths) {
       MANY(() => {
         OR([
           { ALT: () => {
-            const node = SUBRULE(reifier);
+            const node = SUBRULE(reifier, void 0);
             ACTION(() => flush());
             currentReifier = node;
           } },
           { ALT: () => {
-            const block = SUBRULE(allowPaths ? annotationBlockPath : annotationBlock);
+            let node;
+            const block = SUBRULE(
+              allowPaths ? annotationBlockPath : annotationBlock,
+              { subject: ACTION(() => {
+                if (currentReifier === void 0 && !C.parseMode.has("canCreateBlankNodes")) {
+                  throw new Error("Cannot create blanknodes in current parse mode");
+                }
+                node = currentReifier ?? C.dataFactory.blankNode();
+                return node;
+              }) }
+            );
             ACTION(() => {
-              if (currentReifier === void 0 && !context.parseMode.has(grammar_exports.canCreateBlankNodes)) {
-                throw new Error("Cannot create blanknodes in current parse mode");
-              }
-              const node = currentReifier ?? context.dataFactory.blankNode();
               annotations.push({
                 node,
-                triples: block.map((partial) => partial({ subject: node }))
+                triples: block
               });
               currentReifier = void 0;
             });
@@ -13314,9 +13309,9 @@ var annotation = annotationImpl("annotation", false);
 function annotationBlockImpl(name, allowPaths) {
   return {
     name,
-    impl: ({ SUBRULE, CONSUME }) => () => {
+    impl: ({ ACTION, SUBRULE, CONSUME }) => (_, arg) => {
       CONSUME(annotationOpen);
-      const res = SUBRULE(allowPaths ? grammar_exports.propertyListPathNotEmpty : grammar_exports.propertyListNotEmpty);
+      const res = SUBRULE(allowPaths ? grammar_exports.propertyListPathNotEmpty : grammar_exports.propertyListNotEmpty, { subject: ACTION(() => arg.subject) });
       CONSUME(annotationClose);
       return res;
     }
@@ -13326,54 +13321,54 @@ var annotationBlockPath = annotationBlockImpl("annotationBlockPath", true);
 var annotationBlock = annotationBlockImpl("annotationBlock", false);
 var graphNode2 = {
   name: "graphNode",
-  impl: ($) => () => $.OR2([
-    { ALT: () => grammar_exports.graphNode.impl($)() },
-    { ALT: () => $.SUBRULE(reifiedTriple) }
+  impl: ($) => (C) => $.OR2([
+    { ALT: () => grammar_exports.graphNode.impl($)(C, void 0) },
+    { ALT: () => $.SUBRULE(reifiedTriple, void 0) }
   ])
 };
 var graphNodePath2 = {
   name: "graphNodePath",
-  impl: ($) => () => $.OR2([
-    { ALT: () => grammar_exports.graphNodePath.impl($)() },
-    { ALT: () => $.SUBRULE(reifiedTriple) }
+  impl: ($) => (C) => $.OR2([
+    { ALT: () => grammar_exports.graphNodePath.impl($)(C, void 0) },
+    { ALT: () => $.SUBRULE(reifiedTriple, void 0) }
   ])
 };
 var varOrTerm2 = {
   name: "varOrTerm",
-  impl: ({ SUBRULE, OR, CONSUME, context }) => () => OR([
-    { 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) },
+  impl: ({ ACTION, SUBRULE, OR, CONSUME }) => (C) => OR([
+    { 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: () => {
       CONSUME(lexer_exports.terminals.nil);
-      return context.dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#nil" /* NIL */);
+      return ACTION(() => C.dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#nil" /* NIL */));
     } },
-    { ALT: () => SUBRULE(tripleTerm) }
+    { ALT: () => SUBRULE(tripleTerm, void 0) }
   ])
 };
 var reifiedTriple = {
   name: "reifiedTriple",
-  impl: ({ ACTION, CONSUME, SUBRULE, OPTION, context }) => () => {
+  impl: ({ ACTION, CONSUME, SUBRULE, OPTION }) => (C) => {
     CONSUME(reificationOpen);
-    const subject = SUBRULE(reifiedTripleSubject);
-    const predicate = SUBRULE(grammar_exports.verb);
-    const object3 = SUBRULE(reifiedTripleObject);
-    const reifierVal = OPTION(() => SUBRULE(reifier));
+    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));
     CONSUME(reificationClose);
     return ACTION(() => {
-      if (reifierVal === void 0 && !context.parseMode.has(grammar_exports.canCreateBlankNodes)) {
+      if (reifierVal === void 0 && !C.parseMode.has("canCreateBlankNodes")) {
         throw new Error("Cannot create blanknodes in current parse mode");
       }
-      const reifier2 = reifierVal ?? context.dataFactory.blankNode();
-      const tripleTerm2 = context.dataFactory.quad(subject.node, predicate, object3.node);
+      const reifier2 = reifierVal ?? C.dataFactory.blankNode();
+      const tripleTerm2 = C.dataFactory.quad(subject.node, predicate, object3.node);
       return {
         node: reifier2,
         triples: [
           ...subject.triples,
-          context.dataFactory.quad(reifier2, context.dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#reifies" /* REIFIES */), tripleTerm2),
+          C.dataFactory.quad(reifier2, C.dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#reifies" /* REIFIES */), tripleTerm2),
           ...object3.triples
         ]
       };
@@ -13383,117 +13378,117 @@ var reifiedTriple = {
 var reifiedTripleSubject = {
   name: "reifiedTripleSubject",
   impl: ({ OR, SUBRULE }) => () => OR([
-    { ALT: () => ({ node: SUBRULE(grammar_exports.var_), triples: [] }) },
-    { ALT: () => ({ node: SUBRULE(grammar_exports.iri), triples: [] }) },
-    { ALT: () => ({ node: SUBRULE(rdfLiteral2), triples: [] }) },
-    { ALT: () => ({ node: SUBRULE(grammar_exports.numericLiteral), triples: [] }) },
-    { ALT: () => ({ node: SUBRULE(grammar_exports.booleanLiteral), triples: [] }) },
-    { ALT: () => ({ node: SUBRULE(grammar_exports.blankNode), triples: [] }) },
-    { ALT: () => SUBRULE(reifiedTriple) }
+    { ALT: () => ({ node: SUBRULE(grammar_exports.var_, void 0), triples: [] }) },
+    { ALT: () => ({ node: SUBRULE(grammar_exports.iri, void 0), triples: [] }) },
+    { ALT: () => ({ node: SUBRULE(rdfLiteral2, void 0), triples: [] }) },
+    { ALT: () => ({ node: SUBRULE(grammar_exports.numericLiteral, void 0), triples: [] }) },
+    { ALT: () => ({ node: SUBRULE(grammar_exports.booleanLiteral, void 0), triples: [] }) },
+    { ALT: () => ({ node: SUBRULE(grammar_exports.blankNode, void 0), triples: [] }) },
+    { ALT: () => SUBRULE(reifiedTriple, void 0) }
   ])
 };
 var reifiedTripleObject = {
   name: "reifiedTripleObject",
-  impl: ($) => () => $.OR2([
-    { ALT: () => reifiedTripleSubject.impl($)() },
-    { ALT: () => ({ node: $.SUBRULE(tripleTerm), triples: [] }) }
+  impl: ($) => (C) => $.OR2([
+    { ALT: () => reifiedTripleSubject.impl($)(C, void 0) },
+    { ALT: () => ({ node: $.SUBRULE(tripleTerm, void 0), triples: [] }) }
   ])
 };
 var tripleTerm = {
   name: "tripleTerm",
-  impl: ({ CONSUME, SUBRULE, context }) => () => {
+  impl: ({ ACTION, CONSUME, SUBRULE }) => (C) => {
     CONSUME(tripleTermOpen);
-    const subject = SUBRULE(tripleTermSubject);
-    const predicate = SUBRULE(grammar_exports.verb);
-    const object3 = SUBRULE(tripleTermObject);
+    const subject = SUBRULE(tripleTermSubject, void 0);
+    const predicate = SUBRULE(grammar_exports.verb, void 0);
+    const object3 = SUBRULE(tripleTermObject, void 0);
     CONSUME(tripleTermClose);
-    return context.dataFactory.quad(subject, predicate, object3);
+    return ACTION(() => C.dataFactory.quad(subject, predicate, object3));
   }
 };
 var tripleTermSubject = {
   name: "tripleTermSubject",
   impl: ({ SUBRULE, OR }) => () => OR([
-    { 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(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) }
   ])
 };
 var tripleTermObject = {
   name: "tripleTermObject",
-  impl: ($) => () => $.OR2([
-    { ALT: () => tripleTermSubject.impl($)() },
-    { ALT: () => $.SUBRULE(tripleTerm) }
+  impl: ($) => (C) => $.OR2([
+    { ALT: () => tripleTermSubject.impl($)(C, void 0) },
+    { ALT: () => $.SUBRULE(tripleTerm, void 0) }
   ])
 };
 var tripleTermData = {
   name: "tripleTermData",
-  impl: ({ ACTION, CONSUME, OR, SUBRULE, context }) => () => {
+  impl: ({ ACTION, CONSUME, OR, SUBRULE }) => (C) => {
     CONSUME(tripleTermOpen);
-    const subject = SUBRULE(tripleTermDataSubject);
+    const subject = SUBRULE(tripleTermDataSubject, void 0);
     const predicate = OR([
-      { ALT: () => SUBRULE(grammar_exports.iri) },
+      { ALT: () => SUBRULE(grammar_exports.iri, void 0) },
       { ALT: () => {
         CONSUME(lexer_exports.a);
-        return ACTION(() => context.dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#type" /* TYPE */));
+        return ACTION(() => C.dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#type" /* TYPE */));
       } }
     ]);
-    const object3 = SUBRULE(tripleTermDataObject);
+    const object3 = SUBRULE(tripleTermDataObject, void 0);
     CONSUME(tripleTermClose);
-    return ACTION(() => context.dataFactory.quad(subject, predicate, object3));
+    return ACTION(() => C.dataFactory.quad(subject, predicate, object3));
   }
 };
 var tripleTermDataSubject = {
   name: "tripleTermDataSubject",
   impl: ({ OR, SUBRULE }) => () => OR([
-    { ALT: () => SUBRULE(grammar_exports.iri) },
-    { ALT: () => SUBRULE(rdfLiteral2) },
-    { ALT: () => SUBRULE(grammar_exports.numericLiteral) },
-    { ALT: () => SUBRULE(grammar_exports.booleanLiteral) }
+    { 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) }
   ])
 };
 var tripleTermDataObject = {
   name: "tripleTermDataObject",
-  impl: ($) => () => $.OR2([
-    { ALT: () => tripleTermDataSubject.impl($)() },
-    { ALT: () => $.SUBRULE(tripleTermData) }
+  impl: ($) => (C) => $.OR2([
+    { ALT: () => tripleTermDataSubject.impl($)(C, void 0) },
+    { ALT: () => $.SUBRULE(tripleTermData, void 0) }
   ])
 };
 var primaryExpression2 = {
   name: "primaryExpression",
-  impl: ($) => () => $.OR2([
-    { ALT: () => grammar_exports.primaryExpression.impl($)() },
-    { ALT: () => $.SUBRULE(exprTripleTerm) }
+  impl: ($) => (C) => $.OR2([
+    { ALT: () => grammar_exports.primaryExpression.impl($)(C, void 0) },
+    { ALT: () => $.SUBRULE(exprTripleTerm, void 0) }
   ])
 };
 var exprTripleTerm = {
   name: "exprTripleTerm",
-  impl: ({ ACTION, CONSUME, SUBRULE, context }) => () => {
+  impl: ({ ACTION, CONSUME, SUBRULE }) => (C) => {
     CONSUME(tripleTermOpen);
-    const subject = SUBRULE(exprTripleTermSubject);
-    const predicate = SUBRULE(grammar_exports.verb);
-    const object3 = SUBRULE(exprTripleTermObject);
+    const subject = SUBRULE(exprTripleTermSubject, void 0);
+    const predicate = SUBRULE(grammar_exports.verb, void 0);
+    const object3 = SUBRULE(exprTripleTermObject, void 0);
     CONSUME(tripleTermClose);
-    return ACTION(() => context.dataFactory.quad(subject, predicate, object3));
+    return ACTION(() => C.dataFactory.quad(subject, predicate, object3));
   }
 };
 var exprTripleTermSubject = {
   name: "exprTripleTermSubject",
   impl: ({ OR, SUBRULE }) => () => OR([
-    { ALT: () => SUBRULE(grammar_exports.iri) },
-    { ALT: () => SUBRULE(rdfLiteral2) },
-    { ALT: () => SUBRULE(grammar_exports.numericLiteral) },
-    { ALT: () => SUBRULE(grammar_exports.booleanLiteral) },
-    { ALT: () => SUBRULE(grammar_exports.var_) }
+    { 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.var_, void 0) }
   ])
 };
 var exprTripleTermObject = {
   name: "exprTripleTermObject",
-  impl: ($) => () => $.OR2([
-    { ALT: () => exprTripleTermSubject.impl($)() },
-    { ALT: () => $.SUBRULE(exprTripleTerm) }
+  impl: ($) => (C) => $.OR2([
+    { ALT: () => exprTripleTermSubject.impl($)(C, void 0) },
+    { ALT: () => $.SUBRULE(exprTripleTerm, void 0) }
   ])
 };
 var builtinLangDir2 = funcExpr1(builtinLangDir);
@@ -13507,17 +13502,17 @@ var builtinPredicate = funcExpr1(builtinPREDICATE);
 var builtinObject = funcExpr1(builtinOBJECT);
 var builtInCall2 = {
   name: "builtInCall",
-  impl: ($) => () => $.OR2([
-    { ALT: () => grammar_exports.builtInCall.impl($)() },
-    { ALT: () => $.SUBRULE(builtinLangDir2) },
-    { ALT: () => $.SUBRULE(builtinLangStrDir) },
-    { ALT: () => $.SUBRULE(builtinHasLang2) },
-    { ALT: () => $.SUBRULE(builtinHasLangDir2) },
-    { ALT: () => $.SUBRULE(builtinIsTriple) },
-    { ALT: () => $.SUBRULE(builtinTriple) },
-    { ALT: () => $.SUBRULE(builtinSubject) },
-    { ALT: () => $.SUBRULE(builtinPredicate) },
-    { ALT: () => $.SUBRULE(builtinObject) }
+  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) }
   ])
 };
 function isLangDir(dir) {
@@ -13525,8 +13520,8 @@ function isLangDir(dir) {
 }
 var rdfLiteral2 = {
   name: "rdfLiteral",
-  impl: ({ ACTION, SUBRULE, OPTION, CONSUME, OR, context }) => () => {
-    const value = SUBRULE(grammar_exports.string);
+  impl: ({ ACTION, SUBRULE, OPTION, CONSUME, OR }) => (C) => {
+    const value = SUBRULE(grammar_exports.string, void 0);
     const langOrDataType = OPTION(() => OR([
       { ALT: () => {
         const langTag2 = CONSUME(LANG_DIR).image.slice(1);
@@ -13547,10 +13542,10 @@ var rdfLiteral2 = {
       } },
       { ALT: () => {
         CONSUME(lexer_exports.symbols.hathat);
-        return SUBRULE(grammar_exports.iri);
+        return SUBRULE(grammar_exports.iri, void 0);
       } }
     ]));
-    return context.dataFactory.literal(value, langOrDataType);
+    return ACTION(() => C.dataFactory.literal(value, langOrDataType));
   }
 };
 /*! Bundled license information: