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

package/lib/grammar.d.ts

@@ -4,137 +4,138 @@
  * Rules in this module redefine the return type of core grammar rules.
  * It is therefore essential that the parser retypes the rules from the core grammar.
  */
-import type { RuleDefReturn, RuleDef } from '@traqula/core';
+import type { RuleDefReturn } from '@traqula/core';
+import { SparqlRuleDef } from '@traqula/rules-sparql-1-1';
 import { gram as S11 } from '@traqula/rules-sparql-1-1';
 import type * as T11 from '@traqula/rules-sparql-1-1';
 import type { BaseQuadTerm, Expression, IGraphNode, Term, Triple } from './sparql12Types';
 /**
  * [[56]](https://www.w3.org/TR/sparql12-query/#rReifiedTripleBlock) Used by triplesSameSubject
  */
-export declare const reifiedTripleBlock: RuleDef<"reifiedTripleBlock", Triple[]>;
+export declare const reifiedTripleBlock: SparqlRuleDef<"reifiedTripleBlock", Triple[]>;
 /**
  * [[57]](https://www.w3.org/TR/sparql12-query/#rReifiedTripleBlockPath) Used by TriplesSameSubjectPath
  */
-export declare const reifiedTripleBlockPath: RuleDef<"reifiedTripleBlockPath", Triple[]>;
+export declare const reifiedTripleBlockPath: SparqlRuleDef<"reifiedTripleBlockPath", Triple[]>;
 /**
  * OVERRIDING RULE: {@link S11.dataBlockValue}.
  * [[67]](https://www.w3.org/TR/sparql12-query/#rDataBlockValue)
  */
-export declare const dataBlockValue: RuleDef<'dataBlockValue', RuleDefReturn<typeof S11.dataBlockValue> | BaseQuadTerm>;
+export declare const dataBlockValue: SparqlRuleDef<'dataBlockValue', RuleDefReturn<typeof S11.dataBlockValue> | BaseQuadTerm>;
 /**
  * [[68]](https://www.w3.org/TR/sparql12-query/#rReifier)
  */
-export declare const reifier: RuleDef<'reifier', T11.VariableTerm | T11.IriTerm | T11.BlankTerm>;
+export declare const reifier: SparqlRuleDef<'reifier', T11.VariableTerm | T11.IriTerm | T11.BlankTerm>;
 /**
  * [[68]](https://www.w3.org/TR/sparql12-query/#rVarOrReifierId)
  */
-export declare const varOrReifierId: RuleDef<'varOrReifierId', T11.VariableTerm | T11.IriTerm | T11.BlankTerm>;
+export declare const varOrReifierId: SparqlRuleDef<'varOrReifierId', T11.VariableTerm | T11.IriTerm | T11.BlankTerm>;
 /**
  * OVERRIDING RULE {@link S11.triplesSameSubject}
  * [[79]](https://www.w3.org/TR/sparql12-query/#rTriplesSameSubject)
  */
-export declare const triplesSameSubject: RuleDef<"triplesSameSubject", Triple[]>;
+export declare const triplesSameSubject: SparqlRuleDef<"triplesSameSubject", Triple[]>;
 /**
  * OVERRIDING RULE {@link S11.triplesSameSubjectPath}
  * [[85]](https://www.w3.org/TR/sparql12-query/#rTriplesSameSubjectPath)
  */
-export declare const triplesSameSubjectPath: RuleDef<"triplesSameSubjectPath", Triple[]>;
+export declare const triplesSameSubjectPath: SparqlRuleDef<"triplesSameSubjectPath", Triple[]>;
 /**
  * OVERRIDING RULE: {@link S11.object}.
  * [[84]](https://www.w3.org/TR/sparql12-query/#rObject) Used by ObjectList
  */
-export declare const object: RuleDef<"object", Triple[], [Term, import("@rdfjs/types").Variable | T11.IriTerm<string> | T11.PropertyPath]>;
+export declare const object: SparqlRuleDef<"object", Triple[], Pick<Triple, "subject" | "predicate">>;
 /**
  * OVERRIDING RULE: {@link S11.objectPath}.
  * [[91]](https://www.w3.org/TR/sparql12-query/#rTriplesSameSubjectPath) Used by ObjectListPath
  */
-export declare const objectPath: RuleDef<"objectPath", Triple[], [Term, import("@rdfjs/types").Variable | T11.IriTerm<string> | T11.PropertyPath]>;
+export declare const objectPath: SparqlRuleDef<"objectPath", Triple[], Pick<Triple, "subject" | "predicate">>;
 /**
  * [[107]](https://www.w3.org/TR/sparql12-query/#rAnnotationPath)
  */
