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

package/lib/grammar.js

@@ -4,16 +4,14 @@
  * 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 { funcExpr1, funcExpr3, gram as S11, lex as l11, CommonIRIs } from '@traqula/rules-sparql-1-1';
 import * as l12 from './lexer';
-import { funcExpr1, funcExpr3 } from '@traqula/rules-sparql-1-1';
-import { gram as S11, lex as l11 } from '@traqula/rules-sparql-1-1';
-import { CommonIRIs } from '@traqula/core';
 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,24 +33,30 @@ 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) },
     ]),
+    gImpl: ({ SUBRULE }) => (ast) => {
+        if (ast) {
+            return SUBRULE(varOrTerm, ast, undefined);
+        }
+        return 'UNDEF';
+    },
 };
 /**
  * [[68]](https://www.w3.org/TR/sparql12-query/#rReifier)
  */
 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 +66,19 @@ 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 +95,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 +112,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 +133,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 +145,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 +186,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 +208,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 +219,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,43 +230,58 @@ 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) },
     ]),
+    gImpl: ({ SUBRULE }) => (ast) => {
+        if (ast.termType === 'Variable') {
+            return SUBRULE(S11.var_, ast, undefined);
+        }
+        if (ast.termType === 'NamedNode') {
+            return SUBRULE(S11.iri, ast, undefined);
+        }
+        if (ast.termType === 'BlankNode') {
+            return SUBRULE(S11.blankNode, ast, undefined);
+        }
+        if (ast.termType === 'Quad') {
+            return SUBRULE(tripleTerm, ast, undefined);
+        }
+        return SUBRULE(S11.rdfLiteral, ast, undefined);
+    },
 };
 /**
  * [[114]](https://www.w3.org/TR/sparql12-query/#rReifiedTriple)
  */
 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 +294,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 +308,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,14 +318,15 @@ 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));
     },
+    gImpl: ({ SUBRULE }) => ast => `<<( ${SUBRULE(varOrTerm, ast.subject, undefined)} ${SUBRULE(varOrTerm, ast.predicate, undefined)} ${SUBRULE(varOrTerm, ast.object, undefined)}  )>>`,
 };
 /**
  * [[118]](https://www.w3.org/TR/sparql12-query/#rTripleTermSubject)
@@ -311,12 +334,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 +347,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 +357,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 +378,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 +389,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 +400,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 +410,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 +425,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 +437,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 +457,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 +480,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 +502,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