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

package/lib/grammar.js

@@ -4,32 +4,90 @@
  * 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 { funcExpr1, funcExpr3, gram as S11, lex as l11, CommonIRIs, } from '@traqula/rules-sparql-1-1';
 import * as l12 from './lexer';
+import { langTagHasCorrectDomain } from './validator';
+/**
+ *[[7]](https://www.w3.org/TR/sparql12-query/#rVersionDecl)
+ */
+export const versionDecl = {
+    name: 'versionDecl',
+    impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
+        const versionToken = CONSUME(l12.version);
+        const identifier = SUBRULE(versionSpecifier, undefined);
+        return ACTION(() => C.factory.contextDefinitionVersion(identifier.val, C.factory.sourceLocation(versionToken, identifier)));
+    },
+    gImpl: ({ PRINT_WORDS }) => (ast, { factory: F }) => {
+        F.printFilter(ast, () => {
+            PRINT_WORDS('VERSION', `${S11.stringEscapedLexical(ast.version)}`);
+        });
+    },
+};
+/**
+ * [[8]](https://www.w3.org/TR/sparql12-query/#rVersionSpecifier)
+ */
+export const versionSpecifier = {
+    name: 'versionSpecifier',
+    impl: ({ ACTION, CONSUME, OR }) => (C) => {
+        const token = OR([
+            { ALT: () => CONSUME(l11.terminals.stringLiteral1) },
+            { ALT: () => CONSUME(l11.terminals.stringLiteral2) },
+        ]);
+        return ACTION(() => C.factory.wrap(token.image.slice(1, -1), C.factory.sourceLocation(token)));
+    },
+};
+/**
+ * OVERRIDING RULE {@link S11.prologue}
+ * [[8]](https://www.w3.org/TR/sparql12-query/#rVersionSpecifier)
+ */
+export const prologue = {
+    name: 'prologue',
+    impl: ({ SUBRULE, MANY, OR }) => () => {
+        const result = [];
+        MANY(() => OR([
+            { ALT: () => result.push(SUBRULE(S11.baseDecl, undefined)) },
+            // TODO: the [spec](https://www.w3.org/TR/sparql11-query/#iriRefs) says you cannot redefine prefixes.
+            //  We might need to check this.
+            { ALT: () => result.push(SUBRULE(S11.prefixDecl, undefined)) },
+            { ALT: () => result.push(SUBRULE(versionDecl, undefined)) },
+        ]));
+        return result;
+    },
+    gImpl: ({ SUBRULE }) => (ast, { factory: F }) => {
+        for (const context of ast) {
+            if (F.isContextDefinitionBase(context)) {
+                SUBRULE(S11.baseDecl, context, undefined);
+            }
+            else if (F.isContextDefinitionPrefix(context)) {
+                SUBRULE(S11.prefixDecl, context, undefined);
+            }
+            else if (F.isContextDefinitionVersion(context)) {
+                SUBRULE(versionDecl, context, undefined);
+            }
+        }
+    },
+};
 function reifiedTripleBlockImpl(name, allowPath) {
     return {
         name,
-        impl: ({ ACTION, SUBRULE }) => () => {
+        impl: ({ ACTION, SUBRULE }) => (C) => {
             const triple = SUBRULE(reifiedTriple, undefined);
-            const properties = SUBRULE(allowPath ? S11.propertyListPath : S11.propertyList, { subject: triple.node });
-            return ACTION(() => [
-                ...triple.triples,
-                ...properties,
-            ]);
+            const properties = SUBRULE(allowPath ? S11.propertyListPath : S11.propertyList, { subject: ACTION(() => C.factory.dematerialized(triple.identifier)) });
+            return ACTION(() => [triple, ...properties]);
         },
     };
 }
 /**
- * [[56]](https://www.w3.org/TR/sparql12-query/#rReifiedTripleBlock) Used by triplesSameSubject
+ * [[58]](https://www.w3.org/TR/sparql12-query/#rReifiedTripleBlock) Used by triplesSameSubject
  */
 export const reifiedTripleBlock = reifiedTripleBlockImpl('reifiedTripleBlock', false);
 /**
- * [[57]](https://www.w3.org/TR/sparql12-query/#rReifiedTripleBlockPath) Used by TriplesSameSubjectPath
+ * [[59]](https://www.w3.org/TR/sparql12-query/#rReifiedTripleBlockPath) Used by TriplesSameSubjectPath
  */
 export const reifiedTripleBlockPath = reifiedTripleBlockImpl('reifiedTripleBlockPath', true);
 /**
  * OVERRIDING RULE: {@link S11.dataBlockValue}.
- * [[67]](https://www.w3.org/TR/sparql12-query/#rDataBlockValue)
+ * [[69]](https://www.w3.org/TR/sparql12-query/#rDataBlockValue)
  */
 export const dataBlockValue = {
     name: 'dataBlockValue',
@@ -37,15 +95,9 @@ export const dataBlockValue = {
         { 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)
+ * [[70]](https://www.w3.org/TR/sparql12-query/#rReifier)
  */
 export const reifier = {
     name: 'reifier',
@@ -56,17 +108,17 @@ export const reifier = {
             if (reifier === undefined && !C.parseMode.has('canCreateBlankNodes')) {
                 throw new Error('Cannot create blanknodes in current parse mode');
             }
-            return reifier ?? C.dataFactory.blankNode();
+            return reifier ?? C.factory.blankNode(undefined, C.factory.sourceLocation());
         });
     },
 };
 /**
- * [[68]](https://www.w3.org/TR/sparql12-query/#rVarOrReifierId)
+ * [[71]](https://www.w3.org/TR/sparql12-query/#rVarOrReifierId)
  */
 export const varOrReifierId = {
     name: 'varOrReifierId',
-    impl: ({ SUBRULE, OR }) => () => OR([
-        { ALT: () => SUBRULE(S11.var_, undefined) },
+    impl: ({ SUBRULE, OR }) => C => OR([
+        { GATE: () => C.parseMode.has('canParseVars'), ALT: () => SUBRULE(S11.var_, undefined) },
         { ALT: () => SUBRULE(S11.iri, undefined) },
         { ALT: () => SUBRULE(S11.blankNode, undefined) },
     ]),
@@ -84,12 +136,12 @@ function triplesSameSubjectImpl(name, allowPaths) {
 }
 /**
  * OVERRIDING RULE {@link S11.triplesSameSubject}
- * [[79]](https://www.w3.org/TR/sparql12-query/#rTriplesSameSubject)
+ * [[81]](https://www.w3.org/TR/sparql12-query/#rTriplesSameSubject)
  */
 export const triplesSameSubject = triplesSameSubjectImpl('triplesSameSubject', false);
 /**
  * OVERRIDING RULE {@link S11.triplesSameSubjectPath}
- * [[85]](https://www.w3.org/TR/sparql12-query/#rTriplesSameSubjectPath)
+ * [[87]](https://www.w3.org/TR/sparql12-query/#rTriplesSameSubjectPath)
  */
 export const triplesSameSubjectPath = triplesSameSubjectImpl('triplesSameSubjectPath', true);
 function objectImpl(name, allowPaths) {
@@ -98,24 +150,13 @@ function objectImpl(name, allowPaths) {
         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) {
+                const F = C.factory;
+                if (F.isPathPure(predicate) && annotationVal.length > 0) {
                     throw new Error('Note 17 violation');
                 }
-                const result = [
-                    // You parse the object
-                    { subject, predicate, object: objectVal.node },
-                    // You might get some additional triples from parsing the object (like when it's a collection)
-                    ...objectVal.triples,
-                ];
-                for (const annotation of annotationVal) {
-                    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;
+                return F.annotatedTriple(subject, predicate, objectVal, annotationVal);
             });
         },
     };
@@ -136,42 +177,40 @@ function annotationImpl(name, allowPaths) {
         impl: ({ ACTION, SUBRULE, OR, MANY }) => (C) => {
             const annotations = [];
             let currentReifier;
-            function flush() {
-                if (currentReifier) {
-                    annotations.push({ node: currentReifier, triples: [] });
-                    currentReifier = undefined;
-                }
-            }
             MANY(() => {
                 OR([
                     { ALT: () => {
                             const node = SUBRULE(reifier, undefined);
-                            ACTION(() => flush());
+                            annotations.push(node);
                             currentReifier = node;
                         } },
                     { ALT: () => {
-                            let 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,
-                                    triples: block,
-                                });
+                                if (!currentReifier && !C.parseMode.has('canCreateBlankNodes')) {
+                                    throw new Error('Cannot create blanknodes in current parse mode');
+                                }
+                                currentReifier = currentReifier ?? C.factory.blankNode(undefined, C.factory.sourceLocation());
+                            });
+                            const block = SUBRULE(allowPaths ? annotationBlockPath : annotationBlock, currentReifier);
+                            ACTION(() => {
+                                annotations.push(block);
                                 currentReifier = undefined;
                             });
                         } },
                 ]);
             });
-            return ACTION(() => {
-                flush();
-                return annotations;
-            });
+            return annotations;
+        },
+        gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F }) => {
+            for (const annotation of ast) {
+                if (F.isTerm(annotation)) {
+                    F.printFilter(annotation, () => PRINT_WORD('~'));
+                    SUBRULE(graphNodePath, annotation, undefined);
+                }
+                else {
+                    SUBRULE(annotationBlockPath, annotation, undefined);
+                }
+            }
         },
     };
 }