-export declare const annotationPath: RuleDef<"annotationPath", IGraphNode[]>;
+export declare const annotationPath: SparqlRuleDef<"annotationPath", IGraphNode[]>;
 /**
  * [[109]](https://www.w3.org/TR/sparql12-query/#rAnnotation)
  */
-export declare const annotation: RuleDef<"annotation", IGraphNode[]>;
+export declare const annotation: SparqlRuleDef<"annotation", IGraphNode[]>;
 /**
  * [[108]](https://www.w3.org/TR/sparql12-query/#rAnnotationBlockPath)
  */
-export declare const annotationBlockPath: RuleDef<"annotationBlockPath", Triple[], [Term]>;
+export declare const annotationBlockPath: SparqlRuleDef<"annotationBlockPath", Triple[], Pick<Triple, "subject">>;
 /**
  * [[110]](https://www.w3.org/TR/sparql12-query/#rAnnotationBlock)
  */
-export declare const annotationBlock: RuleDef<"annotationBlock", Triple[], [Term]>;
+export declare const annotationBlock: SparqlRuleDef<"annotationBlock", Triple[], Pick<Triple, "subject">>;
 /**
  * OVERRIDING RULE: {@link S11.graphNode}.
  * [[111]](https://www.w3.org/TR/sparql12-query/#rGraphNode)
  */
-export declare const graphNode: RuleDef<'graphNode', IGraphNode>;
+export declare const graphNode: SparqlRuleDef<'graphNode', IGraphNode>;
 /**
  * OVERRIDING RULE: {@link S11.graphNodePath}.
  * [[112]](https://www.w3.org/TR/sparql12-query/#rGraphNodePath)
  */
-export declare const graphNodePath: RuleDef<'graphNodePath', IGraphNode>;
+export declare const graphNodePath: SparqlRuleDef<'graphNodePath', IGraphNode>;
 /**
  * OVERRIDING RULE: {@link S11.varOrTerm}.
  * [[113]](https://www.w3.org/TR/sparql12-query/#rVarOrTerm)
  */
-export declare const varOrTerm: RuleDef<'varOrTerm', Term>;
+export declare const varOrTerm: SparqlRuleDef<'varOrTerm', Term>;
 /**
  * [[114]](https://www.w3.org/TR/sparql12-query/#rReifiedTriple)
  */
