@traqula/rules-sparql-1-2 0.0.1-alpha.137

package/LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright © 2024–now Jitse De Smet
+Comunica Association and Ghent University – imec, Belgium
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,15 @@
+# TRAQULA Rules SPARQL 1.2 package
+
+TRAQULA rules SPARQL 1.2 contains additional rules required for creating a parser for SPARQL 1.2 from the SPARQL 1.1 rules.
+
+## Installation
+
+```bash
+npm install @traqula/rules-sparql-1-2
+```
+
+or
+
+```bash
+yarn add @traqula/rules-sparql-1-2
+```

package/lib/grammar.d.ts

@@ -0,0 +1,157 @@
+/**
+ * This module will define patch rules that should be used in combination with the sparql11 grammar to create
+ * a sparql12 grammar.
+ * 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 { 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, TripleCreatorS, TripleCreatorSP } from './sparql12Types';
+/**
+ * [[56]](https://www.w3.org/TR/sparql12-query/#rReifiedTripleBlock) Used by triplesSameSubject
+ */
+export declare const reifiedTripleBlock: RuleDef<"reifiedTripleBlock", Triple[]>;
+/**
+ * [[57]](https://www.w3.org/TR/sparql12-query/#rReifiedTripleBlockPath) Used by TriplesSameSubjectPath
+ */
+export declare const reifiedTripleBlockPath: RuleDef<"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>;
+/**
+ * [[68]](https://www.w3.org/TR/sparql12-query/#rReifier)
+ */
+export declare const reifier: RuleDef<'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>;
+/**
+ * OVERRIDING RULE {@link S11.triplesSameSubject}
+ * [[79]](https://www.w3.org/TR/sparql12-query/#rTriplesSameSubject)
+ */
+export declare const triplesSameSubject: RuleDef<"triplesSameSubject", Triple[]>;
+/**
+ * OVERRIDING RULE {@link S11.triplesSameSubjectPath}
+ * [[85]](https://www.w3.org/TR/sparql12-query/#rTriplesSameSubjectPath)
+ */
+export declare const triplesSameSubjectPath: RuleDef<"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", TripleCreatorSP[]>;
+/**
+ * OVERRIDING RULE: {@link S11.objectPath}.
+ * [[91]](https://www.w3.org/TR/sparql12-query/#rTriplesSameSubjectPath) Used by ObjectListPath
+ */
+export declare const objectPath: RuleDef<"objectPath", TripleCreatorSP[]>;
+/**
+ * [[107]](https://www.w3.org/TR/sparql12-query/#rAnnotationPath)
+ */
+export declare const annotationPath: RuleDef<"annotationPath", IGraphNode[]>;
+/**
+ * [[109]](https://www.w3.org/TR/sparql12-query/#rAnnotation)
+ */
+export declare const annotation: RuleDef<"annotation", IGraphNode[]>;
+/**
+ * [[108]](https://www.w3.org/TR/sparql12-query/#rAnnotationBlockPath)
+ */
+export declare const annotationBlockPath: RuleDef<"annotationBlockPath", TripleCreatorS[]>;
+/**
+ * [[110]](https://www.w3.org/TR/sparql12-query/#rAnnotationBlock)
+ */
+export declare const annotationBlock: RuleDef<"annotationBlock", TripleCreatorS[]>;
+/**
+ * OVERRIDING RULE: {@link S11.graphNode}.
+ * [[111]](https://www.w3.org/TR/sparql12-query/#rGraphNode)
+ */
+export declare const graphNode: RuleDef<'graphNode', IGraphNode>;
+/**
+ * OVERRIDING RULE: {@link S11.graphNodePath}.
+ * [[112]](https://www.w3.org/TR/sparql12-query/#rGraphNodePath)
+ */
+export declare const graphNodePath: RuleDef<'graphNodePath', IGraphNode>;
+/**
+ * OVERRIDING RULE: {@link S11.varOrTerm}.
+ * [[113]](https://www.w3.org/TR/sparql12-query/#rVarOrTerm)
+ */
+export declare const varOrTerm: RuleDef<'varOrTerm', Term>;
+/**
+ * [[114]](https://www.w3.org/TR/sparql12-query/#rReifiedTriple)
+ */
+export declare const reifiedTriple: RuleDef<'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>;
+/**
+ * [[116]](https://www.w3.org/TR/sparql12-query/#rReifiedTripleObject)
+ */
+export declare const reifiedTripleObject: RuleDef<'reifiedTripleObject', RuleDefReturn<typeof reifiedTripleSubject>>;
+/**
+ * [[117]](https://www.w3.org/TR/sparql12-query/#rTripleTerm)
+ */
+export declare const tripleTerm: RuleDef<'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>;
+/**
+ * [[119]](https://www.w3.org/TR/sparql12-query/#rTripleTermObject)
+ */
+export declare const tripleTermObject: RuleDef<'tripleTermObject', RuleDefReturn<typeof tripleTermSubject> | BaseQuadTerm>;
+/**
+ * [[120]](https://www.w3.org/TR/sparql12-query/#rTripleTermData)
+ */
+export declare const tripleTermData: RuleDef<'tripleTermData', BaseQuadTerm>;
+/**
+ * [[121]](https://www.w3.org/TR/sparql12-query/#rTripleTermDataSubject)
+ */
+export declare const tripleTermDataSubject: RuleDef<'tripleTermDataSubject', T11.IriTerm | T11.LiteralTerm>;
+/**
+ * [[122]](https://www.w3.org/TR/sparql12-query/#rTripleTermDataObject)
+ */
+export declare const tripleTermDataObject: RuleDef<'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>;
+/**
+ * [[135]](https://www.w3.org/TR/sparql12-query/#rExprTripleTerm)
+ */
+export declare const exprTripleTerm: RuleDef<'exprTripleTerm', BaseQuadTerm>;
+/**
+ * [[136]](https://www.w3.org/TR/sparql12-query/#rExprTripleTermSubject)
+ */
+export declare const exprTripleTermSubject: RuleDef<'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 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]>;
+export declare const builtinHasLangDir: S11.RuleDefExpressionFunctionX<"builtInHasLangdir", [T11.Expression]>;
+export declare const builtinIsTriple: S11.RuleDefExpressionFunctionX<"builtInIsTriple", [T11.Expression]>;
+export declare const builtinTriple: S11.RuleDefExpressionFunctionX<"builtInTriple", [T11.Expression, T11.Expression, T11.Expression]>;
+export declare const builtinSubject: S11.RuleDefExpressionFunctionX<"builtInSubject", [T11.Expression]>;
+export declare const builtinPredicate: S11.RuleDefExpressionFunctionX<"builtInPredicate", [T11.Expression]>;
+export declare const builtinObject: S11.RuleDefExpressionFunctionX<"builtInObject", [T11.Expression]>;
+/**
+ * OVERRIDING RULE: {@link S11.builtInCall}.
+ * [[139]](https://www.w3.org/TR/sparql12-query/#rBuiltInCall)
+ */
+export declare const builtInCall: typeof S11.builtInCall;
+/**
+ * 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)
+ */
+export declare const rdfLiteral: typeof S11.rdfLiteral;