@@ -180,26 +219,42 @@ function annotationImpl(name, allowPaths) {
  */
 export const annotationPath = annotationImpl('annotationPath', true);
 /**
- * [[109]](https://www.w3.org/TR/sparql12-query/#rAnnotation)
+ * [[111]](https://www.w3.org/TR/sparql12-query/#rAnnotation)
  */
 export const annotation = annotationImpl('annotation', false);
 function annotationBlockImpl(name, allowPaths) {
     return {
         name,
-        impl: ({ ACTION, SUBRULE, CONSUME }) => (_, arg) => {
-            CONSUME(l12.annotationOpen);
-            const res = SUBRULE(allowPaths ? S11.propertyListPathNotEmpty : S11.propertyListNotEmpty, { subject: ACTION(() => arg.subject) });
-            CONSUME(l12.annotationClose);
-            return res;
+        impl: ({ ACTION, SUBRULE, CONSUME }) => (C, arg) => {
+            const open = CONSUME(l12.annotationOpen);
+            const res = SUBRULE(allowPaths ? S11.propertyListPathNotEmpty : S11.propertyListNotEmpty, { subject: arg });
+            const close = CONSUME(l12.annotationClose);
+            return ACTION(() => C.factory.tripleCollectionBlankNodeProperties(arg, res, C.factory.sourceLocation(open, close)));
+        },
+        gImpl: ({ SUBRULE, PRINT_WORD, HANDLE_LOC }) => (ast, { factory: F }) => {
+            F.printFilter(ast, () => PRINT_WORD('{|'));
+            for (const triple of ast.triples) {
+                HANDLE_LOC(triple, () => {
+                    if (F.isTerm(triple.predicate)) {
+                        SUBRULE(graphNodePath, triple.predicate, undefined);
+                    }
+                    else {
+                        SUBRULE(S11.pathGenerator, triple.predicate, undefined);
+                    }
+                    SUBRULE(graphNodePath, triple.object, undefined);
+                    F.printFilter(ast, () => PRINT_WORD(';'));
+                });
+            }
+            F.printFilter(ast, () => PRINT_WORD('|}'));
         },
     };
 }
 /**
- * [[108]](https://www.w3.org/TR/sparql12-query/#rAnnotationBlockPath)
+ * [[110]](https://www.w3.org/TR/sparql12-query/#rAnnotationBlockPath)
  */
 export const annotationBlockPath = annotationBlockImpl('annotationBlockPath', true);
 /**
- * [[110]](https://www.w3.org/TR/sparql12-query/#rAnnotationBlock)
+ * [[112]](https://www.w3.org/TR/sparql12-query/#rAnnotationBlock)
  */
 export const annotationBlock = annotationBlockImpl('annotationBlock', false);
 /**
@@ -215,7 +270,7 @@ export const graphNode = {
 };
 /**
  * OVERRIDING RULE: {@link S11.graphNodePath}.
- * [[112]](https://www.w3.org/TR/sparql12-query/#rGraphNodePath)
+ * [[114]](https://www.w3.org/TR/sparql12-query/#rGraphNodePath)
  */
 export const graphNodePath = {
     name: 'graphNodePath',
@@ -223,41 +278,35 @@ export const graphNodePath = {
         { ALT: () => S11.graphNodePath.impl($)(C, undefined) },
         { ALT: () => $.SUBRULE(reifiedTriple, undefined) },
     ]),
+    gImpl: $ => (ast, C, params) => {
+        if (C.factory.isTripleCollectionReifiedTriple(ast)) {
+            $.SUBRULE(reifiedTriple, ast, undefined);
+        }
+        else {
+            S11.graphNodePath.gImpl($)(ast, C, params);
+        }
+    },
 };
 /**
  * OVERRIDING RULE: {@link S11.varOrTerm}.
- * [[113]](https://www.w3.org/TR/sparql12-query/#rVarOrTerm)
+ * [[115]](https://www.w3.org/TR/sparql12-query/#rVarOrTerm)
  */
 export const varOrTerm = {
     name: 'varOrTerm',
     impl: ({ ACTION, SUBRULE, OR, CONSUME }) => C => OR([
-        { ALT: () => SUBRULE(S11.var_, undefined) },
+        { GATE: () => C.parseMode.has('canParseVars'), 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 ACTION(() => C.dataFactory.namedNode(CommonIRIs.NIL));
+                const token = CONSUME(l11.terminals.nil);
+                return ACTION(() => C.factory.namedNode(C.factory.sourceLocation(token), CommonIRIs.NIL));
             } },
         { 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);
-    },
+    // Generation remains untouched - go through graphTerm
 };
 /**
  * [[114]](https://www.w3.org/TR/sparql12-query/#rReifiedTriple)
@@ -265,42 +314,49 @@ export const varOrTerm = {
 export const reifiedTriple = {
     name: 'reifiedTriple',
     impl: ({ ACTION, CONSUME, SUBRULE, OPTION }) => (C) => {
-        CONSUME(l12.reificationOpen);
+        const open = CONSUME(l12.reificationOpen);
         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);
+        const close = CONSUME(l12.reificationClose);
         return ACTION(() => {
+            // A reifier would be auto generated in this case, but we are not allowed to use them.
             if (reifierVal === undefined && !C.parseMode.has('canCreateBlankNodes')) {
                 throw new Error('Cannot create blanknodes in current parse mode');
             }
-            const reifier = reifierVal ?? C.dataFactory.blankNode();
-            const tripleTerm = C.dataFactory.quad(subject.node, predicate, object.node);
-            return {
-                node: reifier,
-                triples: [
-                    ...subject.triples,
-                    C.dataFactory.quad(reifier, C.dataFactory.namedNode(CommonIRIs.REIFIES), tripleTerm),
-                    ...object.triples,
-                ],
-            };
+            return C.factory.tripleCollectionReifiedTriple(C.factory.sourceLocation(open, close), subject, predicate, object, reifierVal);
         });
     },
+    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F }) => {
+        F.printFilter(ast, () => PRINT_WORD('<<'));
+        const triple = ast.triples[0];
+        SUBRULE(graphNodePath, triple.subject, undefined);
+        if (F.isPathPure(triple.predicate)) {
+            SUBRULE(S11.pathGenerator, triple.predicate, undefined);
+        }
+        else {
+            SUBRULE(graphNodePath, triple.predicate, undefined);
+        }
+        SUBRULE(graphNodePath, triple.object, undefined);
+        SUBRULE(annotationPath, [ast.identifier], undefined);
+        F.printFilter(ast, () => PRINT_WORD('>>'));
+    },
 };
 /**
  * [[115]](https://www.w3.org/TR/sparql12-query/#rReifiedTripleSubject)
  */
 export const reifiedTripleSubject = {
     name: 'reifiedTripleSubject',
-    impl: ({ OR, SUBRULE }) => () => OR([
-        { 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: [] }) },
+    impl: ({ OR, SUBRULE }) => C => OR([
+        { GATE: () => C.parseMode.has('canParseVars'), 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: () => SUBRULE(reifiedTriple, undefined) },
+        { ALT: () => SUBRULE(tripleTerm, undefined) },
     ]),
 };
 /**
@@ -308,10 +364,7 @@ export const reifiedTripleSubject = {
  */
 export const reifiedTripleObject = {
     name: 'reifiedTripleObject',
-    impl: $ => C => $.OR2([
-        { ALT: () => reifiedTripleSubject.impl($)(C, undefined) },
-        { ALT: () => ({ node: $.SUBRULE(tripleTerm, undefined), triples: [] }) },
-    ]),
+    impl: reifiedTripleSubject.impl,
 };
 /**
  * [[117]](https://www.w3.org/TR/sparql12-query/#rTripleTerm)
@@ -319,61 +372,65 @@ export const reifiedTripleObject = {
 export const tripleTerm = {
     name: 'tripleTerm',
     impl: ({ ACTION, CONSUME, SUBRULE }) => (C) => {
-        CONSUME(l12.tripleTermOpen);
+        const open = CONSUME(l12.tripleTermOpen);
         const subject = SUBRULE(tripleTermSubject, undefined);
         const predicate = SUBRULE(S11.verb, undefined);
         const object = SUBRULE(tripleTermObject, undefined);
-        CONSUME(l12.tripleTermClose);
-        return ACTION(() => C.dataFactory.quad(subject, predicate, object));
+        const close = CONSUME(l12.tripleTermClose);
+        return ACTION(() => C.factory.termTriple(subject, predicate, object, C.factory.sourceLocation(open, close)));
+    },
+    gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F }) => {
+        F.printFilter(ast, () => PRINT_WORD('<<('));
+        SUBRULE(graphNodePath, ast.subject, undefined);
+        SUBRULE(graphNodePath, ast.predicate, undefined);
+        SUBRULE(graphNodePath, ast.object, undefined);
+        F.printFilter(ast, () => PRINT_WORD(')>>'));
     },
-    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)
+ * [[120]](https://www.w3.org/TR/sparql12-query/#rTripleTermSubject)
  */
 export const tripleTermSubject = {
     name: 'tripleTermSubject',
-    impl: ({ SUBRULE, OR }) => () => OR([
-        { ALT: () => SUBRULE(S11.var_, undefined) },
+    impl: ({ SUBRULE, OR }) => C => OR([
+        { GATE: () => C.parseMode.has('canParseVars'), 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: () => SUBRULE(tripleTerm, undefined) },
     ]),
 };
 /**
- * [[119]](https://www.w3.org/TR/sparql12-query/#rTripleTermObject)
+ * [[121]](https://www.w3.org/TR/sparql12-query/#rTripleTermObject)
  */
 export const tripleTermObject = {
     name: 'tripleTermObject',
-    impl: $ => C => $.OR2([
-        { ALT: () => tripleTermSubject.impl($)(C, undefined) },
-        { ALT: () => $.SUBRULE(tripleTerm, undefined) },
-    ]),
+    impl: tripleTermSubject.impl,
 };
 /**
- * [[120]](https://www.w3.org/TR/sparql12-query/#rTripleTermData)
+ * [[122]](https://www.w3.org/TR/sparql12-query/#rTripleTermData)
  */
 export const tripleTermData = {
     name: 'tripleTermData',
     impl: ({ ACTION, CONSUME, OR, SUBRULE }) => (C) => {
-        CONSUME(l12.tripleTermOpen);
+        const open = CONSUME(l12.tripleTermOpen);
         const subject = SUBRULE(tripleTermDataSubject, undefined);
         const predicate = OR([
             { ALT: () => SUBRULE(S11.iri, undefined) },
             { ALT: () => {
-                    CONSUME(l11.a);
-                    return ACTION(() => C.dataFactory.namedNode(CommonIRIs.TYPE));
+                    const token = CONSUME(l11.a);
+                    return ACTION(() => C.factory.namedNode(C.factory.sourceLocation(token), CommonIRIs.TYPE));
                 } },
         ]);
         const object = SUBRULE(tripleTermDataObject, undefined);
-        CONSUME(l12.tripleTermClose);
-        return ACTION(() => C.dataFactory.quad(subject, predicate, object));
+        const close = CONSUME(l12.tripleTermClose);
+        return ACTION(() => C.factory.termTriple(subject, predicate, object, C.factory.sourceLocation(open, close)));
     },
 };
 /**
- * [[121]](https://www.w3.org/TR/sparql12-query/#rTripleTermDataSubject)
+ * [[123]](https://www.w3.org/TR/sparql12-query/#rTripleTermDataSubject)
  */
 export const tripleTermDataSubject = {
     name: 'tripleTermDataSubject',
@@ -382,21 +439,19 @@ export const tripleTermDataSubject = {
         { ALT: () => SUBRULE(rdfLiteral, undefined) },
         { ALT: () => SUBRULE(S11.numericLiteral, undefined) },
         { ALT: () => SUBRULE(S11.booleanLiteral, undefined) },
+        { ALT: () => SUBRULE(tripleTermData, undefined) },
     ]),
 };
 /**
- * [[122]](https://www.w3.org/TR/sparql12-query/#rTripleTermDataObject)
+ * [[124]](https://www.w3.org/TR/sparql12-query/#rTripleTermDataObject)
  */
 export const tripleTermDataObject = {
     name: 'tripleTermDataObject',
-    impl: $ => C => $.OR2([
-        { ALT: () => tripleTermDataSubject.impl($)(C, undefined) },
-        { ALT: () => $.SUBRULE(tripleTermData, undefined) },
-    ]),
+    impl: tripleTermDataSubject.impl,
 };
 /**
  * OVERRIDING RULE: {@link S11.primaryExpression}.
- * [[134]](https://www.w3.org/TR/sparql12-query/#rPrimaryExpression)
+ * [[136]](https://www.w3.org/TR/sparql12-query/#rPrimaryExpression)
  */
 export const primaryExpression = {
     name: 'primaryExpression',
@@ -411,36 +466,34 @@ export const primaryExpression = {
 export const exprTripleTerm = {
     name: 'exprTripleTerm',
     impl: ({ ACTION, CONSUME, SUBRULE }) => (C) => {
-        CONSUME(l12.tripleTermOpen);
+        const open = CONSUME(l12.tripleTermOpen);
         const subject = SUBRULE(exprTripleTermSubject, undefined);
         const predicate = SUBRULE(S11.verb, undefined);
         const object = SUBRULE(exprTripleTermObject, undefined);
-        CONSUME(l12.tripleTermClose);
-        return ACTION(() => C.dataFactory.quad(subject, predicate, object));
+        const close = CONSUME(l12.tripleTermClose);
+        return ACTION(() => C.factory.termTriple(subject, predicate, object, C.factory.sourceLocation(open, close)));
     },
 };
 /**
- * [[136]](https://www.w3.org/TR/sparql12-query/#rExprTripleTermSubject)
+ * [[138]](https://www.w3.org/TR/sparql12-query/#rExprTripleTermSubject)
  */
 export const exprTripleTermSubject = {
     name: 'exprTripleTermSubject',
-    impl: ({ OR, SUBRULE }) => () => OR([
+    impl: ({ OR, SUBRULE }) => C => OR([
         { ALT: () => SUBRULE(S11.iri, undefined) },
         { ALT: () => SUBRULE(rdfLiteral, undefined) },
         { ALT: () => SUBRULE(S11.numericLiteral, undefined) },
         { ALT: () => SUBRULE(S11.booleanLiteral, undefined) },
-        { ALT: () => SUBRULE(S11.var_, undefined) },
+        { GATE: () => C.parseMode.has('canParseVars'), ALT: () => SUBRULE(S11.var_, undefined) },
+        { ALT: () => SUBRULE(exprTripleTerm, undefined) },
     ]),
 };
 /**
- * [[137]](https://www.w3.org/TR/sparql12-query/#rExprTripleTermObject)
+ * [[139]](https://www.w3.org/TR/sparql12-query/#rExprTripleTermObject)
  */
 export const exprTripleTermObject = {
     name: 'exprTripleTermObject',
-    impl: $ => C => $.OR2([
-        { ALT: () => exprTripleTermSubject.impl($)(C, undefined) },
-        { ALT: () => $.SUBRULE(exprTripleTerm, undefined) },
-    ]),
+    impl: exprTripleTermSubject.impl,
 };
 export const builtinLangDir = funcExpr1(l12.builtinLangDir);
 export const builtinLangStrDir = funcExpr3(l12.builtinStrLangDir);
@@ -453,7 +506,7 @@ export const builtinPredicate = funcExpr1(l12.builtinPREDICATE);
 export const builtinObject = funcExpr1(l12.builtinOBJECT);
 /**
  * OVERRIDING RULE: {@link S11.builtInCall}.
- * [[139]](https://www.w3.org/TR/sparql12-query/#rBuiltInCall)
+ * [[141]](https://www.w3.org/TR/sparql12-query/#rBuiltInCall)
  */
 export const builtInCall = {
     name: 'builtInCall',
@@ -470,42 +523,89 @@ export const builtInCall = {
         { ALT: () => $.SUBRULE(builtinObject, undefined) },
     ]),
 };
-function isLangDir(dir) {
-    return dir === 'ltr' || dir === 'rtl';
-}
 /**
  * OVERRIDING RULE: {@link S11.rdfLiteral}.
  * No retyping is needed since the return type is the same
- * [[147]](https://www.w3.org/TR/sparql12-query/#rRDFLiteral)
+ * [[149]](https://www.w3.org/TR/sparql12-query/#rRDFLiteral)
  */
 export const rdfLiteral = {
     name: 'rdfLiteral',
     impl: ({ ACTION, SUBRULE, OPTION, CONSUME, OR }) => (C) => {
         const value = SUBRULE(S11.string, undefined);
-        const langOrDataType = OPTION(() => OR([
+        return OPTION(() => OR([
             { ALT: () => {
-                    const langTag = CONSUME(l12.LANG_DIR).image.slice(1);
+                    const langTag = CONSUME(l12.LANG_DIR);
                     return ACTION(() => {
-                        const dirSplit = langTag.split('--');
-                        if (dirSplit.length > 1) {
-                            const [language, direction] = dirSplit;
-                            if (!isLangDir(direction)) {
-                                throw new Error(`language direction "${direction}" of literal "${value}@${langTag}" is not is required range 'ltr' | 'rtl'.`);
-                            }
-                            return {
-                                language,
-                                direction,
-                            };
-                        }
-                        return langTag;
+                        const literal = C.factory.literalTerm(C.factory.sourceLocation(value, langTag), value.value, langTag.image.slice(1).toLowerCase());
+                        langTagHasCorrectDomain(literal);
+                        return literal;
                     });
                 } },
             { ALT: () => {
                     CONSUME(l11.symbols.hathat);
-                    return SUBRULE(S11.iri, undefined);
+                    const iriVal = SUBRULE(S11.iri, undefined);
+                    return ACTION(() => C.factory.literalTerm(C.factory.sourceLocation(value, iriVal), value.value, iriVal));
                 } },
-        ]));
-        return ACTION(() => C.dataFactory.literal(value, langOrDataType));
+        ])) ?? value;
+    },
+};
+/**
+ * OVERRIDING RULE: {@link S11.triplesBlock}.
+ */
+export const generateTriplesBlock = {
+    name: 'triplesBlock',
+    gImpl: ({ SUBRULE, PRINT_WORD, HANDLE_LOC }) => (ast, { factory: F }) => {
+        for (const [index, triple] of ast.triples.entries()) {
+            HANDLE_LOC(triple, () => {
+                const nextTriple = ast.triples.at(index);
+                if (F.isTripleCollection(triple)) {
+                    SUBRULE(graphNodePath, triple, undefined);
+                    // A top level tripleCollection block means that it is not used in a triple. So you end with DOT.
+                    F.printFilter(triple, () => PRINT_WORD('.'));
+                }
+                else {
+                    // Subject
+                    SUBRULE(graphNodePath, triple.subject, undefined);
+                    // Predicate
+                    if (F.isPathPure(triple.predicate)) {
+                        SUBRULE(S11.pathGenerator, triple.predicate, undefined);
+                    }
+                    else {
+                        SUBRULE(graphNodePath, triple.predicate, undefined);
+                    }
+                    // Object
+                    SUBRULE(graphNodePath, triple.object, undefined);
+                    SUBRULE(annotationPath, triple.annotations ?? [], undefined);
+                    // If no more things, or a top level collection (only possible if new block was part), or new subject: add DOT
+                    if (nextTriple === undefined || F.isTripleCollection(nextTriple) ||
+                        !F.isSourceLocationNoMaterialize(nextTriple.subject.loc)) {
+                        F.printFilter(ast, () => PRINT_WORD('.'));
+                    }
+                    else if (F.isSourceLocationNoMaterialize(nextTriple.predicate.loc)) {
+                        F.printFilter(ast, () => PRINT_WORD(','));
+                    }
+                    else {
+                        F.printFilter(ast, () => PRINT_WORD(';'));
+                    }
+                }
+            });
+        }
+    },
+};
+/**
+ * OVERRIDING RULE: {@link S11.graphTerm}.
+ * No retyping is needed since the return type is the same
+ * [[149]](https://www.w3.org/TR/sparql12-query/#rRDFLiteral)
+ */
+export const generateGraphTerm = {
+    name: 'graphTerm',
+    gImpl: $ => (ast, C, par) => {
+        if (C.factory.isTermTriple(ast)) {
+            $.SUBRULE(tripleTerm, ast, undefined);
+        }
+        else {
+            S11.graphTerm.gImpl($)(ast, C, par);
+        }
     },
 };
 //# sourceMappingURL=grammar.js.map