-export declare const reifiedTriple: RuleDef<'reifiedTriple', IGraphNode & {
+export declare const reifiedTriple: SparqlRuleDef<'reifiedTriple', IGraphNode & {
     node: T11.BlankTerm | T11.VariableTerm | T11.IriTerm;
 }>;
 /**
  * [[115]](https://www.w3.org/TR/sparql12-query/#rReifiedTripleSubject)
  */
-export declare const reifiedTripleSubject: RuleDef<'reifiedTripleSubject', IGraphNode>;
+export declare const reifiedTripleSubject: SparqlRuleDef<'reifiedTripleSubject', IGraphNode>;
 /**
  * [[116]](https://www.w3.org/TR/sparql12-query/#rReifiedTripleObject)
  */
-export declare const reifiedTripleObject: RuleDef<'reifiedTripleObject', RuleDefReturn<typeof reifiedTripleSubject>>;
+export declare const reifiedTripleObject: SparqlRuleDef<'reifiedTripleObject', RuleDefReturn<typeof reifiedTripleSubject>>;
 /**
  * [[117]](https://www.w3.org/TR/sparql12-query/#rTripleTerm)
  */
-export declare const tripleTerm: RuleDef<'tripleTerm', BaseQuadTerm>;
+export declare const tripleTerm: SparqlRuleDef<'tripleTerm', BaseQuadTerm>;
 /**
  * [[118]](https://www.w3.org/TR/sparql12-query/#rTripleTermSubject)
  */
-export declare const tripleTermSubject: RuleDef<'tripleTermSubject', T11.VariableTerm | T11.IriTerm | T11.LiteralTerm | T11.BlankTerm>;
+export declare const tripleTermSubject: SparqlRuleDef<'tripleTermSubject', T11.VariableTerm | T11.IriTerm | T11.LiteralTerm | T11.BlankTerm>;
 /**
  * [[119]](https://www.w3.org/TR/sparql12-query/#rTripleTermObject)
  */
-export declare const tripleTermObject: RuleDef<'tripleTermObject', RuleDefReturn<typeof tripleTermSubject> | BaseQuadTerm>;
+export declare const tripleTermObject: SparqlRuleDef<'tripleTermObject', RuleDefReturn<typeof tripleTermSubject> | BaseQuadTerm>;
 /**
  * [[120]](https://www.w3.org/TR/sparql12-query/#rTripleTermData)
  */
-export declare const tripleTermData: RuleDef<'tripleTermData', BaseQuadTerm>;
+export declare const tripleTermData: SparqlRuleDef<'tripleTermData', BaseQuadTerm>;
 /**
  * [[121]](https://www.w3.org/TR/sparql12-query/#rTripleTermDataSubject)
  */
-export declare const tripleTermDataSubject: RuleDef<'tripleTermDataSubject', T11.IriTerm | T11.LiteralTerm>;
+export declare const tripleTermDataSubject: SparqlRuleDef<'tripleTermDataSubject', T11.IriTerm | T11.LiteralTerm>;
 /**
  * [[122]](https://www.w3.org/TR/sparql12-query/#rTripleTermDataObject)
  */
-export declare const tripleTermDataObject: RuleDef<'tripleTermDataObject', RuleDefReturn<typeof tripleTermDataSubject> | BaseQuadTerm>;
+export declare const tripleTermDataObject: SparqlRuleDef<'tripleTermDataObject', RuleDefReturn<typeof tripleTermDataSubject> | BaseQuadTerm>;
 /**
  * OVERRIDING RULE: {@link S11.primaryExpression}.
  * [[134]](https://www.w3.org/TR/sparql12-query/#rPrimaryExpression)
  */
-export declare const primaryExpression: RuleDef<'primaryExpression', Expression>;
+export declare const primaryExpression: SparqlRuleDef<'primaryExpression', Expression>;
 /**
  * [[135]](https://www.w3.org/TR/sparql12-query/#rExprTripleTerm)
  */
-export declare const exprTripleTerm: RuleDef<'exprTripleTerm', BaseQuadTerm>;
+export declare const exprTripleTerm: SparqlRuleDef<'exprTripleTerm', BaseQuadTerm>;
 /**
  * [[136]](https://www.w3.org/TR/sparql12-query/#rExprTripleTermSubject)
  */
-export declare const exprTripleTermSubject: RuleDef<'exprTripleTermSubject', T11.IriTerm | T11.VariableTerm | T11.LiteralTerm>;
+export declare const exprTripleTermSubject: SparqlRuleDef<'exprTripleTermSubject', T11.IriTerm | T11.VariableTerm | T11.LiteralTerm>;
 /**
  * [[137]](https://www.w3.org/TR/sparql12-query/#rExprTripleTermObject)
  */
-export declare const exprTripleTermObject: RuleDef<'exprTripleTermObject', RuleDefReturn<typeof exprTripleTermSubject> | BaseQuadTerm>;
+export declare const exprTripleTermObject: SparqlRuleDef<'exprTripleTermObject', RuleDefReturn<typeof exprTripleTermSubject> | BaseQuadTerm>;
 export declare const builtinLangDir: S11.RuleDefExpressionFunctionX<"builtInLangdir", [T11.Expression]>;
 export declare const builtinLangStrDir: S11.RuleDefExpressionFunctionX<"builtInStrLangdir", [T11.Expression, T11.Expression, T11.Expression]>;
 export declare const builtinHasLang: S11.RuleDefExpressionFunctionX<"builtInHasLang", [T11.Expression]>;

package/lib/grammar.js

@@ -12,8 +12,8 @@ function reifiedTripleBlockImpl(name, allowPath) {
     return {
         name,
         impl: ({ ACTION, SUBRULE }) => () => {
-            const triple = SUBRULE(reifiedTriple);
-            const properties = SUBRULE(allowPath ? S11.propertyListPath : S11.propertyList, triple.node);
+            const triple = SUBRULE(reifiedTriple, undefined);
+            const properties = SUBRULE(allowPath ? S11.propertyListPath : S11.propertyList, { subject: triple.node });
             return ACTION(() => [
                 ...triple.triples,
                 ...properties,
@@ -35,9 +35,9 @@ export const reifiedTripleBlockPath = reifiedTripleBlockImpl('reifiedTripleBlock
  */
 export const dataBlockValue = {
     name: 'dataBlockValue',
-    impl: $ => () => $.OR2([
-        { ALT: () => S11.dataBlockValue.impl($)() },
-        { ALT: () => $.SUBRULE(tripleTermData) },
+    impl: $ => (C) => $.OR2([
+        { ALT: () => S11.dataBlockValue.impl($)(C, undefined) },
+        { ALT: () => $.SUBRULE(tripleTermData, undefined) },
     ]),
 };
 /**
@@ -45,14 +45,14 @@ export const dataBlockValue = {
  */
 export const reifier = {
     name: 'reifier',
-    impl: ({ ACTION, CONSUME, SUBRULE, OPTION, context }) => () => {
+    impl: ({ ACTION, CONSUME, SUBRULE, OPTION }) => (C) => {
         CONSUME(l12.tilde);
-        const reifier = OPTION(() => SUBRULE(varOrReifierId));
+        const reifier = OPTION(() => SUBRULE(varOrReifierId, undefined));
         return ACTION(() => {
-            if (reifier === undefined && !context.parseMode.has(S11.canCreateBlankNodes)) {
+            if (reifier === undefined && !C.parseMode.has('canCreateBlankNodes')) {
                 throw new Error('Cannot create blanknodes in current parse mode');
             }
-            return reifier ?? context.dataFactory.blankNode();
+            return reifier ?? C.dataFactory.blankNode();
         });
     },
 };
@@ -62,17 +62,17 @@ export const reifier = {
 export const varOrReifierId = {
     name: 'varOrReifierId',
     impl: ({ SUBRULE, OR }) => () => OR([
-        { ALT: () => SUBRULE(S11.var_) },
-        { ALT: () => SUBRULE(S11.iri) },
-        { ALT: () => SUBRULE(S11.blankNode) },
+        { ALT: () => SUBRULE(S11.var_, undefined) },
+        { ALT: () => SUBRULE(S11.iri, undefined) },
+        { ALT: () => SUBRULE(S11.blankNode, undefined) },
     ]),
 };
 function triplesSameSubjectImpl(name, allowPaths) {
     return {
         name,
-        impl: $ => () => $.OR2([
-            { ALT: () => allowPaths ? S11.triplesSameSubjectPath.impl($)() : S11.triplesSameSubject.impl($)() },
-            { ALT: () => $.SUBRULE(allowPaths ? reifiedTripleBlockPath : reifiedTripleBlock) },
+        impl: $ => (C) => $.OR2([
+            { ALT: () => allowPaths ? S11.triplesSameSubjectPath.impl($)(C, undefined) : S11.triplesSameSubject.impl($)(C, undefined) },
+            { ALT: () => $.SUBRULE(allowPaths ? reifiedTripleBlockPath : reifiedTripleBlock, undefined) },
         ]),
     };
 }
@@ -89,12 +89,13 @@ export const triplesSameSubjectPath = triplesSameSubjectImpl('triplesSameSubject
 function objectImpl(name, allowPaths) {
     return {
         name,
-        impl: ({ ACTION, SUBRULE, context }) => (subject, predicate) => {
-            const objectVal = SUBRULE(allowPaths ? graphNodePath : graphNode);
-            const annotationVal = SUBRULE(allowPaths ? annotationPath : annotation);
+        impl: ({ ACTION, SUBRULE }) => (C, arg) => {
+            const objectVal = SUBRULE(allowPaths ? graphNodePath : graphNode, undefined);
+            const annotationVal = SUBRULE(allowPaths ? annotationPath : annotation, undefined);
             // This rule knows the annotation. And for each annotation node, we need to make a triple:
             // <annotationNode, reifies, parsedSubjectAndObject>
             return ACTION(() => {
+                const { subject, predicate } = arg;
                 if ('type' in predicate && predicate.type === 'path' && annotationVal.length > 0) {
                     throw new Error('Note 17 violation');
                 }
@@ -105,7 +106,7 @@ function objectImpl(name, allowPaths) {
                     ...objectVal.triples,
                 ];
                 for (const annotation of annotationVal) {
-                    result.push(context.dataFactory.quad(annotation.node, context.dataFactory.namedNode(CommonIRIs.REIFIES), context.dataFactory.quad(subject, predicate, objectVal.node)));
+                    result.push(C.dataFactory.quad(annotation.node, C.dataFactory.namedNode(CommonIRIs.REIFIES), C.dataFactory.quad(subject, predicate, objectVal.node)));
                     result.push(...annotation.triples);
                 }
                 return result;
@@ -126,7 +127,7 @@ export const objectPath = objectImpl('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() {
@@ -138,19 +139,19 @@ function annotationImpl(name, allowPaths) {
             MANY(() => {
                 OR([
                     { ALT: () => {
-                            const node = SUBRULE(reifier);
+                            const node = SUBRULE(reifier, undefined);
                             ACTION(() => flush());
                             currentReifier = node;
                         } },
                     { ALT: () => {
                             let node;
-                            const block = SUBRULE(allowPaths ? annotationBlockPath : annotationBlock, ACTION(() => {
-                                if (currentReifier === undefined && !context.parseMode.has(S11.canCreateBlankNodes)) {
-                                    throw new Error('Cannot create blanknodes in current parse mode');
-                                }
-                                node = currentReifier ?? context.dataFactory.blankNode();
-                                return node;
-                            }));
+                            const block = SUBRULE(allowPaths ? annotationBlockPath : annotationBlock, { subject: ACTION(() => {
+                                    if (currentReifier === undefined && !C.parseMode.has('canCreateBlankNodes')) {
+                                        throw new Error('Cannot create blanknodes in current parse mode');
+                                    }
+                                    node = currentReifier ?? C.dataFactory.blankNode();
+                                    return node;
+                                }) });
                             ACTION(() => {
                                 annotations.push({
                                     node,
@@ -179,9 +180,9 @@ export const annotation = annotationImpl('annotation', false);
 function annotationBlockImpl(name, allowPaths) {
     return {
         name,
-        impl: ({ SUBRULE, CONSUME }) => (subject) => {
+        impl: ({ ACTION, SUBRULE, CONSUME }) => (_, arg) => {
             CONSUME(l12.annotationOpen);
-            const res = SUBRULE(allowPaths ? S11.propertyListPathNotEmpty : S11.propertyListNotEmpty, subject);
+            const res = SUBRULE(allowPaths ? S11.propertyListPathNotEmpty : S11.propertyListNotEmpty, { subject: ACTION(() => arg.subject) });
             CONSUME(l12.annotationClose);
             return res;
         },
@@ -201,9 +202,9 @@ export const annotationBlock = annotationBlockImpl('annotationBlock', false);
  */
 export const graphNode = {
     name: 'graphNode',
-    impl: $ => () => $.OR2([
-        { ALT: () => S11.graphNode.impl($)() },
-        { ALT: () => $.SUBRULE(reifiedTriple) },
+    impl: $ => (C) => $.OR2([
+        { ALT: () => S11.graphNode.impl($)(C, undefined) },
+        { ALT: () => $.SUBRULE(reifiedTriple, undefined) },
     ]),
 };
 /**
@@ -212,9 +213,9 @@ export const graphNode = {
  */
 export const graphNodePath = {
     name: 'graphNodePath',
-    impl: $ => () => $.OR2([
-        { ALT: () => S11.graphNodePath.impl($)() },
-        { ALT: () => $.SUBRULE(reifiedTriple) },
+    impl: $ => (C) => $.OR2([
+        { ALT: () => S11.graphNodePath.impl($)(C, undefined) },
+        { ALT: () => $.SUBRULE(reifiedTriple, undefined) },
     ]),
 };
 /**
@@ -223,18 +224,18 @@ export const graphNodePath = {
  */
 export const varOrTerm = {
     name: 'varOrTerm',
-    impl: ({ SUBRULE, OR, CONSUME, context }) => () => OR([
-        { ALT: () => SUBRULE(S11.var_) },
-        { ALT: () => SUBRULE(S11.iri) },
-        { ALT: () => SUBRULE(rdfLiteral) },
-        { ALT: () => SUBRULE(S11.numericLiteral) },
-        { ALT: () => SUBRULE(S11.booleanLiteral) },
-        { ALT: () => SUBRULE(S11.blankNode) },
+    impl: ({ ACTION, SUBRULE, OR, CONSUME }) => (C) => OR([
+        { ALT: () => SUBRULE(S11.var_, undefined) },
+        { ALT: () => SUBRULE(S11.iri, undefined) },
+        { ALT: () => SUBRULE(rdfLiteral, undefined) },
+        { ALT: () => SUBRULE(S11.numericLiteral, undefined) },
+        { ALT: () => SUBRULE(S11.booleanLiteral, undefined) },
+        { ALT: () => SUBRULE(S11.blankNode, undefined) },
         { ALT: () => {
                 CONSUME(l11.terminals.nil);
-                return context.dataFactory.namedNode(CommonIRIs.NIL);
+                return ACTION(() => C.dataFactory.namedNode(CommonIRIs.NIL));
             } },
-        { ALT: () => SUBRULE(tripleTerm) },
+        { ALT: () => SUBRULE(tripleTerm, undefined) },
     ]),
 };
 /**
@@ -242,24 +243,24 @@ export const varOrTerm = {
  */
 export const reifiedTriple = {
     name: 'reifiedTriple',
-    impl: ({ ACTION, CONSUME, SUBRULE, OPTION, context }) => () => {
+    impl: ({ ACTION, CONSUME, SUBRULE, OPTION }) => (C) => {
         CONSUME(l12.reificationOpen);
-        const subject = SUBRULE(reifiedTripleSubject);
-        const predicate = SUBRULE(S11.verb);
-        const object = SUBRULE(reifiedTripleObject);
-        const reifierVal = OPTION(() => SUBRULE(reifier));
+        const subject = SUBRULE(reifiedTripleSubject, undefined);
+        const predicate = SUBRULE(S11.verb, undefined);
+        const object = SUBRULE(reifiedTripleObject, undefined);
+        const reifierVal = OPTION(() => SUBRULE(reifier, undefined));
         CONSUME(l12.reificationClose);
         return ACTION(() => {
-            if (reifierVal === undefined && !context.parseMode.has(S11.canCreateBlankNodes)) {
+            if (reifierVal === undefined && !C.parseMode.has('canCreateBlankNodes')) {
                 throw new Error('Cannot create blanknodes in current parse mode');
             }
-            const reifier = reifierVal ?? context.dataFactory.blankNode();
-            const tripleTerm = context.dataFactory.quad(subject.node, predicate, object.node);
+            const reifier = reifierVal ?? C.dataFactory.blankNode();
+            const tripleTerm = C.dataFactory.quad(subject.node, predicate, object.node);
             return {
                 node: reifier,
                 triples: [
                     ...subject.triples,
-                    context.dataFactory.quad(reifier, context.dataFactory.namedNode(CommonIRIs.REIFIES), tripleTerm),
+                    C.dataFactory.quad(reifier, C.dataFactory.namedNode(CommonIRIs.REIFIES), tripleTerm),
                     ...object.triples,
                 ],
             };
@@ -272,13 +273,13 @@ export const reifiedTriple = {
 export const reifiedTripleSubject = {
     name: 'reifiedTripleSubject',
     impl: ({ OR, SUBRULE }) => () => OR([
-        { ALT: () => ({ node: SUBRULE(S11.var_), triples: [] }) },
-        { ALT: () => ({ node: SUBRULE(S11.iri), triples: [] }) },
-        { ALT: () => ({ node: SUBRULE(rdfLiteral), triples: [] }) },
-        { ALT: () => ({ node: SUBRULE(S11.numericLiteral), triples: [] }) },
-        { ALT: () => ({ node: SUBRULE(S11.booleanLiteral), triples: [] }) },
-        { ALT: () => ({ node: SUBRULE(S11.blankNode), triples: [] }) },
-        { ALT: () => SUBRULE(reifiedTriple) },
+        { ALT: () => ({ node: SUBRULE(S11.var_, undefined), triples: [] }) },
+        { ALT: () => ({ node: SUBRULE(S11.iri, undefined), triples: [] }) },
+        { ALT: () => ({ node: SUBRULE(rdfLiteral, undefined), triples: [] }) },
+        { ALT: () => ({ node: SUBRULE(S11.numericLiteral, undefined), triples: [] }) },
+        { ALT: () => ({ node: SUBRULE(S11.booleanLiteral, undefined), triples: [] }) },
+        { ALT: () => ({ node: SUBRULE(S11.blankNode, undefined), triples: [] }) },
+        { ALT: () => SUBRULE(reifiedTriple, undefined) },
     ]),
 };
 /**
@@ -286,9 +287,9 @@ export const reifiedTripleSubject = {
  */
 export const reifiedTripleObject = {
     name: 'reifiedTripleObject',
-    impl: $ => () => $.OR2([
-        { ALT: () => reifiedTripleSubject.impl($)() },
-        { ALT: () => ({ node: $.SUBRULE(tripleTerm), triples: [] }) },
+    impl: $ => (C) => $.OR2([
+        { ALT: () => reifiedTripleSubject.impl($)(C, undefined) },
+        { ALT: () => ({ node: $.SUBRULE(tripleTerm, undefined), triples: [] }) },
     ]),
 };
 /**
@@ -296,13 +297,13 @@ export const reifiedTripleObject = {
  */
 export const tripleTerm = {
     name: 'tripleTerm',
-    impl: ({ CONSUME, SUBRULE, context }) => () => {
+    impl: ({ ACTION, CONSUME, SUBRULE }) => (C) => {
         CONSUME(l12.tripleTermOpen);
-        const subject = SUBRULE(tripleTermSubject);
-        const predicate = SUBRULE(S11.verb);
-        const object = SUBRULE(tripleTermObject);
+        const subject = SUBRULE(tripleTermSubject, undefined);
+        const predicate = SUBRULE(S11.verb, undefined);
+        const object = SUBRULE(tripleTermObject, undefined);
         CONSUME(l12.tripleTermClose);
-        return context.dataFactory.quad(subject, predicate, object);
+        return ACTION(() => C.dataFactory.quad(subject, predicate, object));
     },
 };
 /**
@@ -311,12 +312,12 @@ export const tripleTerm = {
 export const tripleTermSubject = {
     name: 'tripleTermSubject',
     impl: ({ SUBRULE, OR }) => () => OR([
-        { ALT: () => SUBRULE(S11.var_) },
-        { ALT: () => SUBRULE(S11.iri) },
-        { ALT: () => SUBRULE(rdfLiteral) },
-        { ALT: () => SUBRULE(S11.numericLiteral) },
-        { ALT: () => SUBRULE(S11.booleanLiteral) },
-        { ALT: () => SUBRULE(S11.blankNode) },
+        { ALT: () => SUBRULE(S11.var_, undefined) },
+        { ALT: () => SUBRULE(S11.iri, undefined) },
+        { ALT: () => SUBRULE(rdfLiteral, undefined) },
+        { ALT: () => SUBRULE(S11.numericLiteral, undefined) },
+        { ALT: () => SUBRULE(S11.booleanLiteral, undefined) },
+        { ALT: () => SUBRULE(S11.blankNode, undefined) },
     ]),
 };
 /**
@@ -324,9 +325,9 @@ export const tripleTermSubject = {
  */
 export const tripleTermObject = {
     name: 'tripleTermObject',
-    impl: $ => () => $.OR2([
-        { ALT: () => tripleTermSubject.impl($)() },
-        { ALT: () => $.SUBRULE(tripleTerm) },
+    impl: $ => (C) => $.OR2([
+        { ALT: () => tripleTermSubject.impl($)(C, undefined) },
+        { ALT: () => $.SUBRULE(tripleTerm, undefined) },
     ]),
 };
 /**
@@ -334,19 +335,19 @@ export const tripleTermObject = {
  */
 export const tripleTermData = {
     name: 'tripleTermData',
-    impl: ({ ACTION, CONSUME, OR, SUBRULE, context }) => () => {
+    impl: ({ ACTION, CONSUME, OR, SUBRULE }) => (C) => {
         CONSUME(l12.tripleTermOpen);
-        const subject = SUBRULE(tripleTermDataSubject);
+        const subject = SUBRULE(tripleTermDataSubject, undefined);
         const predicate = OR([
-            { ALT: () => SUBRULE(S11.iri) },
+            { ALT: () => SUBRULE(S11.iri, undefined) },
             { ALT: () => {
                     CONSUME(l11.a);
-                    return ACTION(() => context.dataFactory.namedNode(CommonIRIs.TYPE));
+                    return ACTION(() => C.dataFactory.namedNode(CommonIRIs.TYPE));
                 } },
         ]);
-        const object = SUBRULE(tripleTermDataObject);
+        const object = SUBRULE(tripleTermDataObject, undefined);
         CONSUME(l12.tripleTermClose);
-        return ACTION(() => context.dataFactory.quad(subject, predicate, object));
+        return ACTION(() => C.dataFactory.quad(subject, predicate, object));
     },
 };
 /**
@@ -355,10 +356,10 @@ export const tripleTermData = {
 export const tripleTermDataSubject = {
     name: 'tripleTermDataSubject',
     impl: ({ OR, SUBRULE }) => () => OR([
-        { ALT: () => SUBRULE(S11.iri) },
-        { ALT: () => SUBRULE(rdfLiteral) },
-        { ALT: () => SUBRULE(S11.numericLiteral) },
-        { ALT: () => SUBRULE(S11.booleanLiteral) },
+        { ALT: () => SUBRULE(S11.iri, undefined) },
+        { ALT: () => SUBRULE(rdfLiteral, undefined) },
+        { ALT: () => SUBRULE(S11.numericLiteral, undefined) },
+        { ALT: () => SUBRULE(S11.booleanLiteral, undefined) },
     ]),
 };
 /**
@@ -366,9 +367,9 @@ export const tripleTermDataSubject = {
  */
 export const tripleTermDataObject = {
     name: 'tripleTermDataObject',
-    impl: $ => () => $.OR2([
-        { ALT: () => tripleTermDataSubject.impl($)() },
-        { ALT: () => $.SUBRULE(tripleTermData) },
+    impl: $ => (C) => $.OR2([
+        { ALT: () => tripleTermDataSubject.impl($)(C, undefined) },
+        { ALT: () => $.SUBRULE(tripleTermData, undefined) },
     ]),
 };
 /**
@@ -377,9 +378,9 @@ export const tripleTermDataObject = {
  */
 export const primaryExpression = {
     name: 'primaryExpression',
-    impl: $ => () => $.OR2([
-        { ALT: () => S11.primaryExpression.impl($)() },
-        { ALT: () => $.SUBRULE(exprTripleTerm) },
+    impl: $ => (C) => $.OR2([
+        { ALT: () => S11.primaryExpression.impl($)(C, undefined) },
+        { ALT: () => $.SUBRULE(exprTripleTerm, undefined) },
     ]),
 };
 /**
@@ -387,13 +388,13 @@ export const primaryExpression = {
  */
 export const exprTripleTerm = {
     name: 'exprTripleTerm',
-    impl: ({ ACTION, CONSUME, SUBRULE, context }) => () => {
+    impl: ({ ACTION, CONSUME, SUBRULE }) => (C) => {
         CONSUME(l12.tripleTermOpen);
-        const subject = SUBRULE(exprTripleTermSubject);
-        const predicate = SUBRULE(S11.verb);
-        const object = SUBRULE(exprTripleTermObject);
+        const subject = SUBRULE(exprTripleTermSubject, undefined);
+        const predicate = SUBRULE(S11.verb, undefined);
+        const object = SUBRULE(exprTripleTermObject, undefined);
         CONSUME(l12.tripleTermClose);
-        return ACTION(() => context.dataFactory.quad(subject, predicate, object));
+        return ACTION(() => C.dataFactory.quad(subject, predicate, object));
     },
 };
 /**
@@ -402,11 +403,11 @@ export const exprTripleTerm = {
 export const exprTripleTermSubject = {
     name: 'exprTripleTermSubject',
     impl: ({ OR, SUBRULE }) => () => OR([
-        { ALT: () => SUBRULE(S11.iri) },
-        { ALT: () => SUBRULE(rdfLiteral) },
-        { ALT: () => SUBRULE(S11.numericLiteral) },
-        { ALT: () => SUBRULE(S11.booleanLiteral) },
-        { ALT: () => SUBRULE(S11.var_) },
+        { ALT: () => SUBRULE(S11.iri, undefined) },
+        { ALT: () => SUBRULE(rdfLiteral, undefined) },
+        { ALT: () => SUBRULE(S11.numericLiteral, undefined) },
+        { ALT: () => SUBRULE(S11.booleanLiteral, undefined) },
+        { ALT: () => SUBRULE(S11.var_, undefined) },
     ]),
 };
 /**
@@ -414,9 +415,9 @@ export const exprTripleTermSubject = {
  */
 export const exprTripleTermObject = {
     name: 'exprTripleTermObject',
-    impl: $ => () => $.OR2([
-        { ALT: () => exprTripleTermSubject.impl($)() },
-        { ALT: () => $.SUBRULE(exprTripleTerm) },
+    impl: $ => (C) => $.OR2([
+        { ALT: () => exprTripleTermSubject.impl($)(C, undefined) },
+        { ALT: () => $.SUBRULE(exprTripleTerm, undefined) },
     ]),
 };
 export const builtinLangDir = funcExpr1(l12.builtinLangDir);
@@ -434,17 +435,17 @@ export const builtinObject = funcExpr1(l12.builtinOBJECT);
  */
 export const builtInCall = {
     name: 'builtInCall',
-    impl: $ => () => $.OR2([
-        { ALT: () => S11.builtInCall.impl($)() },
-        { ALT: () => $.SUBRULE(builtinLangDir) },
-        { ALT: () => $.SUBRULE(builtinLangStrDir) },
-        { ALT: () => $.SUBRULE(builtinHasLang) },
-        { ALT: () => $.SUBRULE(builtinHasLangDir) },
-        { ALT: () => $.SUBRULE(builtinIsTriple) },
-        { ALT: () => $.SUBRULE(builtinTriple) },
-        { ALT: () => $.SUBRULE(builtinSubject) },
-        { ALT: () => $.SUBRULE(builtinPredicate) },
-        { ALT: () => $.SUBRULE(builtinObject) },
+    impl: $ => (C) => $.OR2([
+        { ALT: () => S11.builtInCall.impl($)(C, undefined) },
+        { ALT: () => $.SUBRULE(builtinLangDir, undefined) },
+        { ALT: () => $.SUBRULE(builtinLangStrDir, undefined) },
+        { ALT: () => $.SUBRULE(builtinHasLang, undefined) },
+        { ALT: () => $.SUBRULE(builtinHasLangDir, undefined) },
+        { ALT: () => $.SUBRULE(builtinIsTriple, undefined) },
+        { ALT: () => $.SUBRULE(builtinTriple, undefined) },
+        { ALT: () => $.SUBRULE(builtinSubject, undefined) },
+        { ALT: () => $.SUBRULE(builtinPredicate, undefined) },
+        { ALT: () => $.SUBRULE(builtinObject, undefined) },
     ]),
 };
 function isLangDir(dir) {
@@ -457,8 +458,8 @@ function isLangDir(dir) {
  */
 export const rdfLiteral = {
     name: 'rdfLiteral',
-    impl: ({ ACTION, SUBRULE, OPTION, CONSUME, OR, context }) => () => {
-        const value = SUBRULE(S11.string);
+    impl: ({ ACTION, SUBRULE, OPTION, CONSUME, OR }) => (C) => {
+        const value = SUBRULE(S11.string, undefined);
         const langOrDataType = OPTION(() => OR([
             { ALT: () => {
                     const langTag = CONSUME(l12.LANG_DIR).image.slice(1);
@@ -479,10 +480,10 @@ export const rdfLiteral = {
                 } },
             { ALT: () => {
                     CONSUME(l11.symbols.hathat);
-                    return SUBRULE(S11.iri);
+                    return SUBRULE(S11.iri, undefined);
                 } },
         ]));
-        return context.dataFactory.literal(value, langOrDataType);
+        return ACTION(() => C.dataFactory.literal(value, langOrDataType));
     },
 };
 //# sourceMappingURL=grammar.js.map