package/lib/grammar.js

@@ -0,0 +1,485 @@
+/**
+ * This module will define patch rules that should be used in combination with the sparql11 grammar to create
+ * a sparql12 grammar.
+ * 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 * 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);
+            return ACTION(() => [
+                ...triple.triples,
+                ...properties.map(partial => partial({ subject: triple.node })),
+            ]);
+        },
+    };
+}
+/**
+ * [[56]](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
+ */
+export const reifiedTripleBlockPath = reifiedTripleBlockImpl('reifiedTripleBlockPath', true);
+/**
+ * OVERRIDING RULE: {@link S11.dataBlockValue}.
+ * [[67]](https://www.w3.org/TR/sparql12-query/#rDataBlockValue)
+ */
+export const dataBlockValue = {
+    name: 'dataBlockValue',
+    impl: $ => () => $.OR2([
+        { ALT: () => S11.dataBlockValue.impl($)() },
+        { ALT: () => $.SUBRULE(tripleTermData) },
+    ]),
+};
+/**
+ * [[68]](https://www.w3.org/TR/sparql12-query/#rReifier)
+ */
+export const reifier = {
+    name: 'reifier',
+    impl: ({ ACTION, CONSUME, SUBRULE, OPTION, context }) => () => {
+        CONSUME(l12.tilde);
+        const reifier = OPTION(() => SUBRULE(varOrReifierId));
+        return ACTION(() => {
+            if (reifier === undefined && !context.parseMode.has(S11.canCreateBlankNodes)) {
+                throw new Error('Cannot create blanknodes in current parse mode');
+            }
+            return reifier ?? context.dataFactory.blankNode();
+        });
+    },
+};
+/**
+ * [[68]](https://www.w3.org/TR/sparql12-query/#rVarOrReifierId)
+ */
+export const varOrReifierId = {
+    name: 'varOrReifierId',
+    impl: ({ SUBRULE, OR }) => () => OR([
+        { ALT: () => SUBRULE(S11.var_) },
+        { ALT: () => SUBRULE(S11.iri) },
+        { ALT: () => SUBRULE(S11.blankNode) },
+    ]),
+};
+function triplesSameSubjectImpl(name, allowPaths) {
+    return {
+        name,
+        impl: $ => () => $.OR2([
+            { ALT: () => allowPaths ? S11.triplesSameSubjectPath.impl($)() : S11.triplesSameSubject.impl($)() },
+            { ALT: () => $.SUBRULE(allowPaths ? reifiedTripleBlockPath : reifiedTripleBlock) },
+        ]),
+    };
+}
+/**
+ * OVERRIDING RULE {@link S11.triplesSameSubject}
+ * [[79]](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)
+ */
+export const triplesSameSubjectPath = triplesSameSubjectImpl('triplesSameSubjectPath', true);
+function objectImpl(name, allowPaths) {
+    return {
+        name,
+        impl: ({ ACTION, SUBRULE, context }) => () => {
+            const objectVal = SUBRULE(allowPaths ? graphNodePath : graphNode);
+            const annotationVal = SUBRULE(allowPaths ? annotationPath : annotation);
+            return ACTION(() => {
+                const result = [
+                    // You parse the object
+                    ({ subject, predicate }) => ({ 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),
+                ];
+                for (const annotation of annotationVal) {
+                    result.push(({ subject, predicate }) => {
+                        if ('type' in predicate && predicate.type === 'path') {
+                            throw new Error('Note 17 violation');
+                        }
+                        return context.dataFactory.quad(annotation.node, context.dataFactory.namedNode(CommonIRIs.REIFIES), context.dataFactory.quad(subject, predicate, objectVal.node));
+                    });
+                    result.push(...annotation.triples.map(triple => () => triple));
+                }
+                return result;
+            });
+        },
+    };
+}
+/**
+ * OVERRIDING RULE: {@link S11.object}.
+ * [[84]](https://www.w3.org/TR/sparql12-query/#rObject) Used by ObjectList
+ */
+export const object = objectImpl('object', false);
+/**
+ * OVERRIDING RULE: {@link S11.objectPath}.
+ * [[91]](https://www.w3.org/TR/sparql12-query/#rTriplesSameSubjectPath) Used by ObjectListPath
+ */
+export const objectPath = objectImpl('objectPath', true);
+function annotationImpl(name, allowPaths) {
+    return {
+        name,
+        impl: ({ ACTION, SUBRULE, OR, MANY, context }) => () => {
+            const annotations = [];
+            let currentReifier;
+            function flush() {
+                if (currentReifier) {
+                    annotations.push({ node: currentReifier, triples: [] });
+                    currentReifier = undefined;
+                }
+            }
+            MANY(() => {
+                OR([
+                    { ALT: () => {
+                            const node = SUBRULE(reifier);
+                            ACTION(() => flush());
+                            currentReifier = node;
+                        } },
+                    { ALT: () => {
+                            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');
+                                }
+                                const node = currentReifier ?? context.dataFactory.blankNode();
+                                annotations.push({
+                                    node,
+                                    triples: block.map(partial => partial({ subject: node })),
+                                });
+                                currentReifier = undefined;
+                            });
+                        } },
+                ]);
+            });
+            return ACTION(() => {
+                flush();
+                return annotations;
+            });
+        },
+    };
+}
+/**
+ * [[107]](https://www.w3.org/TR/sparql12-query/#rAnnotationPath)
+ */
+export const annotationPath = annotationImpl('annotationPath', true);
+/**
+ * [[109]](https://www.w3.org/TR/sparql12-query/#rAnnotation)
+ */
+export const annotation = annotationImpl('annotation', false);
+function annotationBlockImpl(name, allowPaths) {
+    return {
+        name,
+        impl: ({ SUBRULE, CONSUME }) => () => {
+            CONSUME(l12.annotationOpen);
+            const res = SUBRULE(allowPaths ? S11.propertyListPathNotEmpty : S11.propertyListNotEmpty);
+            CONSUME(l12.annotationClose);
+            return res;
+        },
+    };
+}
+/**
+ * [[108]](https://www.w3.org/TR/sparql12-query/#rAnnotationBlockPath)
+ */
+export const annotationBlockPath = annotationBlockImpl('annotationBlockPath', true);
+/**
+ * [[110]](https://www.w3.org/TR/sparql12-query/#rAnnotationBlock)
+ */
+export const annotationBlock = annotationBlockImpl('annotationBlock', false);
+/**
+ * OVERRIDING RULE: {@link S11.graphNode}.
+ * [[111]](https://www.w3.org/TR/sparql12-query/#rGraphNode)
+ */
+export const graphNode = {
+    name: 'graphNode',
+    impl: $ => () => $.OR2([
+        { ALT: () => S11.graphNode.impl($)() },
+        { ALT: () => $.SUBRULE(reifiedTriple) },
+    ]),
+};
+/**
+ * OVERRIDING RULE: {@link S11.graphNodePath}.
+ * [[112]](https://www.w3.org/TR/sparql12-query/#rGraphNodePath)
+ */
+export const graphNodePath = {
+    name: 'graphNodePath',
+    impl: $ => () => $.OR2([
+        { ALT: () => S11.graphNodePath.impl($)() },
+        { ALT: () => $.SUBRULE(reifiedTriple) },
+    ]),
+};
+/**
+ * OVERRIDING RULE: {@link S11.varOrTerm}.
+ * [[113]](https://www.w3.org/TR/sparql12-query/#rVarOrTerm)
+ */
+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) },
+        { ALT: () => {
+                CONSUME(l11.terminals.nil);
+                return context.dataFactory.namedNode(CommonIRIs.NIL);
+            } },
+        { ALT: () => SUBRULE(tripleTerm) },
+    ]),
+};
+/**
+ * [[114]](https://www.w3.org/TR/sparql12-query/#rReifiedTriple)
+ */
+export const reifiedTriple = {
+    name: 'reifiedTriple',
+    impl: ({ ACTION, CONSUME, SUBRULE, OPTION, context }) => () => {
+        CONSUME(l12.reificationOpen);
+        const subject = SUBRULE(reifiedTripleSubject);
+        const predicate = SUBRULE(S11.verb);
+        const object = SUBRULE(reifiedTripleObject);
+        const reifierVal = OPTION(() => SUBRULE(reifier));
+        CONSUME(l12.reificationClose);
+        return ACTION(() => {
+            if (reifierVal === undefined && !context.parseMode.has(S11.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);
+            return {
+                node: reifier,
+                triples: [
+                    ...subject.triples,
+                    context.dataFactory.quad(reifier, context.dataFactory.namedNode(CommonIRIs.REIFIES), tripleTerm),
+                    ...object.triples,
+                ],
+            };
+        });
+    },
+};
+/**
+ * [[115]](https://www.w3.org/TR/sparql12-query/#rReifiedTripleSubject)
+ */
+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) },
+    ]),
+};
+/**
+ * [[116]](https://www.w3.org/TR/sparql12-query/#rReifiedTripleObject)
+ */
+export const reifiedTripleObject = {
+    name: 'reifiedTripleObject',
+    impl: $ => () => $.OR2([
+        { ALT: () => reifiedTripleSubject.impl($)() },
+        { ALT: () => ({ node: $.SUBRULE(tripleTerm), triples: [] }) },
+    ]),
+};
+/**
+ * [[117]](https://www.w3.org/TR/sparql12-query/#rTripleTerm)
+ */
+export const tripleTerm = {
+    name: 'tripleTerm',
+    impl: ({ CONSUME, SUBRULE, context }) => () => {
+        CONSUME(l12.tripleTermOpen);
+        const subject = SUBRULE(tripleTermSubject);
+        const predicate = SUBRULE(S11.verb);
+        const object = SUBRULE(tripleTermObject);
+        CONSUME(l12.tripleTermClose);
+        return context.dataFactory.quad(subject, predicate, object);
+    },
+};
+/**
+ * [[118]](https://www.w3.org/TR/sparql12-query/#rTripleTermSubject)
+ */
+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) },
+    ]),
+};
+/**
+ * [[119]](https://www.w3.org/TR/sparql12-query/#rTripleTermObject)
+ */
+export const tripleTermObject = {
+    name: 'tripleTermObject',
+    impl: $ => () => $.OR2([
+        { ALT: () => tripleTermSubject.impl($)() },
+        { ALT: () => $.SUBRULE(tripleTerm) },
+    ]),
+};
+/**
+ * [[120]](https://www.w3.org/TR/sparql12-query/#rTripleTermData)
+ */
+export const tripleTermData = {
+    name: 'tripleTermData',
+    impl: ({ ACTION, CONSUME, OR, SUBRULE, context }) => () => {
+        CONSUME(l12.tripleTermOpen);
+        const subject = SUBRULE(tripleTermDataSubject);
+        const predicate = OR([
+            { ALT: () => SUBRULE(S11.iri) },
+            { ALT: () => {
+                    CONSUME(l11.a);
+                    return ACTION(() => context.dataFactory.namedNode(CommonIRIs.TYPE));
+                } },
+        ]);
+        const object = SUBRULE(tripleTermDataObject);
+        CONSUME(l12.tripleTermClose);
+        return ACTION(() => context.dataFactory.quad(subject, predicate, object));
+    },
+};
+/**
+ * [[121]](https://www.w3.org/TR/sparql12-query/#rTripleTermDataSubject)
+ */
+export const tripleTermDataSubject = {
+    name: 'tripleTermDataSubject',
+    impl: ({ OR, SUBRULE }) => () => OR([
+        { ALT: () => SUBRULE(S11.iri) },
+        { ALT: () => SUBRULE(rdfLiteral) },
+        { ALT: () => SUBRULE(S11.numericLiteral) },
+        { ALT: () => SUBRULE(S11.booleanLiteral) },
+    ]),
+};
+/**
+ * [[122]](https://www.w3.org/TR/sparql12-query/#rTripleTermDataObject)
+ */
+export const tripleTermDataObject = {
+    name: 'tripleTermDataObject',
+    impl: $ => () => $.OR2([
+        { ALT: () => tripleTermDataSubject.impl($)() },
+        { ALT: () => $.SUBRULE(tripleTermData) },
+    ]),
+};
+/**
+ * OVERRIDING RULE: {@link S11.primaryExpression}.
+ * [[134]](https://www.w3.org/TR/sparql12-query/#rPrimaryExpression)
+ */
+export const primaryExpression = {
+    name: 'primaryExpression',
+    impl: $ => () => $.OR2([
+        { ALT: () => S11.primaryExpression.impl($)() },
+        { ALT: () => $.SUBRULE(exprTripleTerm) },
+    ]),
+};
+/**
+ * [[135]](https://www.w3.org/TR/sparql12-query/#rExprTripleTerm)
+ */
+export const exprTripleTerm = {
+    name: 'exprTripleTerm',
+    impl: ({ ACTION, CONSUME, SUBRULE, context }) => () => {
+        CONSUME(l12.tripleTermOpen);
+        const subject = SUBRULE(exprTripleTermSubject);
+        const predicate = SUBRULE(S11.verb);
+        const object = SUBRULE(exprTripleTermObject);
+        CONSUME(l12.tripleTermClose);
+        return ACTION(() => context.dataFactory.quad(subject, predicate, object));
+    },
+};
+/**
+ * [[136]](https://www.w3.org/TR/sparql12-query/#rExprTripleTermSubject)
+ */
+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_) },
+    ]),
+};
+/**
+ * [[137]](https://www.w3.org/TR/sparql12-query/#rExprTripleTermObject)
+ */
+export const exprTripleTermObject = {
+    name: 'exprTripleTermObject',
+    impl: $ => () => $.OR2([
+        { ALT: () => exprTripleTermSubject.impl($)() },
+        { ALT: () => $.SUBRULE(exprTripleTerm) },
+    ]),
+};
+export const builtinLangDir = funcExpr1(l12.builtinLangDir);
+export const builtinLangStrDir = funcExpr3(l12.builtinStrLangDir);
+export const builtinHasLang = funcExpr1(l12.builtinHasLang);
+export const builtinHasLangDir = funcExpr1(l12.builtinHasLangDir);
+export const builtinIsTriple = funcExpr1(l12.builtinIsTRIPLE);
+export const builtinTriple = funcExpr3(l12.builtinTRIPLE);
+export const builtinSubject = funcExpr1(l12.builtinSUBJECT);
+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)
+ */
+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) },
+    ]),
+};
+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)
+ */
+export const rdfLiteral = {
+    name: 'rdfLiteral',
+    impl: ({ ACTION, SUBRULE, OPTION, CONSUME, OR, context }) => () => {
+        const value = SUBRULE(S11.string);
+        const langOrDataType = OPTION(() => OR([
+            { ALT: () => {
+                    const langTag = CONSUME(l12.LANG_DIR).image.slice(1);
+                    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;
+                    });
+                } },
+            { ALT: () => {
+                    CONSUME(l11.symbols.hathat);
+                    return SUBRULE(S11.iri);
+                } },
+        ]));
+        return context.dataFactory.literal(value, langOrDataType);
+    },
+};
+//# sourceMappingURL=grammar.js.map