@faubulous/mentor-rdf 1.4.1 → 1.4.2

package/dist/index.js

@@ -1868,8 +1868,8 @@ var Uri = class _Uri {
     if (u.endsWith("/") || u.endsWith("#")) {
       u = u.substring(0, u.length - 1);
     }
-    let ns = _Uri.getNamespaceIri(u);
-    return ns.length < u.length ? u.replace(ns, "") : void 0;
+    let ns2 = _Uri.getNamespaceIri(u);
+    return ns2.length < u.length ? u.replace(ns2, "") : void 0;
   }
   /**
    * Get the portion of a URI after the first occurance of '#' or the last occurance of '/'.
@@ -4125,7 +4125,7 @@ var ShapeRepository = class extends IndividualRepository {
    */
   getPropertyPathTokens(graphUris, subject) {
     const visitedNodes = /* @__PURE__ */ new Set();
-    const parse = (subject2, level, separator = "/", i = 0) => {
+    const parse2 = (subject2, level, separator = "/", i = 0) => {
       if (visitedNodes.has(subject2.value)) {
         return [];
       }
@@ -4135,10 +4135,10 @@ var ShapeRepository = class extends IndividualRepository {
       } else {
         const first2 = this.store.matchAll(graphUris, subject2, rdf.first, null, false).next().value;
         if (first2) {
-          const path = parse(first2.object, level + 1);
+          const path = parse2(first2.object, level + 1);
           const rest = this.store.matchAll(graphUris, subject2, rdf.rest, null, false).next().value;
           if (rest && rest.object.value !== rdf.nil.value) {
-            const tail = parse(rest.object, level, separator, i + 1);
+            const tail = parse2(rest.object, level, separator, i + 1);
             if (tail.length === 0) {
               return path;
             }
@@ -4153,19 +4153,19 @@ var ShapeRepository = class extends IndividualRepository {
           for (let q of this.store.matchAll(graphUris, subject2, null, null, false)) {
             switch (q.predicate.value) {
               case sh.inversePath.value: {
-                return ["^", ...parse(q.object, level)];
+                return ["^", ...parse2(q.object, level)];
               }
               case sh.zeroOrOnePath.value: {
-                return [...parse(q.object, level), "?"];
+                return [...parse2(q.object, level), "?"];
               }
               case sh.zeroOrMorePath.value: {
-                return [...parse(q.object, level), "*"];
+                return [...parse2(q.object, level), "*"];
               }
               case sh.oneOrMorePath.value: {
-                return [...parse(q.object, level), "+"];
+                return [...parse2(q.object, level), "+"];
               }
               case sh.alternativePath.value: {
-                return parse(q.object, level, "|");
+                return parse2(q.object, level, "|");
               }
               default:
                 throw new Error(`Unsupported path predicate: ${q.predicate.value}`);
@@ -4175,7 +4175,7 @@ var ShapeRepository = class extends IndividualRepository {
         }
       }
     };
-    return parse(subject, 0);
+    return parse2(subject, 0);
   }
   /**
    * Get the first discovered path from a given shape class to the sh:Shape root.
@@ -14889,6 +14889,2676 @@ var SparqlTokens = [
   RdfToken.STRING_LITERAL_SINGLE_QUOTE,
   RdfToken.STRING_LITERAL_QUOTE
 ];
+var SparqlParser = class extends CstParser {
+  constructor() {
+    super(SparqlTokens, {
+      recoveryEnabled: true
+    });
+    /**
+     * A map of prefixes to their namespace IRI.
+     */
+    __publicField(this, "namespaces", {});
+    /**
+     * Tracks whether the current verb in a PropertyListPathNotEmpty is a simple
+     * path (IRI or 'a') vs a complex property path expression. Per spec note 16,
+     * annotations and reifiers are only permitted when the verb is a simple path.
+     */
+    __publicField(this, "_verbIsSimplePath", true);
+    /**
+     * Tracks whether we are inside a DELETE block (DELETE DATA, DELETE WHERE,
+     * or DeleteClause). Per grammar note 7, blank node syntax is not allowed
+     * in these contexts, which means anonymous reifiers and annotation blocks
+     * without a named reifier are disallowed.
+     */
+    __publicField(this, "_insideDeleteBlock", false);
+    /**
+     * Whether to throw errors during parsing or collect them.
+     */
+    __publicField(this, "_throwOnErrors", true);
+    /**
+     * Semantic errors collected during parsing (e.g., UndefinedNamespacePrefixError).
+     */
+    __publicField(this, "semanticErrors", []);
+    // ==========================================
+    // Entry point
+    // ==========================================
+    /**
+     * [1] QueryUnit ::= Query
+     * [30] UpdateUnit ::= Update
+     * Combined entry point that tries Query first, then Update.
+     */
+    __publicField(this, "queryOrUpdate", this.RULE("queryOrUpdate", () => {
+      this.SUBRULE(this.prologue);
+      this.OR([
+        // Query forms (SELECT, CONSTRUCT, DESCRIBE, ASK)
+        { ALT: () => this.SUBRULE(this.queryBody) },
+        // Update forms (INSERT, DELETE, LOAD, CLEAR, DROP, ADD, MOVE, COPY, CREATE, WITH)
+        { ALT: () => this.SUBRULE(this.updateBody) }
+      ]);
+    }));
+    // ==========================================
+    // Query productions [2]-[29]
+    // ==========================================
+    /**
+     * [2] Query ::= Prologue (SelectQuery | ConstructQuery | DescribeQuery | AskQuery) ValuesClause
+     * Note: Prologue is factored out into queryOrUpdate.
+     */
+    __publicField(this, "query", this.RULE("query", () => {
+      this.SUBRULE(this.prologue);
+      this.SUBRULE(this.queryBody);
+    }));
+    /**
+     * Query body after prologue: (SelectQuery | ConstructQuery | DescribeQuery | AskQuery) ValuesClause
+     */
+    __publicField(this, "queryBody", this.RULE("queryBody", () => {
+      this.OR([
+        { ALT: () => this.SUBRULE(this.selectQuery) },
+        { ALT: () => this.SUBRULE(this.constructQuery) },
+        { ALT: () => this.SUBRULE(this.describeQuery) },
+        { ALT: () => this.SUBRULE(this.askQuery) }
+      ]);
+      this.SUBRULE(this.valuesClause);
+    }));
+    /**
+     * [4] Prologue ::= (BaseDecl | PrefixDecl | VersionDecl)*
+     */
+    __publicField(this, "prologue", this.RULE("prologue", () => {
+      this.MANY(() => {
+        this.OR([
+          { ALT: () => this.SUBRULE(this.baseDecl) },
+          { ALT: () => this.SUBRULE(this.prefixDecl) },
+          { ALT: () => this.SUBRULE(this.versionDecl) }
+        ]);
+      });
+    }));
+    /**
+     * [5] BaseDecl ::= 'BASE' IRIREF
+     */
+    __publicField(this, "baseDecl", this.RULE("baseDecl", () => {
+      this.CONSUME(RdfToken.BASE);
+      this.CONSUME(RdfToken.IRIREF);
+    }));
+    /**
+     * [6] PrefixDecl ::= 'PREFIX' PNAME_NS IRIREF
+     */
+    __publicField(this, "prefixDecl", this.RULE("prefixDecl", () => {
+      this.CONSUME(RdfToken.PREFIX);
+      const prefix = this.CONSUME(RdfToken.PNAME_NS);
+      const iri = this.CONSUME(RdfToken.IRIREF);
+      this.registerNamespace(prefix, iri);
+    }));
+    /**
+     * [7] VersionDecl ::= 'VERSION' VersionSpecifier
+     */
+    __publicField(this, "versionDecl", this.RULE("versionDecl", () => {
+      this.CONSUME(RdfToken.SPARQL_VERSION);
+      this.SUBRULE(this.versionSpecifier);
+    }));
+    /**
+     * [8] VersionSpecifier ::= STRING_LITERAL_QUOTE | STRING_LITERAL_SINGLE_QUOTE
+     */
+    __publicField(this, "versionSpecifier", this.RULE("versionSpecifier", () => {
+      this.OR([
+        { ALT: () => this.CONSUME(RdfToken.STRING_LITERAL_QUOTE) },
+        { ALT: () => this.CONSUME(RdfToken.STRING_LITERAL_SINGLE_QUOTE) }
+      ]);
+    }));
+    /**
+     * [9] SelectQuery ::= SelectClause DatasetClause* WhereClause SolutionModifier
+     */
+    __publicField(this, "selectQuery", this.RULE("selectQuery", () => {
+      this.SUBRULE(this.selectClause);
+      this.MANY(() => this.SUBRULE(this.datasetClause));
+      this.SUBRULE(this.whereClause);
+      this.SUBRULE(this.solutionModifier);
+    }));
+    /**
+     * [10] SubSelect ::= SelectClause WhereClause SolutionModifier ValuesClause
+     */
+    __publicField(this, "subSelect", this.RULE("subSelect", () => {
+      this.SUBRULE(this.selectClause);
+      this.SUBRULE(this.whereClause);
+      this.SUBRULE(this.solutionModifier);
+      this.SUBRULE(this.valuesClause);
+    }));
+    /**
+     * [11] SelectClause ::= 'SELECT' ('DISTINCT' | 'REDUCED')? ((Var | ('(' Expression 'AS' Var ')'))+ | '*')
+     */
+    __publicField(this, "selectClause", this.RULE("selectClause", () => {
+      this.CONSUME(RdfToken.SELECT);
+      this.OPTION(() => {
+        this.OR1([
+          { ALT: () => this.CONSUME(RdfToken.DISTINCT) },
+          { ALT: () => this.CONSUME(RdfToken.REDUCED) }
+        ]);
+      });
+      this.OR2([
+        {
+          ALT: () => {
+            this.AT_LEAST_ONE(() => {
+              this.OR3([
+                { ALT: () => this.SUBRULE(this.var) },
+                {
+                  ALT: () => {
+                    this.CONSUME(RdfToken.LPARENT);
+                    this.SUBRULE(this.expression);
+                    this.CONSUME(RdfToken.AS_KW);
+                    this.SUBRULE2(this.var);
+                    this.CONSUME(RdfToken.RPARENT);
+                  }
+                }
+              ]);
+            });
+          }
+        },
+        { ALT: () => this.CONSUME(RdfToken.STAR) }
+      ]);
+    }));
+    /**
+     * [12] ConstructQuery ::= 'CONSTRUCT' (ConstructTemplate DatasetClause* WhereClause SolutionModifier
+     *                       | DatasetClause* 'WHERE' '{' TriplesTemplate? '}' SolutionModifier)
+     */
+    __publicField(this, "constructQuery", this.RULE("constructQuery", () => {
+      this.CONSUME(RdfToken.CONSTRUCT);
+      this.OR([
+        {
+          ALT: () => {
+            this.SUBRULE(this.constructTemplate);
+            this.MANY1(() => this.SUBRULE1(this.datasetClause));
+            this.SUBRULE1(this.whereClause);
+            this.SUBRULE1(this.solutionModifier);
+          }
+        },
+        {
+          ALT: () => {
+            this.MANY2(() => this.SUBRULE2(this.datasetClause));
+            this.CONSUME(RdfToken.WHERE);
+            this.CONSUME(RdfToken.LCURLY);
+            this.OPTION(() => this.SUBRULE(this.triplesTemplate));
+            this.CONSUME(RdfToken.RCURLY);
+            this.SUBRULE2(this.solutionModifier);
+          }
+        }
+      ]);
+    }));
+    /**
+     * [13] DescribeQuery ::= 'DESCRIBE' (VarOrIri+ | '*') DatasetClause* WhereClause? SolutionModifier
+     */
+    __publicField(this, "describeQuery", this.RULE("describeQuery", () => {
+      this.CONSUME(RdfToken.DESCRIBE);
+      this.OR([
+        { ALT: () => this.AT_LEAST_ONE(() => this.SUBRULE(this.varOrIri)) },
+        { ALT: () => this.CONSUME(RdfToken.STAR) }
+      ]);
+      this.MANY(() => this.SUBRULE(this.datasetClause));
+      this.OPTION(() => this.SUBRULE(this.whereClause));
+      this.SUBRULE(this.solutionModifier);
+    }));
+    /**
+     * [14] AskQuery ::= 'ASK' DatasetClause* WhereClause SolutionModifier
+     */
+    __publicField(this, "askQuery", this.RULE("askQuery", () => {
+      this.CONSUME(RdfToken.ASK);
+      this.MANY(() => this.SUBRULE(this.datasetClause));
+      this.SUBRULE(this.whereClause);
+      this.SUBRULE(this.solutionModifier);
+    }));
+    /**
+     * [15] DatasetClause ::= 'FROM' (DefaultGraphClause | NamedGraphClause)
+     */
+    __publicField(this, "datasetClause", this.RULE("datasetClause", () => {
+      this.CONSUME(RdfToken.FROM);
+      this.OR([
+        { ALT: () => this.SUBRULE(this.defaultGraphClause) },
+        { ALT: () => this.SUBRULE(this.namedGraphClause) }
+      ]);
+    }));
+    /**
+     * [16] DefaultGraphClause ::= SourceSelector
+     */
+    __publicField(this, "defaultGraphClause", this.RULE("defaultGraphClause", () => {
+      this.SUBRULE(this.sourceSelector);
+    }));
+    /**
+     * [17] NamedGraphClause ::= 'NAMED' SourceSelector
+     */
+    __publicField(this, "namedGraphClause", this.RULE("namedGraphClause", () => {
+      this.CONSUME(RdfToken.NAMED);
+      this.SUBRULE(this.sourceSelector);
+    }));
+    /**
+     * [18] SourceSelector ::= iri
+     */
+    __publicField(this, "sourceSelector", this.RULE("sourceSelector", () => {
+      this.SUBRULE(this.iri);
+    }));
+    /**
+     * [19] WhereClause ::= 'WHERE'? GroupGraphPattern
+     */
+    __publicField(this, "whereClause", this.RULE("whereClause", () => {
+      this.OPTION(() => this.CONSUME(RdfToken.WHERE));
+      this.SUBRULE(this.groupGraphPattern);
+    }));
+    /**
+     * [20] SolutionModifier ::= GroupClause? HavingClause? OrderClause? LimitOffsetClauses?
+     */
+    __publicField(this, "solutionModifier", this.RULE("solutionModifier", () => {
+      this.OPTION1(() => this.SUBRULE(this.groupClause));
+      this.OPTION2(() => this.SUBRULE(this.havingClause));
+      this.OPTION3(() => this.SUBRULE(this.orderClause));
+      this.OPTION4(() => this.SUBRULE(this.limitOffsetClauses));
+    }));
+    /**
+     * [21] GroupClause ::= 'GROUP' 'BY' GroupCondition+
+     */
+    __publicField(this, "groupClause", this.RULE("groupClause", () => {
+      this.CONSUME(RdfToken.GROUP);
+      this.CONSUME(RdfToken.BY);
+      this.AT_LEAST_ONE(() => this.SUBRULE(this.groupCondition));
+    }));
+    /**
+     * [22] GroupCondition ::= BuiltInCall | FunctionCall | '(' Expression ('AS' Var)? ')' | Var
+     */
+    __publicField(this, "groupCondition", this.RULE("groupCondition", () => {
+      this.OR([
+        { ALT: () => this.SUBRULE(this.builtInCall) },
+        { ALT: () => this.SUBRULE(this.functionCall) },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.LPARENT);
+            this.SUBRULE(this.expression);
+            this.OPTION(() => {
+              this.CONSUME(RdfToken.AS_KW);
+              this.SUBRULE(this.var);
+            });
+            this.CONSUME(RdfToken.RPARENT);
+          }
+        },
+        { ALT: () => this.SUBRULE2(this.var) }
+      ]);
+    }));
+    /**
+     * [23] HavingClause ::= 'HAVING' HavingCondition+
+     */
+    __publicField(this, "havingClause", this.RULE("havingClause", () => {
+      this.CONSUME(RdfToken.HAVING);
+      this.AT_LEAST_ONE(() => this.SUBRULE(this.havingCondition));
+    }));
+    /**
+     * [24] HavingCondition ::= Constraint
+     */
+    __publicField(this, "havingCondition", this.RULE("havingCondition", () => {
+      this.SUBRULE(this.constraint);
+    }));
+    /**
+     * [25] OrderClause ::= 'ORDER' 'BY' OrderCondition+
+     */
+    __publicField(this, "orderClause", this.RULE("orderClause", () => {
+      this.CONSUME(RdfToken.ORDER);
+      this.CONSUME(RdfToken.BY);
+      this.AT_LEAST_ONE(() => this.SUBRULE(this.orderCondition));
+    }));
+    /**
+     * [26] OrderCondition ::= (('ASC' | 'DESC') BrackettedExpression) | (Constraint | Var)
+     */
+    __publicField(this, "orderCondition", this.RULE("orderCondition", () => {
+      this.OR([
+        {
+          ALT: () => {
+            this.OR2([
+              { ALT: () => this.CONSUME(RdfToken.ASC_KW) },
+              { ALT: () => this.CONSUME(RdfToken.DESC_KW) }
+            ]);
+            this.SUBRULE(this.brackettedExpression);
+          }
+        },
+        { ALT: () => this.SUBRULE(this.constraint) },
+        { ALT: () => this.SUBRULE(this.var) }
+      ]);
+    }));
+    /**
+     * [27] LimitOffsetClauses ::= LimitClause OffsetClause? | OffsetClause LimitClause?
+     */
+    __publicField(this, "limitOffsetClauses", this.RULE("limitOffsetClauses", () => {
+      this.OR([
+        {
+          ALT: () => {
+            this.SUBRULE1(this.limitClause);
+            this.OPTION1(() => this.SUBRULE1(this.offsetClause));
+          }
+        },
+        {
+          ALT: () => {
+            this.SUBRULE2(this.offsetClause);
+            this.OPTION2(() => this.SUBRULE2(this.limitClause));
+          }
+        }
+      ]);
+    }));
+    /**
+     * [28] LimitClause ::= 'LIMIT' INTEGER
+     */
+    __publicField(this, "limitClause", this.RULE("limitClause", () => {
+      this.CONSUME(RdfToken.LIMIT);
+      this.CONSUME(RdfToken.INTEGER);
+    }));
+    /**
+     * [29] OffsetClause ::= 'OFFSET' INTEGER
+     */
+    __publicField(this, "offsetClause", this.RULE("offsetClause", () => {
+      this.CONSUME(RdfToken.OFFSET);
+      this.CONSUME(RdfToken.INTEGER);
+    }));
+    // ==========================================
+    // Update productions [30]-[49]
+    // ==========================================
+    /**
+     * [31] Update ::= Prologue (Update1 (';' Update)? )?
+     * Note: Prologue is factored out into queryOrUpdate.
+     */
+    __publicField(this, "update", this.RULE("update", () => {
+      this.SUBRULE(this.prologue);
+      this.SUBRULE(this.updateBody);
+    }));
+    /**
+     * Update body after prologue: (Update1 (';' Update)?)?
+     */
+    __publicField(this, "updateBody", this.RULE("updateBody", () => {
+      this.OPTION(() => {
+        this.SUBRULE(this.update1);
+        this.OPTION2(() => {
+          this.CONSUME(RdfToken.SEMICOLON);
+          this.SUBRULE(this.update);
+        });
+      });
+    }));
+    /**
+     * [32] Update1 ::= Load | Clear | Drop | Add | Move | Copy | Create | InsertData | DeleteData | DeleteWhere | Modify
+     */
+    __publicField(this, "update1", this.RULE("update1", () => {
+      this.OR([
+        { ALT: () => this.SUBRULE(this.load) },
+        { ALT: () => this.SUBRULE(this.clear) },
+        { ALT: () => this.SUBRULE(this.drop) },
+        { ALT: () => this.SUBRULE(this.add) },
+        { ALT: () => this.SUBRULE(this.move) },
+        { ALT: () => this.SUBRULE(this.copy) },
+        { ALT: () => this.SUBRULE(this.create) },
+        { ALT: () => this.SUBRULE(this.insertData) },
+        { ALT: () => this.SUBRULE(this.deleteData) },
+        { ALT: () => this.SUBRULE(this.deleteWhere) },
+        { ALT: () => this.SUBRULE(this.modify) }
+      ]);
+    }));
+    /**
+     * [33] Load ::= 'LOAD' 'SILENT'? iri ('INTO' GraphRef)?
+     */
+    __publicField(this, "load", this.RULE("load", () => {
+      this.CONSUME(RdfToken.LOAD);
+      this.OPTION1(() => this.CONSUME(RdfToken.SILENT));
+      this.SUBRULE(this.iri);
+      this.OPTION2(() => {
+        this.CONSUME(RdfToken.INTO);
+        this.SUBRULE(this.graphRef);
+      });
+    }));
+    /**
+     * [34] Clear ::= 'CLEAR' 'SILENT'? GraphRefAll
+     */
+    __publicField(this, "clear", this.RULE("clear", () => {
+      this.CONSUME(RdfToken.CLEAR);
+      this.OPTION(() => this.CONSUME(RdfToken.SILENT));
+      this.SUBRULE(this.graphRefAll);
+    }));
+    /**
+     * [35] Drop ::= 'DROP' 'SILENT'? GraphRefAll
+     */
+    __publicField(this, "drop", this.RULE("drop", () => {
+      this.CONSUME(RdfToken.DROP);
+      this.OPTION(() => this.CONSUME(RdfToken.SILENT));
+      this.SUBRULE(this.graphRefAll);
+    }));
+    /**
+     * [36] Create ::= 'CREATE' 'SILENT'? GraphRef
+     */
+    __publicField(this, "create", this.RULE("create", () => {
+      this.CONSUME(RdfToken.CREATE_KW);
+      this.OPTION(() => this.CONSUME(RdfToken.SILENT));
+      this.SUBRULE(this.graphRef);
+    }));
+    /**
+     * [37] Add ::= 'ADD' 'SILENT'? GraphOrDefault 'TO' GraphOrDefault
+     */
+    __publicField(this, "add", this.RULE("add", () => {
+      this.CONSUME(RdfToken.ADD_KW);
+      this.OPTION(() => this.CONSUME(RdfToken.SILENT));
+      this.SUBRULE1(this.graphOrDefault);
+      this.CONSUME(RdfToken.TO);
+      this.SUBRULE2(this.graphOrDefault);
+    }));
+    /**
+     * [38] Move ::= 'MOVE' 'SILENT'? GraphOrDefault 'TO' GraphOrDefault
+     */
+    __publicField(this, "move", this.RULE("move", () => {
+      this.CONSUME(RdfToken.MOVE);
+      this.OPTION(() => this.CONSUME(RdfToken.SILENT));
+      this.SUBRULE1(this.graphOrDefault);
+      this.CONSUME(RdfToken.TO);
+      this.SUBRULE2(this.graphOrDefault);
+    }));
+    /**
+     * [39] Copy ::= 'COPY' 'SILENT'? GraphOrDefault 'TO' GraphOrDefault
+     */
+    __publicField(this, "copy", this.RULE("copy", () => {
+      this.CONSUME(RdfToken.COPY);
+      this.OPTION(() => this.CONSUME(RdfToken.SILENT));
+      this.SUBRULE1(this.graphOrDefault);
+      this.CONSUME(RdfToken.TO);
+      this.SUBRULE2(this.graphOrDefault);
+    }));
+    /**
+     * [40] InsertData ::= 'INSERT' 'DATA' QuadData
+     */
+    __publicField(this, "insertData", this.RULE("insertData", () => {
+      this.CONSUME(RdfToken.INSERT);
+      this.CONSUME(RdfToken.DATA);
+      this.SUBRULE(this.quadData);
+    }));
+    /**
+     * [41] DeleteData ::= 'DELETE' 'DATA' QuadData
+     */
+    __publicField(this, "deleteData", this.RULE("deleteData", () => {
+      this.CONSUME(RdfToken.DELETE_KW);
+      this.CONSUME(RdfToken.DATA);
+      const prev = this._insideDeleteBlock;
+      this._insideDeleteBlock = true;
+      this.SUBRULE(this.quadData);
+      this._insideDeleteBlock = prev;
+    }));
+    /**
+     * [42] DeleteWhere ::= 'DELETE' 'WHERE' QuadPattern
+     */
+    __publicField(this, "deleteWhere", this.RULE("deleteWhere", () => {
+      this.CONSUME(RdfToken.DELETE_KW);
+      this.CONSUME(RdfToken.WHERE);
+      const prev = this._insideDeleteBlock;
+      this._insideDeleteBlock = true;
+      this.SUBRULE(this.quadPattern);
+      this._insideDeleteBlock = prev;
+    }));
+    /**
+     * [43] Modify ::= ('WITH' iri)? (DeleteClause InsertClause? | InsertClause) UsingClause* 'WHERE' GroupGraphPattern
+     */
+    __publicField(this, "modify", this.RULE("modify", () => {
+      this.OPTION1(() => {
+        this.CONSUME(RdfToken.WITH_KW);
+        this.SUBRULE1(this.iri);
+      });
+      this.OR([
+        {
+          ALT: () => {
+            this.SUBRULE(this.deleteClause);
+            this.OPTION2(() => this.SUBRULE1(this.insertClause));
+          }
+        },
+        { ALT: () => this.SUBRULE2(this.insertClause) }
+      ]);
+      this.MANY(() => this.SUBRULE(this.usingClause));
+      this.CONSUME(RdfToken.WHERE);
+      this.SUBRULE(this.groupGraphPattern);
+    }));
+    /**
+     * [44] DeleteClause ::= 'DELETE' QuadPattern
+     */
+    __publicField(this, "deleteClause", this.RULE("deleteClause", () => {
+      this.CONSUME(RdfToken.DELETE_KW);
+      const prev = this._insideDeleteBlock;
+      this._insideDeleteBlock = true;
+      this.SUBRULE(this.quadPattern);
+      this._insideDeleteBlock = prev;
+    }));
+    /**
+     * [45] InsertClause ::= 'INSERT' QuadPattern
+     */
+    __publicField(this, "insertClause", this.RULE("insertClause", () => {
+      this.CONSUME(RdfToken.INSERT);
+      this.SUBRULE(this.quadPattern);
+    }));
+    /**
+     * [46] UsingClause ::= 'USING' (iri | 'NAMED' iri)
+     */
+    __publicField(this, "usingClause", this.RULE("usingClause", () => {
+      this.CONSUME(RdfToken.USING);
+      this.OR([
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.NAMED);
+            this.SUBRULE1(this.iri);
+          }
+        },
+        { ALT: () => this.SUBRULE2(this.iri) }
+      ]);
+    }));
+    /**
+     * [47] GraphOrDefault ::= 'DEFAULT' | 'GRAPH'? iri
+     */
+    __publicField(this, "graphOrDefault", this.RULE("graphOrDefault", () => {
+      this.OR([
+        { ALT: () => this.CONSUME(RdfToken.DEFAULT_KW) },
+        {
+          ALT: () => {
+            this.OPTION(() => this.CONSUME(RdfToken.GRAPH));
+            this.SUBRULE(this.iri);
+          }
+        }
+      ]);
+    }));
+    /**
+     * [48] GraphRef ::= 'GRAPH' iri
+     */
+    __publicField(this, "graphRef", this.RULE("graphRef", () => {
+      this.CONSUME(RdfToken.GRAPH);
+      this.SUBRULE(this.iri);
+    }));
+    /**
+     * [49] GraphRefAll ::= GraphRef | 'DEFAULT' | 'NAMED' | 'ALL'
+     */
+    __publicField(this, "graphRefAll", this.RULE("graphRefAll", () => {
+      this.OR([
+        { ALT: () => this.SUBRULE(this.graphRef) },
+        { ALT: () => this.CONSUME(RdfToken.DEFAULT_KW) },
+        { ALT: () => this.CONSUME(RdfToken.NAMED) },
+        { ALT: () => this.CONSUME(RdfToken.ALL_KW) }
+      ]);
+    }));
+    // ==========================================
+    // Quad productions [50]-[54]
+    // ==========================================
+    /**
+     * [50] QuadPattern ::= '{' Quads '}'
+     */
+    __publicField(this, "quadPattern", this.RULE("quadPattern", () => {
+      this.CONSUME(RdfToken.LCURLY);
+      this.SUBRULE(this.quads);
+      this.CONSUME(RdfToken.RCURLY);
+    }));
+    /**
+     * [51] QuadData ::= '{' Quads '}'
+     */
+    __publicField(this, "quadData", this.RULE("quadData", () => {
+      this.CONSUME(RdfToken.LCURLY);
+      this.SUBRULE(this.quads);
+      this.CONSUME(RdfToken.RCURLY);
+    }));
+    /**
+     * [52] Quads ::= TriplesTemplate? (QuadsNotTriples '.'? TriplesTemplate?)*
+     */
+    __publicField(this, "quads", this.RULE("quads", () => {
+      this.OPTION1(() => this.SUBRULE1(this.triplesTemplate));
+      this.MANY(() => {
+        this.SUBRULE(this.quadsNotTriples);
+        this.OPTION2(() => this.CONSUME(RdfToken.PERIOD));
+        this.OPTION3(() => this.SUBRULE2(this.triplesTemplate));
+      });
+    }));
+    /**
+     * [53] QuadsNotTriples ::= 'GRAPH' VarOrIri '{' TriplesTemplate? '}'
+     */
+    __publicField(this, "quadsNotTriples", this.RULE("quadsNotTriples", () => {
+      this.CONSUME(RdfToken.GRAPH);
+      this.SUBRULE(this.varOrIri);
+      this.CONSUME(RdfToken.LCURLY);
+      this.OPTION(() => this.SUBRULE(this.triplesTemplate));
+      this.CONSUME(RdfToken.RCURLY);
+    }));
+    /**
+     * [54] TriplesTemplate ::= TriplesSameSubject ('.' TriplesTemplate?)?
+     */
+    __publicField(this, "triplesTemplate", this.RULE("triplesTemplate", () => {
+      this.SUBRULE(this.triplesSameSubject);
+      this.OPTION(() => {
+        this.CONSUME(RdfToken.PERIOD);
+        this.OPTION2(() => this.SUBRULE(this.triplesTemplate));
+      });
+    }));
+    // ==========================================
+    // Graph pattern productions [55]-[73]
+    // ==========================================
+    /**
+     * [55] GroupGraphPattern ::= '{' (SubSelect | GroupGraphPatternSub) '}'
+     */
+    __publicField(this, "groupGraphPattern", this.RULE("groupGraphPattern", () => {
+      this.CONSUME(RdfToken.LCURLY);
+      this.OR([
+        { ALT: () => this.SUBRULE(this.subSelect) },
+        { ALT: () => this.SUBRULE(this.groupGraphPatternSub) }
+      ]);
+      this.CONSUME(RdfToken.RCURLY);
+    }));
+    /**
+     * [56] GroupGraphPatternSub ::= TriplesBlock? (GraphPatternNotTriples '.'? TriplesBlock?)*
+     */
+    __publicField(this, "groupGraphPatternSub", this.RULE("groupGraphPatternSub", () => {
+      this.OPTION1(() => this.SUBRULE1(this.triplesBlock));
+      this.MANY(() => {
+        this.SUBRULE(this.graphPatternNotTriples);
+        this.OPTION2(() => this.CONSUME(RdfToken.PERIOD));
+        this.OPTION3(() => this.SUBRULE2(this.triplesBlock));
+      });
+    }));
+    /**
+     * [57] TriplesBlock ::= TriplesSameSubjectPath ('.' TriplesBlock?)?
+     */
+    __publicField(this, "triplesBlock", this.RULE("triplesBlock", () => {
+      this.SUBRULE(this.triplesSameSubjectPath);
+      this.OPTION(() => {
+        this.CONSUME(RdfToken.PERIOD);
+        this.OPTION2(() => this.SUBRULE(this.triplesBlock));
+      });
+    }));
+    /**
+     * [58] GraphPatternNotTriples ::= GroupOrUnionGraphPattern | OptionalGraphPattern
+     *     | MinusGraphPattern | GraphGraphPattern | ServiceGraphPattern | Filter | Bind | InlineData
+     *     | ReifiedTripleBlockPath
+     */
+    __publicField(this, "graphPatternNotTriples", this.RULE("graphPatternNotTriples", () => {
+      this.OR([
+        { ALT: () => this.SUBRULE(this.groupOrUnionGraphPattern) },
+        { ALT: () => this.SUBRULE(this.optionalGraphPattern) },
+        { ALT: () => this.SUBRULE(this.minusGraphPattern) },
+        { ALT: () => this.SUBRULE(this.graphGraphPattern) },
+        { ALT: () => this.SUBRULE(this.serviceGraphPattern) },
+        { ALT: () => this.SUBRULE(this.filter) },
+        { ALT: () => this.SUBRULE(this.bind) },
+        { ALT: () => this.SUBRULE(this.inlineData) },
+        { ALT: () => this.SUBRULE(this.reifiedTripleBlockPath) }
+      ]);
+    }));
+    /**
+     * [59] ReifiedTripleBlockPath ::= ReifiedTriple PropertyListPath
+     */
+    __publicField(this, "reifiedTripleBlockPath", this.RULE("reifiedTripleBlockPath", () => {
+      this.SUBRULE(this.reifiedTriple);
+      this.SUBRULE(this.propertyListPath);
+    }));
+    /**
+     * [60] OptionalGraphPattern ::= 'OPTIONAL' GroupGraphPattern
+     */
+    __publicField(this, "optionalGraphPattern", this.RULE("optionalGraphPattern", () => {
+      this.CONSUME(RdfToken.OPTIONAL_KW);
+      this.SUBRULE(this.groupGraphPattern);
+    }));
+    /**
+     * [61] GraphGraphPattern ::= 'GRAPH' VarOrIri GroupGraphPattern
+     */
+    __publicField(this, "graphGraphPattern", this.RULE("graphGraphPattern", () => {
+      this.CONSUME(RdfToken.GRAPH);
+      this.SUBRULE(this.varOrIri);
+      this.SUBRULE(this.groupGraphPattern);
+    }));
+    /**
+     * [62] ServiceGraphPattern ::= 'SERVICE' 'SILENT'? VarOrIri GroupGraphPattern
+     */
+    __publicField(this, "serviceGraphPattern", this.RULE("serviceGraphPattern", () => {
+      this.CONSUME(RdfToken.SERVICE);
+      this.OPTION(() => this.CONSUME(RdfToken.SILENT));
+      this.SUBRULE(this.varOrIri);
+      this.SUBRULE(this.groupGraphPattern);
+    }));
+    /**
+     * [63] Bind ::= 'BIND' '(' Expression 'AS' Var ')'
+     */
+    __publicField(this, "bind", this.RULE("bind", () => {
+      this.CONSUME(RdfToken.BIND_KW);
+      this.CONSUME(RdfToken.LPARENT);
+      this.SUBRULE(this.expression);
+      this.CONSUME(RdfToken.AS_KW);
+      this.SUBRULE(this.var);
+      this.CONSUME(RdfToken.RPARENT);
+    }));
+    /**
+     * [64] InlineData ::= 'VALUES' DataBlock
+     */
+    __publicField(this, "inlineData", this.RULE("inlineData", () => {
+      this.CONSUME(RdfToken.VALUES);
+      this.SUBRULE(this.dataBlock);
+    }));
+    /**
+     * [65] DataBlock ::= InlineDataOneVar | InlineDataFull
+     */
+    __publicField(this, "dataBlock", this.RULE("dataBlock", () => {
+      this.OR([
+        { ALT: () => this.SUBRULE(this.inlineDataOneVar) },
+        { ALT: () => this.SUBRULE(this.inlineDataFull) }
+      ]);
+    }));
+    /**
+     * [66] InlineDataOneVar ::= Var '{' DataBlockValue* '}'
+     */
+    __publicField(this, "inlineDataOneVar", this.RULE("inlineDataOneVar", () => {
+      this.SUBRULE(this.var);
+      this.CONSUME(RdfToken.LCURLY);
+      this.MANY(() => this.SUBRULE(this.dataBlockValue));
+      this.CONSUME(RdfToken.RCURLY);
+    }));
+    /**
+     * [67] InlineDataFull ::= (NIL | '(' Var* ')') '{' ('(' DataBlockValue* ')' | NIL)* '}'
+     */
+    __publicField(this, "inlineDataFull", this.RULE("inlineDataFull", () => {
+      this.OR1([
+        { ALT: () => this.CONSUME1(RdfToken.NIL) },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.LPARENT);
+            this.MANY1(() => this.SUBRULE(this.var));
+            this.CONSUME(RdfToken.RPARENT);
+          }
+        }
+      ]);
+      this.CONSUME(RdfToken.LCURLY);
+      this.MANY2(() => {
+        this.OR2([
+          {
+            ALT: () => {
+              this.CONSUME2(RdfToken.LPARENT);
+              this.MANY3(() => this.SUBRULE(this.dataBlockValue));
+              this.CONSUME2(RdfToken.RPARENT);
+            }
+          },
+          { ALT: () => this.CONSUME2(RdfToken.NIL) }
+        ]);
+      });
+      this.CONSUME(RdfToken.RCURLY);
+    }));
+    /**
+     * [68] DataBlockValue ::= iri | RDFLiteral | NumericLiteral | BooleanLiteral | 'UNDEF' | TripleTermData
+     */
+    __publicField(this, "dataBlockValue", this.RULE("dataBlockValue", () => {
+      this.OR([
+        { ALT: () => this.SUBRULE(this.iri) },
+        { ALT: () => this.SUBRULE(this.rdfLiteral) },
+        { ALT: () => this.SUBRULE(this.numericLiteral) },
+        { ALT: () => this.SUBRULE(this.booleanLiteral) },
+        { ALT: () => this.CONSUME(RdfToken.UNDEF) },
+        { ALT: () => this.SUBRULE(this.tripleTermData) }
+      ]);
+    }));
+    /**
+     * [69] MinusGraphPattern ::= 'MINUS' GroupGraphPattern
+     */
+    __publicField(this, "minusGraphPattern", this.RULE("minusGraphPattern", () => {
+      this.CONSUME(RdfToken.MINUS_KW);
+      this.SUBRULE(this.groupGraphPattern);
+    }));
+    /**
+     * [70] GroupOrUnionGraphPattern ::= GroupGraphPattern ('UNION' GroupGraphPattern)*
+     */
+    __publicField(this, "groupOrUnionGraphPattern", this.RULE("groupOrUnionGraphPattern", () => {
+      this.SUBRULE1(this.groupGraphPattern);
+      this.MANY(() => {
+        this.CONSUME(RdfToken.UNION);
+        this.SUBRULE2(this.groupGraphPattern);
+      });
+    }));
+    /**
+     * [71] Filter ::= 'FILTER' Constraint
+     */
+    __publicField(this, "filter", this.RULE("filter", () => {
+      this.CONSUME(RdfToken.FILTER);
+      this.SUBRULE(this.constraint);
+    }));
+    /**
+     * [72] Constraint ::= BrackettedExpression | BuiltInCall | FunctionCall
+     */
+    __publicField(this, "constraint", this.RULE("constraint", () => {
+      this.OR([
+        { ALT: () => this.SUBRULE(this.brackettedExpression) },
+        { ALT: () => this.SUBRULE(this.builtInCall) },
+        { ALT: () => this.SUBRULE(this.functionCall) }
+      ]);
+    }));
+    /**
+     * [73] FunctionCall ::= iri ArgList
+     */
+    __publicField(this, "functionCall", this.RULE("functionCall", () => {
+      this.SUBRULE(this.iri);
+      this.SUBRULE(this.argList);
+    }));
+    // ==========================================
+    // ArgList / ExpressionList [74]-[75]
+    // ==========================================
+    /**
+     * [74] ArgList ::= NIL | '(' 'DISTINCT'? Expression (',' Expression)* ')'
+     */
+    __publicField(this, "argList", this.RULE("argList", () => {
+      this.OR([
+        { ALT: () => this.CONSUME(RdfToken.NIL) },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.LPARENT);
+            this.OPTION(() => this.CONSUME(RdfToken.DISTINCT));
+            this.SUBRULE1(this.expression);
+            this.MANY(() => {
+              this.CONSUME(RdfToken.COMMA);
+              this.SUBRULE2(this.expression);
+            });
+            this.CONSUME(RdfToken.RPARENT);
+          }
+        }
+      ]);
+    }));
+    /**
+     * [75] ExpressionList ::= NIL | '(' Expression (',' Expression)* ')'
+     */
+    __publicField(this, "expressionList", this.RULE("expressionList", () => {
+      this.OR([
+        { ALT: () => this.CONSUME(RdfToken.NIL) },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.LPARENT);
+            this.SUBRULE1(this.expression);
+            this.MANY(() => {
+              this.CONSUME(RdfToken.COMMA);
+              this.SUBRULE2(this.expression);
+            });
+            this.CONSUME(RdfToken.RPARENT);
+          }
+        }
+      ]);
+    }));
+    // ==========================================
+    // Construct template [76]-[77]
+    // ==========================================
+    /**
+     * [76] ConstructTemplate ::= '{' ConstructTriples? '}'
+     */
+    __publicField(this, "constructTemplate", this.RULE("constructTemplate", () => {
+      this.CONSUME(RdfToken.LCURLY);
+      this.OPTION(() => this.SUBRULE(this.constructTriples));
+      this.CONSUME(RdfToken.RCURLY);
+    }));
+    /**
+     * [77] ConstructTriples ::= TriplesSameSubject ('.' ConstructTriples?)?
+     */
+    __publicField(this, "constructTriples", this.RULE("constructTriples", () => {
+      this.SUBRULE(this.triplesSameSubject);
+      this.OPTION(() => {
+        this.CONSUME(RdfToken.PERIOD);
+        this.OPTION2(() => this.SUBRULE(this.constructTriples));
+      });
+    }));
+    // ==========================================
+    // Triple productions [78]-[93]
+    // ==========================================
+    /**
+     * [78] TriplesSameSubject ::= VarOrTerm PropertyListNotEmpty | TriplesNode PropertyList | ReifiedTripleBlock
+     */
+    __publicField(this, "triplesSameSubject", this.RULE("triplesSameSubject", () => {
+      this.OR([
+        {
+          ALT: () => {
+            this.SUBRULE(this.varOrTerm);
+            this.SUBRULE(this.propertyListNotEmpty);
+          }
+        },
+        {
+          ALT: () => {
+            this.SUBRULE(this.triplesNode);
+            this.SUBRULE(this.propertyList);
+          }
+        },
+        { ALT: () => this.SUBRULE(this.reifiedTripleBlock) }
+      ]);
+    }));
+    /**
+     * [79] PropertyList ::= PropertyListNotEmpty?
+     */
+    __publicField(this, "propertyList", this.RULE("propertyList", () => {
+      this.OPTION(() => this.SUBRULE(this.propertyListNotEmpty));
+    }));
+    /**
+     * [80] PropertyListNotEmpty ::= Verb ObjectList (';' (Verb ObjectList)?)*
+     */
+    __publicField(this, "propertyListNotEmpty", this.RULE("propertyListNotEmpty", () => {
+      this.SUBRULE1(this.verb);
+      this.SUBRULE1(this.objectList);
+      this.MANY(() => {
+        this.CONSUME(RdfToken.SEMICOLON);
+        this.OPTION(() => {
+          this.SUBRULE2(this.verb);
+          this.SUBRULE2(this.objectList);
+        });
+      });
+    }));
+    /**
+     * [81] Verb ::= VarOrIri | 'a'
+     */
+    __publicField(this, "verb", this.RULE("verb", () => {
+      this.OR([
+        { ALT: () => this.SUBRULE(this.varOrIri) },
+        { ALT: () => this.CONSUME(RdfToken.A) }
+      ]);
+    }));
+    /**
+     * [85] ObjectList ::= Object (',' Object)*
+     */
+    __publicField(this, "objectList", this.RULE("objectList", () => {
+      this.SUBRULE1(this.graphObject);
+      this.MANY(() => {
+        this.CONSUME(RdfToken.COMMA);
+        this.SUBRULE2(this.graphObject);
+      });
+    }));
+    /**
+     * [86] Object ::= GraphNode Annotation
+     */
+    __publicField(this, "graphObject", this.RULE("graphObject", () => {
+      this.SUBRULE(this.graphNode);
+      this.SUBRULE(this.annotation);
+    }));
+    /**
+     * [84] TriplesSameSubjectPath ::= VarOrTerm PropertyListPathNotEmpty | TriplesNodePath PropertyListPath | ReifiedTripleBlockPath
+     */
+    __publicField(this, "triplesSameSubjectPath", this.RULE("triplesSameSubjectPath", () => {
+      this.OR([
+        {
+          ALT: () => {
+            this.SUBRULE(this.varOrTerm);
+            this.SUBRULE(this.propertyListPathNotEmpty);
+          }
+        },
+        {
+          ALT: () => {
+            this.SUBRULE(this.triplesNodePath);
+            this.SUBRULE(this.propertyListPath);
+          }
+        },
+        { ALT: () => this.SUBRULE(this.reifiedTripleBlockPath) }
+      ]);
+    }));
+    /**
+     * [85] PropertyListPath ::= PropertyListPathNotEmpty?
+     */
+    __publicField(this, "propertyListPath", this.RULE("propertyListPath", () => {
+      this.OPTION(() => this.SUBRULE(this.propertyListPathNotEmpty));
+    }));
+    /**
+     * [86] PropertyListPathNotEmpty ::= (VerbPath | VerbSimple) ObjectListPath (';' ((VerbPath | VerbSimple) ObjectListPath)?)*
+     *
+     * Per spec note 16: annotations and reifiers are only permitted when the
+     * predicate is a simple path (IRI, 'a', or variable). Inside annotation
+     * blocks, complex paths in verb position produce an error after parsing.
+     */
+    __publicField(this, "propertyListPathNotEmpty", this.RULE("propertyListPathNotEmpty", () => {
+      this._verbIsSimplePath = true;
+      this.OR1([
+        { ALT: () => this.SUBRULE1(this.verbPath) },
+        { ALT: () => this.SUBRULE1(this.verbSimple) }
+      ]);
+      this.SUBRULE1(this.objectListPath);
+      this.MANY(() => {
+        this.CONSUME(RdfToken.SEMICOLON);
+        this.OPTION(() => {
+          this._verbIsSimplePath = true;
+          this.OR2([
+            { ALT: () => this.SUBRULE2(this.verbPath) },
+            { ALT: () => this.SUBRULE2(this.verbSimple) }
+          ]);
+          this.SUBRULE2(this.objectListPath);
+        });
+      });
+    }));
+    /**
+     * [87] VerbPath ::= Path
+     */
+    __publicField(this, "verbPath", this.RULE("verbPath", () => {
+      this.SUBRULE(this.path);
+    }));
+    /**
+     * [88] VerbSimple ::= Var
+     */
+    __publicField(this, "verbSimple", this.RULE("verbSimple", () => {
+      this.SUBRULE(this.var);
+    }));
+    /**
+     * [92] ObjectListPath ::= ObjectPath (',' ObjectPath)*
+     */
+    __publicField(this, "objectListPath", this.RULE("objectListPath", () => {
+      this.SUBRULE1(this.objectPath);
+      this.MANY(() => {
+        this.CONSUME(RdfToken.COMMA);
+        this.SUBRULE2(this.objectPath);
+      });
+    }));
+    /**
+     * [93] ObjectPath ::= GraphNodePath AnnotationPath
+     */
+    __publicField(this, "objectPath", this.RULE("objectPath", () => {
+      this.SUBRULE(this.graphNodePath);
+      this.SUBRULE(this.annotationPath);
+    }));
+    // ==========================================
+    // Property path productions [91]-[99]
+    // ==========================================
+    /**
+     * [91] Path ::= PathAlternative
+     */
+    __publicField(this, "path", this.RULE("path", () => {
+      this.SUBRULE(this.pathAlternative);
+    }));
+    /**
+     * [92] PathAlternative ::= PathSequence ('|' PathSequence)*
+     */
+    __publicField(this, "pathAlternative", this.RULE("pathAlternative", () => {
+      this.SUBRULE1(this.pathSequence);
+      this.MANY(() => {
+        this._verbIsSimplePath = false;
+        this.CONSUME(RdfToken.PIPE);
+        this.SUBRULE2(this.pathSequence);
+      });
+    }));
+    /**
+     * [93] PathSequence ::= PathEltOrInverse ('/' PathEltOrInverse)*
+     */
+    __publicField(this, "pathSequence", this.RULE("pathSequence", () => {
+      this.SUBRULE1(this.pathEltOrInverse);
+      this.MANY(() => {
+        this._verbIsSimplePath = false;
+        this.CONSUME(RdfToken.SLASH);
+        this.SUBRULE2(this.pathEltOrInverse);
+      });
+    }));
+    /**
+     * [94] PathElt ::= PathPrimary PathMod?
+     */
+    __publicField(this, "pathElt", this.RULE("pathElt", () => {
+      this.SUBRULE(this.pathPrimary);
+      this.OPTION(() => this.SUBRULE(this.pathMod));
+    }));
+    /**
+     * [95] PathEltOrInverse ::= PathElt | '^' PathElt
+     */
+    __publicField(this, "pathEltOrInverse", this.RULE("pathEltOrInverse", () => {
+      this.OR([
+        { ALT: () => this.SUBRULE1(this.pathElt) },
+        {
+          ALT: () => {
+            this._verbIsSimplePath = false;
+            this.CONSUME(RdfToken.CARET);
+            this.SUBRULE2(this.pathElt);
+          }
+        }
+      ]);
+    }));
+    /**
+     * [96] PathMod ::= '?' | '*' | '+'
+     */
+    __publicField(this, "pathMod", this.RULE("pathMod", () => {
+      this._verbIsSimplePath = false;
+      this.OR([
+        { ALT: () => this.CONSUME(RdfToken.QUESTION_MARK) },
+        { ALT: () => this.CONSUME(RdfToken.STAR) },
+        { ALT: () => this.CONSUME(RdfToken.PLUS_SIGN) }
+      ]);
+    }));
+    /**
+     * [97] PathPrimary ::= iri | 'a' | '!' PathNegatedPropertySet | '(' Path ')'
+     */
+    __publicField(this, "pathPrimary", this.RULE("pathPrimary", () => {
+      this.OR([
+        { ALT: () => this.SUBRULE(this.iri) },
+        { ALT: () => this.CONSUME(RdfToken.A) },
+        {
+          ALT: () => {
+            this._verbIsSimplePath = false;
+            this.CONSUME(RdfToken.BANG);
+            this.SUBRULE(this.pathNegatedPropertySet);
+          }
+        },
+        {
+          ALT: () => {
+            this._verbIsSimplePath = false;
+            this.CONSUME(RdfToken.LPARENT);
+            this.SUBRULE(this.path);
+            this.CONSUME(RdfToken.RPARENT);
+          }
+        }
+      ]);
+    }));
+    /**
+     * [98] PathNegatedPropertySet ::= PathOneInPropertySet | '(' (PathOneInPropertySet ('|' PathOneInPropertySet)*)? ')'
+     */
+    __publicField(this, "pathNegatedPropertySet", this.RULE("pathNegatedPropertySet", () => {
+      this.OR([
+        { ALT: () => this.SUBRULE1(this.pathOneInPropertySet) },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.LPARENT);
+            this.OPTION(() => {
+              this.SUBRULE2(this.pathOneInPropertySet);
+              this.MANY(() => {
+                this.CONSUME(RdfToken.PIPE);
+                this.SUBRULE3(this.pathOneInPropertySet);
+              });
+            });
+            this.CONSUME(RdfToken.RPARENT);
+          }
+        }
+      ]);
+    }));
+    /**
+     * [99] PathOneInPropertySet ::= iri | 'a' | '^' (iri | 'a')
+     */
+    __publicField(this, "pathOneInPropertySet", this.RULE("pathOneInPropertySet", () => {
+      this.OR([
+        { ALT: () => this.SUBRULE(this.iri) },
+        { ALT: () => this.CONSUME(RdfToken.A) },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.CARET);
+            this.OR2([
+              { ALT: () => this.SUBRULE2(this.iri) },
+              { ALT: () => this.CONSUME2(RdfToken.A) }
+            ]);
+          }
+        }
+      ]);
+    }));
+    // ==========================================
+    // RDF 1.2 reification / annotation / triple term [100]-[125]
+    // ==========================================
+    /**
+     * [58] ReifiedTripleBlock ::= ReifiedTriple PropertyList
+     */
+    __publicField(this, "reifiedTripleBlock", this.RULE("reifiedTripleBlock", () => {
+      this.SUBRULE(this.reifiedTriple);
+      this.SUBRULE(this.propertyList);
+    }));
+    /**
+     * [101] ReifiedTriplePathBlock ::= ReifiedTriplePath PropertyListPathNotEmpty
+     */
+    __publicField(this, "reifiedTriplePathBlock", this.RULE("reifiedTriplePathBlock", () => {
+      this.SUBRULE(this.reifiedTriplePath);
+      this.SUBRULE(this.propertyListPathNotEmpty);
+    }));
+    /**
+     * [102] ReifiedTriple ::= '<<' ReifiedTripleSubject Verb ReifiedTripleObject Reifier? '>>'
+     */
+    __publicField(this, "reifiedTriple", this.RULE("reifiedTriple", () => {
+      this.CONSUME(RdfToken.OPEN_REIFIED_TRIPLE);
+      this.SUBRULE(this.reifiedTripleSubject);
+      this.SUBRULE(this.verb);
+      this.SUBRULE(this.reifiedTripleObject);
+      this.OPTION(() => this.SUBRULE(this.reifier));
+      this.CONSUME(RdfToken.CLOSE_REIFIED_TRIPLE);
+    }));
+    /**
+     * [103] ReifiedTriplePath ::= '<<' ReifiedTripleSubject VerbPath ReifiedTripleObjectPath Reifier? '>>'
+     */
+    __publicField(this, "reifiedTriplePath", this.RULE("reifiedTriplePath", () => {
+      this.CONSUME(RdfToken.OPEN_REIFIED_TRIPLE);
+      this.SUBRULE(this.reifiedTripleSubject);
+      this.SUBRULE(this.verbPath);
+      this.SUBRULE(this.reifiedTripleObjectPath);
+      this.OPTION(() => this.SUBRULE(this.reifier));
+      this.CONSUME(RdfToken.CLOSE_REIFIED_TRIPLE);
+    }));
+    /**
+     * [117] ReifiedTripleSubject ::= Var | iri | RDFLiteral | NumericLiteral | BooleanLiteral | BlankNode | ReifiedTriple | TripleTerm
+     * Note: Unlike VarOrTerm, this does NOT include NIL.
+     */
+    __publicField(this, "reifiedTripleSubject", this.RULE("reifiedTripleSubject", () => {
+      this.OR([
+        { IGNORE_AMBIGUITIES: true, ALT: () => this.SUBRULE(this.reifiedTriple) },
+        { IGNORE_AMBIGUITIES: true, ALT: () => this.SUBRULE(this.tripleTerm) },
+        { IGNORE_AMBIGUITIES: true, ALT: () => this.SUBRULE(this.var) },
+        { IGNORE_AMBIGUITIES: true, ALT: () => this.SUBRULE(this.iri) },
+        { IGNORE_AMBIGUITIES: true, ALT: () => this.SUBRULE(this.rdfLiteral) },
+        { IGNORE_AMBIGUITIES: true, ALT: () => this.SUBRULE(this.numericLiteral) },
+        { IGNORE_AMBIGUITIES: true, ALT: () => this.SUBRULE(this.booleanLiteral) },
+        { IGNORE_AMBIGUITIES: true, ALT: () => this.SUBRULE(this.blankNode) }
+      ]);
+    }));
+    /**
+     * [118] ReifiedTripleObject ::= Var | iri | RDFLiteral | NumericLiteral | BooleanLiteral | BlankNode | ReifiedTriple | TripleTerm
+     * Note: Unlike VarOrTerm, this does NOT include NIL.
+     */
+    __publicField(this, "reifiedTripleObject", this.RULE("reifiedTripleObject", () => {
+      this.OR([
+        { IGNORE_AMBIGUITIES: true, ALT: () => this.SUBRULE(this.tripleTerm) },
+        { IGNORE_AMBIGUITIES: true, ALT: () => this.SUBRULE(this.reifiedTriple) },
+        { IGNORE_AMBIGUITIES: true, ALT: () => this.SUBRULE(this.var) },
+        { IGNORE_AMBIGUITIES: true, ALT: () => this.SUBRULE(this.iri) },
+        { IGNORE_AMBIGUITIES: true, ALT: () => this.SUBRULE(this.rdfLiteral) },
+        { IGNORE_AMBIGUITIES: true, ALT: () => this.SUBRULE(this.numericLiteral) },
+        { IGNORE_AMBIGUITIES: true, ALT: () => this.SUBRULE(this.booleanLiteral) },
+        { IGNORE_AMBIGUITIES: true, ALT: () => this.SUBRULE(this.blankNode) }
+      ]);
+    }));
+    /**
+     * [118] ReifiedTripleObjectPath ::= Var | iri | RDFLiteral | NumericLiteral | BooleanLiteral | BlankNode | ReifiedTriplePath | TripleTerm
+     * Note: Unlike VarOrTerm, this does NOT include NIL.
+     */
+    __publicField(this, "reifiedTripleObjectPath", this.RULE("reifiedTripleObjectPath", () => {
+      this.OR([
+        { IGNORE_AMBIGUITIES: true, ALT: () => this.SUBRULE(this.tripleTerm) },
+        { IGNORE_AMBIGUITIES: true, ALT: () => this.SUBRULE(this.reifiedTriplePath) },
+        { IGNORE_AMBIGUITIES: true, ALT: () => this.SUBRULE(this.var) },
+        { IGNORE_AMBIGUITIES: true, ALT: () => this.SUBRULE(this.iri) },
+        { IGNORE_AMBIGUITIES: true, ALT: () => this.SUBRULE(this.rdfLiteral) },
+        { IGNORE_AMBIGUITIES: true, ALT: () => this.SUBRULE(this.numericLiteral) },
+        { IGNORE_AMBIGUITIES: true, ALT: () => this.SUBRULE(this.booleanLiteral) },
+        { IGNORE_AMBIGUITIES: true, ALT: () => this.SUBRULE(this.blankNode) }
+      ]);
+    }));
+    /**
+     * [107] AnnotationPath ::= (Reifier | AnnotationBlockPath)*
+     *
+     * Per spec note 16: annotations and reifiers are only permitted when the
+     * predicate is a simple path (IRI, 'a', or variable), not for complex path
+     * expressions (sequence, alternative, inverse, modifiers, negation, grouping).
+     */
+    __publicField(this, "annotationPath", this.RULE("annotationPath", () => {
+      this.MANY({
+        GATE: () => this._verbIsSimplePath,
+        DEF: () => {
+          this.OR([
+            { ALT: () => this.SUBRULE(this.reifier) },
+            { ALT: () => this.SUBRULE(this.annotationBlockPath) }
+          ]);
+        }
+      });
+    }));
+    /**
+     * [108] AnnotationBlockPath ::= '{|' PropertyListPathNotEmpty '|}'
+     */
+    __publicField(this, "annotationBlockPath", this.RULE("annotationBlockPath", () => {
+      this.CONSUME(RdfToken.OPEN_ANNOTATION);
+      this.SUBRULE(this.propertyListPathNotEmpty);
+      this.CONSUME(RdfToken.CLOSE_ANNOTATION);
+    }));
+    /**
+     * [109] Annotation ::= (Reifier | AnnotationBlock)*
+     *
+     * In delete contexts (DELETE DATA, DELETE WHERE, DeleteClause), annotation
+     * blocks without a preceding named reifier are rejected because they create
+     * anonymous reifiers (blank nodes), which are disallowed per grammar note 7.
+     */
+    __publicField(this, "annotation", this.RULE("annotation", () => {
+      let hasNamedReifier = false;
+      this.MANY(() => {
+        this.OR([
+          {
+            ALT: () => {
+              this.SUBRULE(this.reifier);
+              hasNamedReifier = true;
+            }
+          },
+          {
+            ALT: () => {
+              if (this._insideDeleteBlock && !hasNamedReifier) {
+                throw new Error("Anonymous reifiers (annotation blocks without a named reifier) are not allowed in DELETE blocks (grammar note 7: no blank nodes)");
+              }
+              this.SUBRULE(this.annotationBlock);
+              hasNamedReifier = false;
+            }
+          }
+        ]);
+      });
+    }));
+    /**
+     * [110] AnnotationBlock ::= '{|' PropertyListNotEmpty '|}'
+     */
+    __publicField(this, "annotationBlock", this.RULE("annotationBlock", () => {
+      this.CONSUME(RdfToken.OPEN_ANNOTATION);
+      this.SUBRULE(this.propertyListNotEmpty);
+      this.CONSUME(RdfToken.CLOSE_ANNOTATION);
+    }));
+    /**
+     * [111] Reifier ::= '~' VarOrReifierId?
+     */
+    __publicField(this, "reifier", this.RULE("reifier", () => {
+      this.CONSUME(RdfToken.TILDE);
+      this.OPTION(() => this.SUBRULE(this.varOrReifierId));
+    }));
+    /**
+     * [112] VarOrReifierId ::= Var | iri | BlankNode
+     */
+    __publicField(this, "varOrReifierId", this.RULE("varOrReifierId", () => {
+      this.OR([
+        { ALT: () => this.SUBRULE(this.var) },
+        { ALT: () => this.SUBRULE(this.iri) },
+        { ALT: () => this.SUBRULE(this.blankNode) }
+      ]);
+    }));
+    /**
+     * [113] TripleTerm ::= '<<(' TripleTermSubject Verb TripleTermObject ')>>'
+     */
+    __publicField(this, "tripleTerm", this.RULE("tripleTerm", () => {
+      this.CONSUME(RdfToken.OPEN_TRIPLE_TERM);
+      this.SUBRULE(this.tripleTermSubject);
+      this.SUBRULE(this.verb);
+      this.SUBRULE(this.tripleTermObject);
+      this.CONSUME(RdfToken.CLOSE_TRIPLE_TERM);
+    }));
+    /**
+     * [120] TripleTermSubject ::= Var | iri | RDFLiteral | NumericLiteral | BooleanLiteral | BlankNode | TripleTerm
+     */
+    __publicField(this, "tripleTermSubject", this.RULE("tripleTermSubject", () => {
+      this.OR([
+        { ALT: () => this.SUBRULE(this.var) },
+        { ALT: () => this.SUBRULE(this.iri) },
+        { ALT: () => this.SUBRULE(this.rdfLiteral) },
+        { ALT: () => this.SUBRULE(this.numericLiteral) },
+        { ALT: () => this.SUBRULE(this.booleanLiteral) },
+        { ALT: () => this.SUBRULE(this.blankNode) },
+        { ALT: () => this.SUBRULE(this.tripleTerm) }
+      ]);
+    }));
+    /**
+     * [121] TripleTermObject ::= Var | iri | RDFLiteral | NumericLiteral | BooleanLiteral | BlankNode | TripleTerm
+     */
+    __publicField(this, "tripleTermObject", this.RULE("tripleTermObject", () => {
+      this.OR([
+        { ALT: () => this.SUBRULE(this.var) },
+        { ALT: () => this.SUBRULE(this.iri) },
+        { ALT: () => this.SUBRULE(this.rdfLiteral) },
+        { ALT: () => this.SUBRULE(this.numericLiteral) },
+        { ALT: () => this.SUBRULE(this.booleanLiteral) },
+        { ALT: () => this.SUBRULE(this.blankNode) },
+        { ALT: () => this.SUBRULE(this.tripleTerm) }
+      ]);
+    }));
+    /**
+     * [116] TripleTermData ::= '<<(' TripleTermDataSubject (iri | 'a') TripleTermDataObject ')>>'
+     */
+    __publicField(this, "tripleTermData", this.RULE("tripleTermData", () => {
+      this.CONSUME(RdfToken.OPEN_TRIPLE_TERM);
+      this.SUBRULE(this.tripleTermDataSubject);
+      this.OR([
+        { ALT: () => this.SUBRULE1(this.iri) },
+        { ALT: () => this.CONSUME(RdfToken.A) }
+      ]);
+      this.SUBRULE(this.tripleTermDataObject);
+      this.CONSUME(RdfToken.CLOSE_TRIPLE_TERM);
+    }));
+    /**
+     * [123] TripleTermDataSubject ::= iri
+     */
+    __publicField(this, "tripleTermDataSubject", this.RULE("tripleTermDataSubject", () => {
+      this.SUBRULE(this.iri);
+    }));
+    /**
+     * [124] TripleTermDataObject ::= iri | RDFLiteral | NumericLiteral | BooleanLiteral | TripleTermData
+     */
+    __publicField(this, "tripleTermDataObject", this.RULE("tripleTermDataObject", () => {
+      this.OR([
+        { ALT: () => this.SUBRULE(this.iri) },
+        { ALT: () => this.SUBRULE(this.rdfLiteral) },
+        { ALT: () => this.SUBRULE(this.numericLiteral) },
+        { ALT: () => this.SUBRULE(this.booleanLiteral) },
+        { ALT: () => this.SUBRULE(this.tripleTermData) }
+      ]);
+    }));
+    // ==========================================
+    // Expression productions [119]-[143]
+    // ==========================================
+    /**
+     * [119] Expression ::= ConditionalOrExpression
+     */
+    __publicField(this, "expression", this.RULE("expression", () => {
+      this.SUBRULE(this.conditionalOrExpression);
+    }));
+    /**
+     * [120] ConditionalOrExpression ::= ConditionalAndExpression ('||' ConditionalAndExpression)*
+     */
+    __publicField(this, "conditionalOrExpression", this.RULE("conditionalOrExpression", () => {
+      this.SUBRULE1(this.conditionalAndExpression);
+      this.MANY(() => {
+        this.CONSUME(RdfToken.OR);
+        this.SUBRULE2(this.conditionalAndExpression);
+      });
+    }));
+    /**
+     * [121] ConditionalAndExpression ::= ValueLogical ('&&' ValueLogical)*
+     */
+    __publicField(this, "conditionalAndExpression", this.RULE("conditionalAndExpression", () => {
+      this.SUBRULE1(this.valueLogical);
+      this.MANY(() => {
+        this.CONSUME(RdfToken.AND);
+        this.SUBRULE2(this.valueLogical);
+      });
+    }));
+    /**
+     * [122] ValueLogical ::= RelationalExpression
+     */
+    __publicField(this, "valueLogical", this.RULE("valueLogical", () => {
+      this.SUBRULE(this.relationalExpression);
+    }));
+    /**
+     * [123] RelationalExpression ::= NumericExpression
+     *       ('=' NumericExpression | '!=' NumericExpression | '<' NumericExpression
+     *       | '>' NumericExpression | '<=' NumericExpression | '>=' NumericExpression
+     *       | 'IN' ExpressionList | 'NOT' 'IN' ExpressionList)?
+     */
+    __publicField(this, "relationalExpression", this.RULE("relationalExpression", () => {
+      this.SUBRULE1(this.numericExpression);
+      this.OPTION(() => {
+        this.OR([
+          { ALT: () => {
+            this.CONSUME(RdfToken.EQ);
+            this.SUBRULE2(this.numericExpression);
+          } },
+          { ALT: () => {
+            this.CONSUME(RdfToken.NEQ);
+            this.SUBRULE3(this.numericExpression);
+          } },
+          { ALT: () => {
+            this.CONSUME(RdfToken.LT);
+            this.SUBRULE4(this.numericExpression);
+          } },
+          { ALT: () => {
+            this.CONSUME(RdfToken.GT);
+            this.SUBRULE5(this.numericExpression);
+          } },
+          { ALT: () => {
+            this.CONSUME(RdfToken.LTE);
+            this.SUBRULE6(this.numericExpression);
+          } },
+          { ALT: () => {
+            this.CONSUME(RdfToken.GTE);
+            this.SUBRULE7(this.numericExpression);
+          } },
+          { ALT: () => {
+            this.CONSUME(RdfToken.IN_KW);
+            this.SUBRULE1(this.expressionList);
+          } },
+          { ALT: () => {
+            this.CONSUME(RdfToken.NOT);
+            this.CONSUME2(RdfToken.IN_KW);
+            this.SUBRULE2(this.expressionList);
+          } }
+        ]);
+      });
+    }));
+    /**
+     * [124] NumericExpression ::= AdditiveExpression
+     */
+    __publicField(this, "numericExpression", this.RULE("numericExpression", () => {
+      this.SUBRULE(this.additiveExpression);
+    }));
+    /**
+     * [125] AdditiveExpression ::= MultiplicativeExpression
+     *       ('+' MultiplicativeExpression | '-' MultiplicativeExpression
+     *       | (NumericLiteralPositive | NumericLiteralNegative) (('*' UnaryExpression) | ('/' UnaryExpression))?)*
+     */
+    __publicField(this, "additiveExpression", this.RULE("additiveExpression", () => {
+      this.SUBRULE1(this.multiplicativeExpression);
+      this.MANY(() => {
+        this.OR([
+          {
+            ALT: () => {
+              this.CONSUME(RdfToken.PLUS_SIGN);
+              this.SUBRULE2(this.multiplicativeExpression);
+            }
+          },
+          {
+            ALT: () => {
+              this.CONSUME(RdfToken.MINUS_SIGN);
+              this.SUBRULE3(this.multiplicativeExpression);
+            }
+          },
+          {
+            ALT: () => {
+              this.OR2([
+                { ALT: () => this.SUBRULE1(this.numericLiteralPositive) },
+                { ALT: () => this.SUBRULE1(this.numericLiteralNegative) }
+              ]);
+              this.OPTION(() => {
+                this.OR3([
+                  { ALT: () => {
+                    this.CONSUME(RdfToken.STAR);
+                    this.SUBRULE1(this.unaryExpression);
+                  } },
+                  { ALT: () => {
+                    this.CONSUME(RdfToken.SLASH);
+                    this.SUBRULE2(this.unaryExpression);
+                  } }
+                ]);
+              });
+            }
+          }
+        ]);
+      });
+    }));
+    /**
+     * [126] MultiplicativeExpression ::= UnaryExpression (('*' UnaryExpression) | ('/' UnaryExpression))*
+     */
+    __publicField(this, "multiplicativeExpression", this.RULE("multiplicativeExpression", () => {
+      this.SUBRULE1(this.unaryExpression);
+      this.MANY(() => {
+        this.OR([
+          { ALT: () => {
+            this.CONSUME(RdfToken.STAR);
+            this.SUBRULE2(this.unaryExpression);
+          } },
+          { ALT: () => {
+            this.CONSUME(RdfToken.SLASH);
+            this.SUBRULE3(this.unaryExpression);
+          } }
+        ]);
+      });
+    }));
+    /**
+     * [135] UnaryExpression ::= '!' UnaryExpression | '+' PrimaryExpression | '-' PrimaryExpression | PrimaryExpression
+     */
+    __publicField(this, "unaryExpression", this.RULE("unaryExpression", () => {
+      this.OR([
+        { ALT: () => {
+          this.CONSUME(RdfToken.BANG);
+          this.SUBRULE1(this.unaryExpression);
+        } },
+        { ALT: () => {
+          this.CONSUME(RdfToken.PLUS_SIGN);
+          this.SUBRULE2(this.primaryExpression);
+        } },
+        { ALT: () => {
+          this.CONSUME(RdfToken.MINUS_SIGN);
+          this.SUBRULE3(this.primaryExpression);
+        } },
+        { ALT: () => this.SUBRULE4(this.primaryExpression) }
+      ]);
+    }));
+    /**
+     * [128] PrimaryExpression ::= BrackettedExpression | BuiltInCall | iriOrFunction | RDFLiteral
+     *       | NumericLiteral | BooleanLiteral | Var | ExprTripleTerm
+     */
+    __publicField(this, "primaryExpression", this.RULE("primaryExpression", () => {
+      this.OR([
+        { ALT: () => this.SUBRULE(this.brackettedExpression) },
+        { ALT: () => this.SUBRULE(this.builtInCall) },
+        { ALT: () => this.SUBRULE(this.iriOrFunction) },
+        { ALT: () => this.SUBRULE(this.rdfLiteral) },
+        { ALT: () => this.SUBRULE(this.numericLiteral) },
+        { ALT: () => this.SUBRULE(this.booleanLiteral) },
+        { ALT: () => this.SUBRULE(this.var) },
+        { ALT: () => this.SUBRULE(this.exprTripleTerm) }
+      ]);
+    }));
+    /**
+     * [129] BrackettedExpression ::= '(' Expression ')'
+     */
+    __publicField(this, "brackettedExpression", this.RULE("brackettedExpression", () => {
+      this.CONSUME(RdfToken.LPARENT);
+      this.SUBRULE(this.expression);
+      this.CONSUME(RdfToken.RPARENT);
+    }));
+    /**
+     * [137] ExprTripleTerm ::= '<<(' ExprTripleTermSubject Verb ExprTripleTermObject ')>>'
+     */
+    __publicField(this, "exprTripleTerm", this.RULE("exprTripleTerm", () => {
+      this.CONSUME(RdfToken.OPEN_TRIPLE_TERM);
+      this.SUBRULE(this.exprTripleTermSubject);
+      this.SUBRULE(this.verb);
+      this.SUBRULE(this.exprTripleTermObject);
+      this.CONSUME(RdfToken.CLOSE_TRIPLE_TERM);
+    }));
+    /**
+     * [138] ExprTripleTermSubject ::= iri | Var
+     */
+    __publicField(this, "exprTripleTermSubject", this.RULE("exprTripleTermSubject", () => {
+      this.OR([
+        { ALT: () => this.SUBRULE(this.iri) },
+        { ALT: () => this.SUBRULE(this.var) }
+      ]);
+    }));
+    /**
+     * [139] ExprTripleTermObject ::= iri | RDFLiteral | NumericLiteral | BooleanLiteral | Var | ExprTripleTerm
+     */
+    __publicField(this, "exprTripleTermObject", this.RULE("exprTripleTermObject", () => {
+      this.OR([
+        { ALT: () => this.SUBRULE(this.iri) },
+        { ALT: () => this.SUBRULE(this.rdfLiteral) },
+        { ALT: () => this.SUBRULE(this.numericLiteral) },
+        { ALT: () => this.SUBRULE(this.booleanLiteral) },
+        { ALT: () => this.SUBRULE(this.var) },
+        { ALT: () => this.SUBRULE(this.exprTripleTerm) }
+      ]);
+    }));
+    // ==========================================
+    // Built-in calls [131]
+    // ==========================================
+    /**
+     * [131] BuiltInCall - dispatches to sub-groups to stay within Chevrotain's CONSUME index limits
+     */
+    __publicField(this, "builtInCall", this.RULE("builtInCall", () => {
+      this.OR([
+        { ALT: () => this.SUBRULE(this.aggregate) },
+        { ALT: () => this.SUBRULE(this.builtInCallTermAccessors) },
+        { ALT: () => this.SUBRULE(this.builtInCallStringFuncs) },
+        { ALT: () => this.SUBRULE(this.builtInCallNumericFuncs) },
+        { ALT: () => this.SUBRULE(this.builtInCallDateTimeFuncs) },
+        { ALT: () => this.SUBRULE(this.builtInCallHashFuncs) },
+        { ALT: () => this.SUBRULE(this.builtInCallTestFuncs) },
+        { ALT: () => this.SUBRULE(this.builtInCallMiscFuncs) },
+        { ALT: () => this.SUBRULE(this.builtInCallRdf12Funcs) },
+        { ALT: () => this.SUBRULE(this.regexExpression) },
+        { ALT: () => this.SUBRULE(this.substringExpression) },
+        { ALT: () => this.SUBRULE(this.strReplaceExpression) },
+        { ALT: () => this.SUBRULE(this.existsFunc) },
+        { ALT: () => this.SUBRULE(this.notExistsFunc) }
+      ]);
+    }));
+    /**
+     * Term accessor built-ins: STR, LANG, LANGDIR, DATATYPE, IRI, URI, BNODE
+     */
+    __publicField(this, "builtInCallTermAccessors", this.RULE("builtInCallTermAccessors", () => {
+      this.OR([
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.STR);
+            this.CONSUME1(RdfToken.LPARENT);
+            this.SUBRULE1(this.expression);
+            this.CONSUME1(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.LANG_KW);
+            this.CONSUME2(RdfToken.LPARENT);
+            this.SUBRULE2(this.expression);
+            this.CONSUME2(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.LANGMATCHES);
+            this.CONSUME3(RdfToken.LPARENT);
+            this.SUBRULE3(this.expression);
+            this.CONSUME1(RdfToken.COMMA);
+            this.SUBRULE4(this.expression);
+            this.CONSUME3(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.LANGDIR);
+            this.CONSUME4(RdfToken.LPARENT);
+            this.SUBRULE5(this.expression);
+            this.CONSUME4(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.DATATYPE);
+            this.CONSUME5(RdfToken.LPARENT);
+            this.SUBRULE6(this.expression);
+            this.CONSUME5(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.IRI_KW);
+            this.CONSUME6(RdfToken.LPARENT);
+            this.SUBRULE7(this.expression);
+            this.CONSUME6(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.URI_KW);
+            this.CONSUME7(RdfToken.LPARENT);
+            this.SUBRULE8(this.expression);
+            this.CONSUME7(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.BNODE_KW);
+            this.OR2([
+              {
+                ALT: () => {
+                  this.CONSUME8(RdfToken.LPARENT);
+                  this.SUBRULE9(this.expression);
+                  this.CONSUME8(RdfToken.RPARENT);
+                }
+              },
+              { ALT: () => this.CONSUME1(RdfToken.NIL) }
+            ]);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.BOUND);
+            this.CONSUME9(RdfToken.LPARENT);
+            this.SUBRULE1(this.var);
+            this.CONSUME9(RdfToken.RPARENT);
+          }
+        }
+      ]);
+    }));
+    /**
+     * String built-ins part 1: STRLEN, UCASE, LCASE, ENCODE_FOR_URI, CONTAINS, STRSTARTS, CONCAT
+     */
+    __publicField(this, "builtInCallStringFuncs", this.RULE("builtInCallStringFuncs", () => {
+      this.OR([
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.STRLEN);
+            this.CONSUME1(RdfToken.LPARENT);
+            this.SUBRULE1(this.expression);
+            this.CONSUME1(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.UCASE);
+            this.CONSUME2(RdfToken.LPARENT);
+            this.SUBRULE2(this.expression);
+            this.CONSUME2(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.LCASE);
+            this.CONSUME3(RdfToken.LPARENT);
+            this.SUBRULE3(this.expression);
+            this.CONSUME3(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.ENCODE_FOR_URI);
+            this.CONSUME4(RdfToken.LPARENT);
+            this.SUBRULE4(this.expression);
+            this.CONSUME4(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.CONTAINS);
+            this.CONSUME5(RdfToken.LPARENT);
+            this.SUBRULE5(this.expression);
+            this.CONSUME1(RdfToken.COMMA);
+            this.SUBRULE6(this.expression);
+            this.CONSUME5(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.STRSTARTS);
+            this.CONSUME6(RdfToken.LPARENT);
+            this.SUBRULE7(this.expression);
+            this.CONSUME2(RdfToken.COMMA);
+            this.SUBRULE8(this.expression);
+            this.CONSUME6(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.CONCAT);
+            this.SUBRULE1(this.expressionList);
+          }
+        },
+        { ALT: () => this.SUBRULE(this.builtInCallStringFuncs2) }
+      ]);
+    }));
+    /**
+     * String built-ins part 2: STRENDS, STRBEFORE, STRAFTER
+     */
+    __publicField(this, "builtInCallStringFuncs2", this.RULE("builtInCallStringFuncs2", () => {
+      this.OR([
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.STRENDS);
+            this.CONSUME1(RdfToken.LPARENT);
+            this.SUBRULE1(this.expression);
+            this.CONSUME1(RdfToken.COMMA);
+            this.SUBRULE2(this.expression);
+            this.CONSUME1(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.STRBEFORE);
+            this.CONSUME2(RdfToken.LPARENT);
+            this.SUBRULE3(this.expression);
+            this.CONSUME2(RdfToken.COMMA);
+            this.SUBRULE4(this.expression);
+            this.CONSUME2(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.STRAFTER);
+            this.CONSUME3(RdfToken.LPARENT);
+            this.SUBRULE5(this.expression);
+            this.CONSUME3(RdfToken.COMMA);
+            this.SUBRULE6(this.expression);
+            this.CONSUME3(RdfToken.RPARENT);
+          }
+        },
+        { ALT: () => this.SUBRULE(this.builtInCallStringFuncs3) }
+      ]);
+    }));
+    /**
+     * String built-ins part 3: STRLANG, STRLANGDIR, STRDT
+     */
+    __publicField(this, "builtInCallStringFuncs3", this.RULE("builtInCallStringFuncs3", () => {
+      this.OR([
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.STRLANG);
+            this.CONSUME1(RdfToken.LPARENT);
+            this.SUBRULE1(this.expression);
+            this.CONSUME1(RdfToken.COMMA);
+            this.SUBRULE2(this.expression);
+            this.CONSUME1(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.STRLANGDIR);
+            this.CONSUME2(RdfToken.LPARENT);
+            this.SUBRULE3(this.expression);
+            this.CONSUME2(RdfToken.COMMA);
+            this.SUBRULE4(this.expression);
+            this.CONSUME3(RdfToken.COMMA);
+            this.SUBRULE5(this.expression);
+            this.CONSUME2(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.STRDT);
+            this.CONSUME3(RdfToken.LPARENT);
+            this.SUBRULE6(this.expression);
+            this.CONSUME4(RdfToken.COMMA);
+            this.SUBRULE7(this.expression);
+            this.CONSUME3(RdfToken.RPARENT);
+          }
+        }
+      ]);
+    }));
+    /**
+     * Numeric built-ins: ABS, CEIL, FLOOR, ROUND, RAND
+     */
+    __publicField(this, "builtInCallNumericFuncs", this.RULE("builtInCallNumericFuncs", () => {
+      this.OR([
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.ABS_KW);
+            this.CONSUME1(RdfToken.LPARENT);
+            this.SUBRULE1(this.expression);
+            this.CONSUME1(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.CEIL);
+            this.CONSUME2(RdfToken.LPARENT);
+            this.SUBRULE2(this.expression);
+            this.CONSUME2(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.FLOOR);
+            this.CONSUME3(RdfToken.LPARENT);
+            this.SUBRULE3(this.expression);
+            this.CONSUME3(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.ROUND);
+            this.CONSUME4(RdfToken.LPARENT);
+            this.SUBRULE4(this.expression);
+            this.CONSUME4(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.RAND);
+            this.CONSUME1(RdfToken.NIL);
+          }
+        }
+      ]);
+    }));
+    /**
+     * Date/time built-ins: YEAR, MONTH, DAY, HOURS, MINUTES, SECONDS, TIMEZONE, TZ, NOW
+     */
+    __publicField(this, "builtInCallDateTimeFuncs", this.RULE("builtInCallDateTimeFuncs", () => {
+      this.OR([
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.YEAR);
+            this.CONSUME1(RdfToken.LPARENT);
+            this.SUBRULE1(this.expression);
+            this.CONSUME1(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.MONTH);
+            this.CONSUME2(RdfToken.LPARENT);
+            this.SUBRULE2(this.expression);
+            this.CONSUME2(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.DAY);
+            this.CONSUME3(RdfToken.LPARENT);
+            this.SUBRULE3(this.expression);
+            this.CONSUME3(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.HOURS);
+            this.CONSUME4(RdfToken.LPARENT);
+            this.SUBRULE4(this.expression);
+            this.CONSUME4(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.MINUTES);
+            this.CONSUME5(RdfToken.LPARENT);
+            this.SUBRULE5(this.expression);
+            this.CONSUME5(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.SECONDS);
+            this.CONSUME6(RdfToken.LPARENT);
+            this.SUBRULE6(this.expression);
+            this.CONSUME6(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.TIMEZONE);
+            this.CONSUME7(RdfToken.LPARENT);
+            this.SUBRULE7(this.expression);
+            this.CONSUME7(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.TZ_KW);
+            this.CONSUME8(RdfToken.LPARENT);
+            this.SUBRULE8(this.expression);
+            this.CONSUME8(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.NOW);
+            this.CONSUME2(RdfToken.NIL);
+          }
+        }
+      ]);
+    }));
+    /**
+     * Hash built-ins: MD5, SHA1, SHA256, SHA384, SHA512
+     */
+    __publicField(this, "builtInCallHashFuncs", this.RULE("builtInCallHashFuncs", () => {
+      this.OR([
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.MD5);
+            this.CONSUME1(RdfToken.LPARENT);
+            this.SUBRULE1(this.expression);
+            this.CONSUME1(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.SHA1);
+            this.CONSUME2(RdfToken.LPARENT);
+            this.SUBRULE2(this.expression);
+            this.CONSUME2(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.SHA256);
+            this.CONSUME3(RdfToken.LPARENT);
+            this.SUBRULE3(this.expression);
+            this.CONSUME3(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.SHA384);
+            this.CONSUME4(RdfToken.LPARENT);
+            this.SUBRULE4(this.expression);
+            this.CONSUME4(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.SHA512);
+            this.CONSUME5(RdfToken.LPARENT);
+            this.SUBRULE5(this.expression);
+            this.CONSUME5(RdfToken.RPARENT);
+          }
+        }
+      ]);
+    }));
+    /**
+     * Test built-ins: sameTerm, isIRI, isURI, isBLANK, isLITERAL, isNUMERIC
+     */
+    __publicField(this, "builtInCallTestFuncs", this.RULE("builtInCallTestFuncs", () => {
+      this.OR([
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.SAMETERM);
+            this.CONSUME1(RdfToken.LPARENT);
+            this.SUBRULE1(this.expression);
+            this.CONSUME1(RdfToken.COMMA);
+            this.SUBRULE2(this.expression);
+            this.CONSUME1(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.ISIRI);
+            this.CONSUME2(RdfToken.LPARENT);
+            this.SUBRULE3(this.expression);
+            this.CONSUME2(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.ISURI);
+            this.CONSUME3(RdfToken.LPARENT);
+            this.SUBRULE4(this.expression);
+            this.CONSUME3(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.ISBLANK);
+            this.CONSUME4(RdfToken.LPARENT);
+            this.SUBRULE5(this.expression);
+            this.CONSUME4(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.ISLITERAL);
+            this.CONSUME5(RdfToken.LPARENT);
+            this.SUBRULE6(this.expression);
+            this.CONSUME5(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.ISNUMERIC);
+            this.CONSUME6(RdfToken.LPARENT);
+            this.SUBRULE7(this.expression);
+            this.CONSUME6(RdfToken.RPARENT);
+          }
+        }
+      ]);
+    }));
+    /**
+     * Miscellaneous built-ins: COALESCE, IF, UUID, STRUUID
+     */
+    __publicField(this, "builtInCallMiscFuncs", this.RULE("builtInCallMiscFuncs", () => {
+      this.OR([
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.COALESCE);
+            this.SUBRULE1(this.expressionList);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.IF_KW);
+            this.CONSUME1(RdfToken.LPARENT);
+            this.SUBRULE1(this.expression);
+            this.CONSUME1(RdfToken.COMMA);
+            this.SUBRULE2(this.expression);
+            this.CONSUME2(RdfToken.COMMA);
+            this.SUBRULE3(this.expression);
+            this.CONSUME1(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.UUID_KW);
+            this.CONSUME1(RdfToken.NIL);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.STRUUID);
+            this.CONSUME2(RdfToken.NIL);
+          }
+        }
+      ]);
+    }));
+    /**
+     * RDF 1.2 built-ins: isTRIPLE, TRIPLE, SUBJECT, PREDICATE, OBJECT, hasLANG, hasLANGDIR
+     */
+    __publicField(this, "builtInCallRdf12Funcs", this.RULE("builtInCallRdf12Funcs", () => {
+      this.OR([
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.ISTRIPLE);
+            this.CONSUME1(RdfToken.LPARENT);
+            this.SUBRULE1(this.expression);
+            this.CONSUME1(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.TRIPLE_KW);
+            this.CONSUME2(RdfToken.LPARENT);
+            this.SUBRULE2(this.expression);
+            this.CONSUME1(RdfToken.COMMA);
+            this.SUBRULE3(this.expression);
+            this.CONSUME2(RdfToken.COMMA);
+            this.SUBRULE4(this.expression);
+            this.CONSUME2(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.SUBJECT_KW);
+            this.CONSUME3(RdfToken.LPARENT);
+            this.SUBRULE5(this.expression);
+            this.CONSUME3(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.PREDICATE_KW);
+            this.CONSUME4(RdfToken.LPARENT);
+            this.SUBRULE6(this.expression);
+            this.CONSUME4(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.OBJECT_KW);
+            this.CONSUME5(RdfToken.LPARENT);
+            this.SUBRULE7(this.expression);
+            this.CONSUME5(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.HASLANG);
+            this.CONSUME6(RdfToken.LPARENT);
+            this.SUBRULE8(this.expression);
+            this.CONSUME6(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.HASLANGDIR);
+            this.CONSUME7(RdfToken.LPARENT);
+            this.SUBRULE9(this.expression);
+            this.CONSUME7(RdfToken.RPARENT);
+          }
+        }
+      ]);
+    }));
+    /**
+     * [132] RegexExpression ::= 'REGEX' '(' Expression ',' Expression (',' Expression)? ')'
+     */
+    __publicField(this, "regexExpression", this.RULE("regexExpression", () => {
+      this.CONSUME(RdfToken.REGEX);
+      this.CONSUME(RdfToken.LPARENT);
+      this.SUBRULE1(this.expression);
+      this.CONSUME1(RdfToken.COMMA);
+      this.SUBRULE2(this.expression);
+      this.OPTION(() => {
+        this.CONSUME2(RdfToken.COMMA);
+        this.SUBRULE3(this.expression);
+      });
+      this.CONSUME(RdfToken.RPARENT);
+    }));
+    /**
+     * [133] SubstringExpression ::= 'SUBSTR' '(' Expression ',' Expression (',' Expression)? ')'
+     */
+    __publicField(this, "substringExpression", this.RULE("substringExpression", () => {
+      this.CONSUME(RdfToken.SUBSTR);
+      this.CONSUME(RdfToken.LPARENT);
+      this.SUBRULE1(this.expression);
+      this.CONSUME1(RdfToken.COMMA);
+      this.SUBRULE2(this.expression);
+      this.OPTION(() => {
+        this.CONSUME2(RdfToken.COMMA);
+        this.SUBRULE3(this.expression);
+      });
+      this.CONSUME(RdfToken.RPARENT);
+    }));
+    /**
+     * [134] StrReplaceExpression ::= 'REPLACE' '(' Expression ',' Expression ',' Expression (',' Expression)? ')'
+     */
+    __publicField(this, "strReplaceExpression", this.RULE("strReplaceExpression", () => {
+      this.CONSUME(RdfToken.REPLACE_KW);
+      this.CONSUME(RdfToken.LPARENT);
+      this.SUBRULE1(this.expression);
+      this.CONSUME1(RdfToken.COMMA);
+      this.SUBRULE2(this.expression);
+      this.CONSUME2(RdfToken.COMMA);
+      this.SUBRULE3(this.expression);
+      this.OPTION(() => {
+        this.CONSUME3(RdfToken.COMMA);
+        this.SUBRULE4(this.expression);
+      });
+      this.CONSUME(RdfToken.RPARENT);
+    }));
+    /**
+     * [135] ExistsFunc ::= 'EXISTS' GroupGraphPattern
+     */
+    __publicField(this, "existsFunc", this.RULE("existsFunc", () => {
+      this.CONSUME(RdfToken.EXISTS);
+      this.SUBRULE(this.groupGraphPattern);
+    }));
+    /**
+     * [136] NotExistsFunc ::= 'NOT' 'EXISTS' GroupGraphPattern
+     */
+    __publicField(this, "notExistsFunc", this.RULE("notExistsFunc", () => {
+      this.CONSUME(RdfToken.NOT);
+      this.CONSUME(RdfToken.EXISTS);
+      this.SUBRULE(this.groupGraphPattern);
+    }));
+    // ==========================================
+    // Aggregate [137]
+    // ==========================================
+    /**
+     * [137] Aggregate ::= 'COUNT' '(' 'DISTINCT'? ('*' | Expression) ')'
+     *       | 'SUM' '(' 'DISTINCT'? Expression ')'
+     *       | 'MIN' '(' 'DISTINCT'? Expression ')'
+     *       | 'MAX' '(' 'DISTINCT'? Expression ')'
+     *       | 'AVG' '(' 'DISTINCT'? Expression ')'
+     *       | 'SAMPLE' '(' 'DISTINCT'? Expression ')'
+     *       | 'GROUP_CONCAT' '(' 'DISTINCT'? Expression (';' 'SEPARATOR' '=' String)? ')'
+     */
+    __publicField(this, "aggregate", this.RULE("aggregate", () => {
+      this.OR([
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.COUNT);
+            this.CONSUME1(RdfToken.LPARENT);
+            this.OPTION1(() => this.CONSUME1(RdfToken.DISTINCT));
+            this.OR2([
+              { ALT: () => this.CONSUME(RdfToken.STAR) },
+              { ALT: () => this.SUBRULE1(this.expression) }
+            ]);
+            this.CONSUME1(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.SUM);
+            this.CONSUME2(RdfToken.LPARENT);
+            this.OPTION2(() => this.CONSUME2(RdfToken.DISTINCT));
+            this.SUBRULE2(this.expression);
+            this.CONSUME2(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.MIN_KW);
+            this.CONSUME3(RdfToken.LPARENT);
+            this.OPTION3(() => this.CONSUME3(RdfToken.DISTINCT));
+            this.SUBRULE3(this.expression);
+            this.CONSUME3(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.MAX_KW);
+            this.CONSUME4(RdfToken.LPARENT);
+            this.OPTION4(() => this.CONSUME4(RdfToken.DISTINCT));
+            this.SUBRULE4(this.expression);
+            this.CONSUME4(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.AVG);
+            this.CONSUME5(RdfToken.LPARENT);
+            this.OPTION5(() => this.CONSUME5(RdfToken.DISTINCT));
+            this.SUBRULE5(this.expression);
+            this.CONSUME5(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.SAMPLE);
+            this.CONSUME6(RdfToken.LPARENT);
+            this.OPTION6(() => this.CONSUME6(RdfToken.DISTINCT));
+            this.SUBRULE6(this.expression);
+            this.CONSUME6(RdfToken.RPARENT);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(RdfToken.GROUP_CONCAT);
+            this.CONSUME7(RdfToken.LPARENT);
+            this.OPTION7(() => this.CONSUME7(RdfToken.DISTINCT));
+            this.SUBRULE7(this.expression);
+            this.OPTION8(() => {
+              this.CONSUME(RdfToken.SEMICOLON);
+              this.CONSUME(RdfToken.SEPARATOR);
+              this.CONSUME(RdfToken.EQ);
+              this.SUBRULE(this.string);
+            });
+            this.CONSUME7(RdfToken.RPARENT);
+          }
+        }
+      ]);
+    }));
+    // ==========================================
+    // iri / function call [138]-[139]
+    // ==========================================
+    /**
+     * [138] iriOrFunction ::= iri ArgList?
+     */
+    __publicField(this, "iriOrFunction", this.RULE("iriOrFunction", () => {
+      this.SUBRULE(this.iri);
+      this.OPTION(() => this.SUBRULE(this.argList));
+    }));
+    // ==========================================
+    // RDF literal / numeric / boolean [139]-[145]
+    // ==========================================
+    /**
+     * [139] RDFLiteral ::= String (LANG_DIR | '^^' iri)?
+     */
+    __publicField(this, "rdfLiteral", this.RULE("rdfLiteral", () => {
+      this.SUBRULE(this.string);
+      this.OPTION(() => {
+        this.OR([
+          { ALT: () => this.CONSUME(RdfToken.LANGTAG) },
+          {
+            ALT: () => {
+              this.CONSUME(RdfToken.DCARET);
+              this.SUBRULE(this.iri);
+            }
+          }
+        ]);
+      });
+    }));
+    /**
+     * [140] NumericLiteral ::= NumericLiteralUnsigned | NumericLiteralPositive | NumericLiteralNegative
+     */
+    __publicField(this, "numericLiteral", this.RULE("numericLiteral", () => {
+      this.OR([
+        { ALT: () => this.SUBRULE(this.numericLiteralUnsigned) },
+        { ALT: () => this.SUBRULE(this.numericLiteralPositive) },
+        { ALT: () => this.SUBRULE(this.numericLiteralNegative) }
+      ]);
+    }));
+    /**
+     * [141] NumericLiteralUnsigned ::= INTEGER | DECIMAL | DOUBLE
+     */
+    __publicField(this, "numericLiteralUnsigned", this.RULE("numericLiteralUnsigned", () => {
+      this.OR([
+        { ALT: () => this.CONSUME(RdfToken.INTEGER) },
+        { ALT: () => this.CONSUME(RdfToken.DECIMAL) },
+        { ALT: () => this.CONSUME(RdfToken.DOUBLE) }
+      ]);
+    }));
+    /**
+     * [142] NumericLiteralPositive ::= INTEGER_POSITIVE | DECIMAL_POSITIVE | DOUBLE_POSITIVE
+     */
+    __publicField(this, "numericLiteralPositive", this.RULE("numericLiteralPositive", () => {
+      this.OR([
+        { ALT: () => this.CONSUME(RdfToken.INTEGER_POSITIVE) },
+        { ALT: () => this.CONSUME(RdfToken.DECIMAL_POSITIVE) },
+        { ALT: () => this.CONSUME(RdfToken.DOUBLE_POSITIVE) }
+      ]);
+    }));
+    /**
+     * [143] NumericLiteralNegative ::= INTEGER_NEGATIVE | DECIMAL_NEGATIVE | DOUBLE_NEGATIVE
+     */
+    __publicField(this, "numericLiteralNegative", this.RULE("numericLiteralNegative", () => {
+      this.OR([
+        { ALT: () => this.CONSUME(RdfToken.INTEGER_NEGATIVE) },
+        { ALT: () => this.CONSUME(RdfToken.DECIMAL_NEGATIVE) },
+        { ALT: () => this.CONSUME(RdfToken.DOUBLE_NEGATIVE) }
+      ]);
+    }));
+    /**
+     * [144] BooleanLiteral ::= 'true' | 'false'
+     */
+    __publicField(this, "booleanLiteral", this.RULE("booleanLiteral", () => {
+      this.OR([
+        { ALT: () => this.CONSUME(RdfToken.TRUE) },
+        { ALT: () => this.CONSUME(RdfToken.FALSE) }
+      ]);
+    }));
+    /**
+     * [145] String ::= STRING_LITERAL_QUOTE | STRING_LITERAL_SINGLE_QUOTE | STRING_LITERAL_LONG_QUOTE | STRING_LITERAL_LONG_SINGLE_QUOTE
+     */
+    __publicField(this, "string", this.RULE("string", () => {
+      this.OR([
+        { ALT: () => this.CONSUME(RdfToken.STRING_LITERAL_QUOTE) },
+        { ALT: () => this.CONSUME(RdfToken.STRING_LITERAL_SINGLE_QUOTE) },
+        { ALT: () => this.CONSUME(RdfToken.STRING_LITERAL_LONG_QUOTE) },
+        { ALT: () => this.CONSUME(RdfToken.STRING_LITERAL_LONG_SINGLE_QUOTE) }
+      ]);
+    }));
+    // ==========================================
+    // IRI / prefixed name [146]-[147]
+    // ==========================================
+    /**
+     * [146] iri ::= IRIREF | PrefixedName
+     */
+    __publicField(this, "iri", this.RULE("iri", () => {
+      this.OR([
+        { ALT: () => this.CONSUME(RdfToken.IRIREF) },
+        { ALT: () => this.SUBRULE(this.prefixedName) }
+      ]);
+    }));
+    /**
+     * [147] PrefixedName ::= PNAME_LN | PNAME_NS
+     */
+    __publicField(this, "prefixedName", this.RULE("prefixedName", () => {
+      const token = this.OR([
+        { ALT: () => this.CONSUME(RdfToken.PNAME_LN) },
+        { ALT: () => this.CONSUME(RdfToken.PNAME_NS) }
+      ]);
+      if (token?.image) {
+        const { prefix } = splitPrefixedName(token.image, true);
+        if (this.namespaces[prefix] === void 0) {
+          const error = new Error(`Undefined prefix: ${prefix}`);
+          error.name = "UndefinedNamespacePrefixError";
+          error.token = token;
+          error.ruleStack = [...this.RULE_OCCURRENCE_STACK];
+          if (this._throwOnErrors) {
+            throw error;
+          } else {
+            this.semanticErrors.push(error);
+          }
+        }
+      }
+    }));
+    /**
+     * [148] BlankNode ::= BLANK_NODE_LABEL | ANON
+     */
+    __publicField(this, "blankNode", this.RULE("blankNode", () => {
+      this.OR([
+        { ALT: () => this.CONSUME(RdfToken.BLANK_NODE_LABEL) },
+        { ALT: () => this.SUBRULE(this.anon) }
+      ]);
+    }));
+    __publicField(this, "anon", this.RULE("anon", () => {
+      this.CONSUME(RdfToken.LBRACKET);
+      this.CONSUME(RdfToken.RBRACKET);
+    }));
+    // ==========================================
+    // Var and helper productions
+    // ==========================================
+    /**
+     * Var ::= VAR1 | VAR2
+     */
+    __publicField(this, "var", this.RULE("var", () => {
+      this.OR([
+        { ALT: () => this.CONSUME(RdfToken.VAR1) },
+        { ALT: () => this.CONSUME(RdfToken.VAR2) }
+      ]);
+    }));
+    /**
+     * VarOrTerm ::= Var | GraphTerm
+     */
+    __publicField(this, "varOrTerm", this.RULE("varOrTerm", () => {
+      this.OR([
+        { ALT: () => this.SUBRULE(this.var) },
+        { ALT: () => this.SUBRULE(this.graphTerm) }
+      ]);
+    }));
+    /**
+     * VarOrIri ::= Var | iri
+     */
+    __publicField(this, "varOrIri", this.RULE("varOrIri", () => {
+      this.OR([
+        { ALT: () => this.SUBRULE(this.var) },
+        { ALT: () => this.SUBRULE(this.iri) }
+      ]);
+    }));
+    /**
+     * GraphTerm ::= iri | RDFLiteral | NumericLiteral | BooleanLiteral | BlankNode | NIL | TripleTerm
+     */
+    __publicField(this, "graphTerm", this.RULE("graphTerm", () => {
+      this.OR([
+        { ALT: () => this.SUBRULE(this.iri) },
+        { ALT: () => this.SUBRULE(this.rdfLiteral) },
+        { ALT: () => this.SUBRULE(this.numericLiteral) },
+        { ALT: () => this.SUBRULE(this.booleanLiteral) },
+        { ALT: () => this.SUBRULE(this.blankNode) },
+        { ALT: () => this.CONSUME(RdfToken.NIL) },
+        { ALT: () => this.SUBRULE(this.tripleTerm) }
+      ]);
+    }));
+    /**
+     * Literal ::= RDFLiteral | NumericLiteral | BooleanLiteral
+     */
+    __publicField(this, "literal", this.RULE("literal", () => {
+      this.OR([
+        { ALT: () => this.SUBRULE(this.rdfLiteral) },
+        { ALT: () => this.SUBRULE(this.numericLiteral) },
+        { ALT: () => this.SUBRULE(this.booleanLiteral) }
+      ]);
+    }));
+    // ==========================================
+    // Graph node productions
+    // ==========================================
+    /**
+     * [113] GraphNode ::= VarOrTerm | TriplesNode | ReifiedTriple
+     */
+    __publicField(this, "graphNode", this.RULE("graphNode", () => {
+      this.OR([
+        { ALT: () => this.SUBRULE(this.varOrTerm) },
+        { ALT: () => this.SUBRULE(this.triplesNode) },
+        { ALT: () => this.SUBRULE(this.reifiedTriple) }
+      ]);
+    }));
+    /**
+     * [114] GraphNodePath ::= VarOrTerm | TriplesNodePath | ReifiedTriple
+     */
+    __publicField(this, "graphNodePath", this.RULE("graphNodePath", () => {
+      this.OR([
+        { ALT: () => this.SUBRULE(this.varOrTerm) },
+        { ALT: () => this.SUBRULE(this.triplesNodePath) },
+        { ALT: () => this.SUBRULE(this.reifiedTriple) }
+      ]);
+    }));
+    /**
+     * TriplesNode ::= Collection | BlankNodePropertyList
+     */
+    __publicField(this, "triplesNode", this.RULE("triplesNode", () => {
+      this.OR([
+        { ALT: () => this.SUBRULE(this.collection) },
+        { ALT: () => this.SUBRULE(this.blankNodePropertyList) }
+      ]);
+    }));
+    /**
+     * BlankNodePropertyList ::= '[' PropertyListNotEmpty ']'
+     */
+    __publicField(this, "blankNodePropertyList", this.RULE("blankNodePropertyList", () => {
+      this.CONSUME(RdfToken.LBRACKET);
+      this.SUBRULE(this.propertyListNotEmpty);
+      this.CONSUME(RdfToken.RBRACKET);
+    }));
+    /**
+     * TriplesNodePath ::= CollectionPath | BlankNodePropertyListPath
+     */
+    __publicField(this, "triplesNodePath", this.RULE("triplesNodePath", () => {
+      this.OR([
+        { ALT: () => this.SUBRULE(this.collectionPath) },
+        { ALT: () => this.SUBRULE(this.blankNodePropertyListPath) }
+      ]);
+    }));
+    /**
+     * BlankNodePropertyListPath ::= '[' PropertyListPathNotEmpty ']'
+     */
+    __publicField(this, "blankNodePropertyListPath", this.RULE("blankNodePropertyListPath", () => {
+      this.CONSUME(RdfToken.LBRACKET);
+      this.SUBRULE(this.propertyListPathNotEmpty);
+      this.CONSUME(RdfToken.RBRACKET);
+    }));
+    /**
+     * Collection ::= '(' GraphNode+ ')'
+     */
+    __publicField(this, "collection", this.RULE("collection", () => {
+      this.CONSUME(RdfToken.LPARENT);
+      this.AT_LEAST_ONE(() => this.SUBRULE(this.graphNode));
+      this.CONSUME(RdfToken.RPARENT);
+    }));
+    /**
+     * CollectionPath ::= '(' GraphNodePath+ ')'
+     */
+    __publicField(this, "collectionPath", this.RULE("collectionPath", () => {
+      this.CONSUME(RdfToken.LPARENT);
+      this.AT_LEAST_ONE(() => this.SUBRULE(this.graphNodePath));
+      this.CONSUME(RdfToken.RPARENT);
+    }));
+    /**
+     * ValuesClause ::= ('VALUES' DataBlock)?
+     */
+    __publicField(this, "valuesClause", this.RULE("valuesClause", () => {
+      this.OPTION(() => {
+        this.CONSUME(RdfToken.VALUES);
+        this.SUBRULE(this.dataBlock);
+      });
+    }));
+    this.performSelfAnalysis();
+  }
+  registerNamespace(prefixToken, iriToken) {
+    const prefix = prefixToken.image.slice(0, -1);
+    const iri = iriToken.image.slice(1, -1);
+    this.namespaces[prefix] = iri;
+  }
+  /**
+   * Parses a set of tokens created by the lexer into a concrete syntax tree (CST) representing the parsed document.
+   * @param tokens A set of tokens created by the lexer.
+   * @param throwOnErrors Whether to throw an error if any parsing errors are detected. Defaults to true.
+   * @returns A concrete syntax tree (CST) object.
+   */
+  parse(tokens, throwOnErrors = true) {
+    this._throwOnErrors = throwOnErrors;
+    this.semanticErrors = [];
+    this.namespaces = {};
+    this.input = withoutCommentTokens(tokens);
+    const cst = this.queryOrUpdate();
+    if (throwOnErrors && this.errors.length > 0) {
+      throw new Error("Parsing errors detected:\n" + JSON.stringify(this.errors));
+    }
+    return cst;
+  }
+};
 
 // ../mentor-rdf-parsers/dist/utils.js
 var BLANK_NODE_TOKEN_NAMES = /* @__PURE__ */ new Set([
@@ -16002,6 +18672,286 @@ var NQuadsReader = class extends BaseVisitor2 {
 // ../mentor-rdf-parsers/dist/ntriples/reader.js
 var BaseVisitor3 = new NTriplesParser().getBaseCstVisitorConstructor();
 
+// ../mentor-rdf-parsers/dist/sparql/vocabulary.js
+var SPARQL_SYNTAX_NS = "https://w3id.org/sparql-syntax#";
+var ns = (localName) => data_model_default.namedNode(SPARQL_SYNTAX_NS + localName);
+var sps = {
+  // Query forms
+  Query: ns("Query"),
+  SelectQuery: ns("SelectQuery"),
+  ConstructQuery: ns("ConstructQuery"),
+  DescribeQuery: ns("DescribeQuery"),
+  AskQuery: ns("AskQuery"),
+  SubSelect: ns("SubSelect"),
+  // Update operations
+  Update: ns("Update"),
+  Load: ns("Load"),
+  Clear: ns("Clear"),
+  Drop: ns("Drop"),
+  Create: ns("Create"),
+  Add: ns("Add"),
+  Move: ns("Move"),
+  Copy: ns("Copy"),
+  InsertData: ns("InsertData"),
+  DeleteData: ns("DeleteData"),
+  DeleteWhere: ns("DeleteWhere"),
+  Modify: ns("Modify"),
+  // Terms
+  Variable: ns("Variable"),
+  BlankNode: ns("BlankNode"),
+  TripleTerm: ns("TripleTerm"),
+  // Graph pattern elements
+  TriplePattern: ns("TriplePattern"),
+  Group: ns("Group"),
+  Optional: ns("Optional"),
+  Union: ns("Union"),
+  Minus: ns("Minus"),
+  Graph: ns("Graph"),
+  Service: ns("Service"),
+  Filter: ns("Filter"),
+  Bind: ns("Bind"),
+  Values: ns("Values"),
+  Exists: ns("Exists"),
+  NotExists: ns("NotExists"),
+  // Property paths
+  SeqPath: ns("SeqPath"),
+  AltPath: ns("AltPath"),
+  InversePath: ns("InversePath"),
+  ZeroOrMorePath: ns("ZeroOrMorePath"),
+  OneOrMorePath: ns("OneOrMorePath"),
+  ZeroOrOnePath: ns("ZeroOrOnePath"),
+  NegatedPath: ns("NegatedPath"),
+  // Expressions
+  Expression: ns("Expression"),
+  Or: ns("Or"),
+  And: ns("And"),
+  Eq: ns("Eq"),
+  Neq: ns("Neq"),
+  Lt: ns("Lt"),
+  Gt: ns("Gt"),
+  Leq: ns("Leq"),
+  Geq: ns("Geq"),
+  In: ns("In"),
+  NotIn: ns("NotIn"),
+  Addition: ns("Addition"),
+  Subtraction: ns("Subtraction"),
+  Multiplication: ns("Multiplication"),
+  Division: ns("Division"),
+  UnaryNot: ns("UnaryNot"),
+  UnaryPlus: ns("UnaryPlus"),
+  UnaryMinus: ns("UnaryMinus"),
+  FunctionCall: ns("FunctionCall"),
+  BuiltInCall: ns("BuiltInCall"),
+  BuiltInFunction: ns("BuiltInFunction"),
+  // Aggregates
+  Aggregate: ns("Aggregate"),
+  Count: ns("Count"),
+  Sum: ns("Sum"),
+  Min: ns("Min"),
+  Max: ns("Max"),
+  Avg: ns("Avg"),
+  Sample: ns("Sample"),
+  GroupConcat: ns("GroupConcat"),
+  // Miscellaneous structure
+  Alias: ns("Alias"),
+  Asc: ns("Asc"),
+  Desc: ns("Desc"),
+  // Named individuals
+  undef: ns("undef"),
+  DefaultGraph: ns("DefaultGraph"),
+  NamedGraphs: ns("NamedGraphs"),
+  AllGraphs: ns("AllGraphs"),
+  // Properties
+  version: ns("version"),
+  where: ns("where"),
+  projection: ns("projection"),
+  star: ns("star"),
+  distinct: ns("distinct"),
+  reduced: ns("reduced"),
+  template: ns("template"),
+  describeTargets: ns("describeTargets"),
+  from: ns("from"),
+  fromNamed: ns("fromNamed"),
+  subject: ns("subject"),
+  predicate: ns("predicate"),
+  object: ns("object"),
+  elements: ns("elements"),
+  graph: ns("graph"),
+  endpoint: ns("endpoint"),
+  silent: ns("silent"),
+  expression: ns("expression"),
+  variable: ns("variable"),
+  varName: ns("varName"),
+  label: ns("label"),
+  arg: ns("arg"),
+  arg1: ns("arg1"),
+  arg2: ns("arg2"),
+  args: ns("args"),
+  function: ns("function"),
+  groupBy: ns("groupBy"),
+  having: ns("having"),
+  orderBy: ns("orderBy"),
+  limit: ns("limit"),
+  offset: ns("offset"),
+  values: ns("values"),
+  variables: ns("variables"),
+  bindings: ns("bindings"),
+  pathElements: ns("pathElements"),
+  path: ns("path"),
+  countStar: ns("countStar"),
+  separator: ns("separator"),
+  operations: ns("operations"),
+  source: ns("source"),
+  into: ns("into"),
+  graphTarget: ns("graphTarget"),
+  fromGraph: ns("fromGraph"),
+  toGraph: ns("toGraph"),
+  data: ns("data"),
+  deleteTemplate: ns("deleteTemplate"),
+  insertTemplate: ns("insertTemplate"),
+  withGraph: ns("withGraph"),
+  using: ns("using"),
+  usingNamed: ns("usingNamed"),
+  // Built-in function individuals
+  STR: ns("STR"),
+  LANG: ns("LANG"),
+  LANGMATCHES: ns("LANGMATCHES"),
+  LANGDIR: ns("LANGDIR"),
+  DATATYPE: ns("DATATYPE"),
+  IRI: ns("IRI"),
+  URI: ns("URI"),
+  BNODE: ns("BNODE"),
+  BOUND: ns("BOUND"),
+  STRLEN: ns("STRLEN"),
+  UCASE: ns("UCASE"),
+  LCASE: ns("LCASE"),
+  ENCODE_FOR_URI: ns("ENCODE_FOR_URI"),
+  CONTAINS: ns("CONTAINS"),
+  STRSTARTS: ns("STRSTARTS"),
+  CONCAT: ns("CONCAT"),
+  STRENDS: ns("STRENDS"),
+  STRBEFORE: ns("STRBEFORE"),
+  STRAFTER: ns("STRAFTER"),
+  STRLANG: ns("STRLANG"),
+  STRLANGDIR: ns("STRLANGDIR"),
+  STRDT: ns("STRDT"),
+  ABS: ns("ABS"),
+  CEIL: ns("CEIL"),
+  FLOOR: ns("FLOOR"),
+  ROUND: ns("ROUND"),
+  RAND: ns("RAND"),
+  YEAR: ns("YEAR"),
+  MONTH: ns("MONTH"),
+  DAY: ns("DAY"),
+  HOURS: ns("HOURS"),
+  MINUTES: ns("MINUTES"),
+  SECONDS: ns("SECONDS"),
+  TIMEZONE: ns("TIMEZONE"),
+  TZ: ns("TZ"),
+  NOW: ns("NOW"),
+  MD5: ns("MD5"),
+  SHA1: ns("SHA1"),
+  SHA256: ns("SHA256"),
+  SHA384: ns("SHA384"),
+  SHA512: ns("SHA512"),
+  sameTerm: ns("sameTerm"),
+  isIRI: ns("isIRI"),
+  isURI: ns("isURI"),
+  isBLANK: ns("isBLANK"),
+  isLITERAL: ns("isLITERAL"),
+  isNUMERIC: ns("isNUMERIC"),
+  COALESCE: ns("COALESCE"),
+  IF: ns("IF"),
+  UUID: ns("UUID"),
+  STRUUID: ns("STRUUID"),
+  isTRIPLE: ns("isTRIPLE"),
+  TRIPLE: ns("TRIPLE"),
+  SUBJECT: ns("SUBJECT"),
+  PREDICATE: ns("PREDICATE"),
+  OBJECT: ns("OBJECT"),
+  hasLANG: ns("hasLANG"),
+  hasLANGDIR: ns("hasLANGDIR"),
+  REGEX: ns("REGEX"),
+  SUBSTR: ns("SUBSTR"),
+  REPLACE: ns("REPLACE")
+};
+var BUILT_IN_FUNCTIONS = {
+  STR: sps.STR,
+  LANG: sps.LANG,
+  LANGMATCHES: sps.LANGMATCHES,
+  LANGDIR: sps.LANGDIR,
+  DATATYPE: sps.DATATYPE,
+  IRI: sps.IRI,
+  URI: sps.URI,
+  BNODE: sps.BNODE,
+  BOUND: sps.BOUND,
+  STRLEN: sps.STRLEN,
+  UCASE: sps.UCASE,
+  LCASE: sps.LCASE,
+  ENCODE_FOR_URI: sps.ENCODE_FOR_URI,
+  CONTAINS: sps.CONTAINS,
+  STRSTARTS: sps.STRSTARTS,
+  CONCAT: sps.CONCAT,
+  STRENDS: sps.STRENDS,
+  STRBEFORE: sps.STRBEFORE,
+  STRAFTER: sps.STRAFTER,
+  STRLANG: sps.STRLANG,
+  STRLANGDIR: sps.STRLANGDIR,
+  STRDT: sps.STRDT,
+  ABS: sps.ABS,
+  CEIL: sps.CEIL,
+  FLOOR: sps.FLOOR,
+  ROUND: sps.ROUND,
+  RAND: sps.RAND,
+  YEAR: sps.YEAR,
+  MONTH: sps.MONTH,
+  DAY: sps.DAY,
+  HOURS: sps.HOURS,
+  MINUTES: sps.MINUTES,
+  SECONDS: sps.SECONDS,
+  TIMEZONE: sps.TIMEZONE,
+  TZ: sps.TZ,
+  NOW: sps.NOW,
+  MD5: sps.MD5,
+  SHA1: sps.SHA1,
+  SHA256: sps.SHA256,
+  SHA384: sps.SHA384,
+  SHA512: sps.SHA512,
+  SAMETERM: sps.sameTerm,
+  ISIRI: sps.isIRI,
+  ISURI: sps.isURI,
+  ISBLANK: sps.isBLANK,
+  ISLITERAL: sps.isLITERAL,
+  ISNUMERIC: sps.isNUMERIC,
+  COALESCE: sps.COALESCE,
+  IF: sps.IF,
+  UUID: sps.UUID,
+  STRUUID: sps.STRUUID,
+  ISTRIPLE: sps.isTRIPLE,
+  TRIPLE: sps.TRIPLE,
+  SUBJECT: sps.SUBJECT,
+  PREDICATE: sps.PREDICATE,
+  OBJECT: sps.OBJECT,
+  HASLANG: sps.hasLANG,
+  HASLANGDIR: sps.hasLANGDIR,
+  REGEX: sps.REGEX,
+  SUBSTR: sps.SUBSTR,
+  REPLACE: sps.REPLACE
+};
+
+// ../mentor-rdf-parsers/dist/sparql/reader.js
+var BaseVisitor4 = new SparqlParser().getBaseCstVisitorConstructor();
+var RDF_TYPE2 = data_model_default.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#type");
+var RDF_FIRST2 = data_model_default.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#first");
+var RDF_REST2 = data_model_default.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#rest");
+var RDF_NIL2 = data_model_default.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#nil");
+var RDF_REIFIES = data_model_default.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#reifies");
+var XSD_INTEGER = data_model_default.namedNode("http://www.w3.org/2001/XMLSchema#integer");
+var XSD_DECIMAL = data_model_default.namedNode("http://www.w3.org/2001/XMLSchema#decimal");
+var XSD_DOUBLE = data_model_default.namedNode("http://www.w3.org/2001/XMLSchema#double");
+var XSD_BOOLEAN = data_model_default.namedNode("http://www.w3.org/2001/XMLSchema#boolean");
+var TRUE = data_model_default.literal("true", XSD_BOOLEAN);
+
 // ../mentor-rdf-parsers/dist/turtle/parser.js
 var TurtleTokens = [
   RdfToken.WS,
@@ -16742,11 +19692,11 @@ var TrigParser = class extends TurtleParserBase {
 };
 
 // ../mentor-rdf-parsers/dist/trig/reader.js
-var BaseVisitor4 = new TrigParser().getBaseCstVisitorConstructor();
+var BaseVisitor5 = new TrigParser().getBaseCstVisitorConstructor();
 
 // ../mentor-rdf-parsers/dist/turtle/reader.js
-var BaseVisitor5 = new TurtleParser().getBaseCstVisitorConstructor();
-var TurtleReader = class extends BaseVisitor5 {
+var BaseVisitor6 = new TurtleParser().getBaseCstVisitorConstructor();
+var TurtleReader = class extends BaseVisitor6 {
   constructor() {
     super();
     /**
@@ -17718,6 +20668,34 @@ var TurtleReader = class extends BaseVisitor5 {
   }
 };
 
+// ../mentor-rdf-parsers/dist/triplate/tokens.js
+function createTriplateToken(name, metadata) {
+  const token = createToken({ name, pattern: Lexer.NA });
+  Object.assign(token, metadata);
+  return token;
+}
+var TEMPLATE = { isTemplate: true };
+var INTERP = { isTemplate: true, isInterpolation: true, isTerm: true };
+var TriplateToken = {
+  /** A `---…---` frontmatter header, emitted as a single opaque block token. */
+  TRIPLATE_FRONTMATTER: createTriplateToken("TRIPLATE_FRONTMATTER", TEMPLATE),
+  /** A `${…}` value interpolation standing in for a term. */
+  TRIPLATE_INTERPOLATION: createTriplateToken("TRIPLATE_INTERPOLATION", INTERP),
+  /** A `$<…>` IRI template standing in for an IRI. */
+  TRIPLATE_IRI_TEMPLATE: createTriplateToken("TRIPLATE_IRI_TEMPLATE", INTERP),
+  /** A `$"…"` string template standing in for a literal. */
+  TRIPLATE_STRING_TEMPLATE: createTriplateToken("TRIPLATE_STRING_TEMPLATE", INTERP),
+  /** A `{% … %}` control directive (e.g. `{% if %}` / `{% for %}`). */
+  TRIPLATE_DIRECTIVE: createTriplateToken("TRIPLATE_DIRECTIVE", TEMPLATE)
+};
+
+// ../mentor-rdf-parsers/dist/triplate/constructs.js
+var INLINE_TOKEN = {
+  iri: TriplateToken.TRIPLATE_IRI_TEMPLATE,
+  string: TriplateToken.TRIPLATE_STRING_TEMPLATE,
+  value: TriplateToken.TRIPLATE_INTERPOLATION
+};
+
 // src/rdf/store.ts
 var TripleNotFoundError = class extends Error {
   /**