@traqula/parser-sparql-1-1 0.0.1-alpha.176

package/LICENSE.txt

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

package/README.md

@@ -0,0 +1,87 @@
+<p align="center">
+    <img alt="Traqula logo" width="70%" style="border-radius: 20px" src="/assets/white-on-red/logo-white-on-red-lettered-social.png">
+</p>
+
+<p align="center">
+  <strong>A query language transpiler framework for JavaScript</strong>
+</p>
+
+**WARNING:** V2 will come shortly and will have lots of breaking changes.
+
+# Traqula parser engine for SPARQL 1.1
+
+Traqula Sparql 1.1 is a [SPARQL 1.1](https://www.w3.org/TR/sparql11-query/#grammar) query parser for TypeScript.
+
+## Installation
+
+```bash
+npm install @traqula/parser-sparql-1-1
+```
+
+or
+
+```bash
+yarn add @traqula/parser-sparql-1-1
+```
+
+## Import
+
+Either through ESM import:
+
+```javascript
+import {Parser} from 'engines/parser-sparql-1-1';
+```
+
+_or_ CJS require:
+
+```javascript
+const Parser = require('engines/parser-sparql-1-1').Parser;
+```
+
+## Usage
+
+This package contains a `Parser` that is able to parse SPARQL 1.1 queries:
+
+```typescript
+const parser = new Parser();
+const abstractSyntaxTree = parser.parse('SELECT * { ?s ?p ?o }');
+```
+
+The package also contains multiple parserBuilders.
+These builders can be used either to consume to a parser,
+or to usage as a starting point for your own grammar.
+
+### Consuming parserBuilder to parser
+
+At the core of Traqula, parser are constructed of multiple parser rules that have been consumed by the builder.
+This consumption returns a parser that can parse strings starting from any grammar rule.
+
+The `sparql11ParserBuilder` for example contains both the rules `queryOrUpdate` and `path` (among many others).
+The consumption of `sparql11ParserBuilder` will thus return an object that has function `queryOrUpdate` and `path`.
+Calling those function with a string will cause that string to be parsed using the appropriate rule as a starting rule.
+
+```typescript
+const parser: {
+  queryOrUpdate: (input: string) => SparqlQuery;
+  path: (input: string) => PropertyPath | IriTerm;
+} = sparql11ParserBuilder.consumeToParser({
+  tokenVocabulary: l.sparql11Tokens.build(),
+}, {
+  parseMode: new Set([ gram.canParseVars, gram.canCreateBlankNodes ]),
+  dataFactory: new DataFactory(),
+});
+```
+
+### Constructing a new grammar from an existing one
+
+The builders can also be used to construct new parsers.
+As an example the `triplesBlockParserBuilder` is created by merging the `objectListBuilder` with some new rules.
+
+## Configuration
+
+Optionally, the following parameters can be set in the `Parser` constructor:
+
+* `dataFactory`: A custom [RDFJS DataFactory](http://rdf.js.org/#datafactory-interface) to construct terms and triples. _(Default: `require('@rdfjs/data-model')`)_
+* `baseIRI`:  An initial default base IRI. _(Default: none)_
+* `prefixes`: An initial map of prefixes
+* `skipValidation`: Can be used to disable the validation that used variables in a select clause are in scope.

package/lib/Parser.d.ts

@@ -0,0 +1,210 @@
+import { ParserBuilder } from '@traqula/core';
+import type { Query, SparqlQuery, Update, SparqlGrammarRule } from '@traqula/rules-sparql-1-1';
+import { gram, SparqlParser } from '@traqula/rules-sparql-1-1';
+export declare const sparql11ParserBuilder: ParserBuilder<import("@traqula/rules-sparql-1-1").SparqlContext, "string" | "object" | "filter" | "add" | "clear" | "copy" | "move" | "var" | "path" | "drop" | "load" | "builtInStr" | "builtInLang" | "builtInLangmatches" | "builtInDatatype" | "builtInBound" | "builtInIri" | "builtInUri" | "builtInBnode" | "builtInRand" | "builtInAbs" | "builtInCeil" | "builtInFloor" | "builtInRound" | "builtInConcat" | "builtInStrlen" | "builtInUcase" | "builtInLcase" | "builtInEncode_for_uri" | "builtInContains" | "builtInStrstarts" | "builtInStrends" | "builtInStrbefore" | "builtInStrafter" | "builtInYear" | "builtInMonth" | "builtInDay" | "builtInHours" | "builtInMinutes" | "builtInSeconds" | "builtInTimezone" | "builtInTz" | "builtInNow" | "builtInUuid" | "builtInStruuid" | "builtInMd5" | "builtInSha1" | "builtInSha256" | "builtInSha384" | "builtInSha512" | "builtInCoalesce" | "builtInIf" | "builtInStrlang" | "builtInStrdt" | "builtInSameterm" | "builtInIsiri" | "builtInIsuri" | "builtInIsblank" | "builtInIsliteral" | "builtInIsnumeric" | "builtInRegex" | "builtInSubstr" | "builtInReplace" | "builtInExists" | "builtInNotexists" | "builtInCount" | "builtInSum" | "builtInMin" | "builtInMax" | "builtInAvg" | "builtInSample" | "builtInGroup_concat" | "quads" | "functionCall" | "create" | "bind" | "aggregate" | "rdfLiteral" | "iri" | "numericLiteral" | "numericLiteralUnsigned" | "numericLiteralPositive" | "numericLiteralNegative" | "booleanLiteral" | "prefixedName" | "blankNode" | "datasetClause" | "defaultGraphClause" | "namedGraphClause" | "sourceSelector" | "prologue" | "baseDecl" | "prefixDecl" | "verb" | "varOrIri" | "VerbA" | "varOrTerm" | "graphTerm" | "pathAlternative" | "pathSequence" | "pathEltOrInverse" | "pathElt" | "pathMod" | "pathPrimary" | "pathNegatedPropertySet" | "pathOneInPropertySet" | "triplesBlock" | "triplesSameSubjectPath" | "propertyListPathNotEmpty" | "propertyListNotEmpty" | "propertyListPath" | "propertyList" | "triplesNodePath" | "triplesNode" | "triplesSameSubject" | "triplesTemplate" | "verbPath" | "verbSimple" | "objectList" | "objectListPath" | "graphNodePath" | "graphNode" | "objectPath" | "collection" | "blankNodePropertyList" | "collectionPath" | "blankNodePropertyListPath" | "whereClause" | "groupGraphPattern" | "subSelect" | "groupGraphPatternSub" | "graphPatternNotTriples" | "groupOrUnionGraphPattern" | "optionalGraphPattern" | "minusGraphPattern" | "graphGraphPattern" | "serviceGraphPattern" | "inlineData" | "expression" | "valuesClause" | "dataBlock" | "inlineDataOneVar" | "inlineDataFull" | "dataBlockValue" | "constraint" | "brackettedExpression" | "builtInCall" | "argList" | "expressionList" | "conditionalOrExpression" | "iriOrFunction" | "conditionalAndExpression" | "valueLogical" | "relationalExpression" | "numericExpression" | "additiveExpression" | "multiplicativeExpression" | "unaryExpression" | "primaryExpression" | "solutionModifier" | "limitOffsetClauses" | "groupClause" | "havingClause" | "orderClause" | "groupCondition" | "havingCondition" | "orderCondition" | "limitClause" | "offsetClause" | "selectQuery" | "constructQuery" | "describeQuery" | "askQuery" | "selectClause" | "constructTemplate" | "constructTriples" | "update1" | "insertData" | "deleteData" | "deleteWhere" | "modify" | "graphRef" | "graphRefAll" | "graphOrDefault" | "quadData" | "quadPattern" | "deleteClause" | "insertClause" | "usingClause" | "quadsNotTriples" | "queryOrUpdate", {
+    string: import("@traqula/core").ParserRule<any, "string"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "string", string, undefined> & import("@traqula/core").GeneratorRule<undefined, "string", string, undefined>;
+    object: import("@traqula/core").ParserRule<any, "object"> & SparqlGrammarRule<"object", import("@traqula/rules-sparql-1-1").Triple[], Pick<import("@traqula/rules-sparql-1-1").Triple, "subject" | "predicate">>;
+    filter: import("@traqula/core").ParserRule<any, "filter"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "filter", import("@traqula/rules-sparql-1-1").FilterPattern, undefined> & import("@traqula/core").GeneratorRule<undefined, "filter", import("@traqula/rules-sparql-1-1").FilterPattern, undefined>;
+    add: import("@traqula/core").ParserRule<any, "add"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "add", import("@traqula/rules-sparql-1-1").CopyMoveAddOperation, undefined> & import("@traqula/core").GeneratorRule<undefined, "add", import("@traqula/rules-sparql-1-1").CopyMoveAddOperation, undefined>;
+    clear: import("@traqula/core").ParserRule<any, "clear"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "clear", import("@traqula/rules-sparql-1-1").ClearDropOperation, undefined> & import("@traqula/core").GeneratorRule<undefined, "clear", import("@traqula/rules-sparql-1-1").ClearDropOperation, undefined>;
+    copy: import("@traqula/core").ParserRule<any, "copy"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "copy", import("@traqula/rules-sparql-1-1").CopyMoveAddOperation, undefined> & import("@traqula/core").GeneratorRule<undefined, "copy", import("@traqula/rules-sparql-1-1").CopyMoveAddOperation, undefined>;
+    move: import("@traqula/core").ParserRule<any, "move"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "move", import("@traqula/rules-sparql-1-1").CopyMoveAddOperation, undefined> & import("@traqula/core").GeneratorRule<undefined, "move", import("@traqula/rules-sparql-1-1").CopyMoveAddOperation, undefined>;
+    var: import("@traqula/core").ParserRule<any, "var"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "var", import("@rdfjs/types").Variable, undefined> & import("@traqula/core").GeneratorRule<undefined, "var", import("@rdfjs/types").Variable, undefined>;
+    path: import("@traqula/core").ParserRule<any, "path"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "path", import("@traqula/rules-sparql-1-1").PropertyPath | import("@traqula/rules-sparql-1-1").IriTerm, undefined> & import("@traqula/core").GeneratorRule<undefined, "path", import("@traqula/rules-sparql-1-1").PropertyPath | import("@traqula/rules-sparql-1-1").IriTerm, undefined>;
+    drop: import("@traqula/core").ParserRule<any, "drop"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "drop", import("@traqula/rules-sparql-1-1").ClearDropOperation, undefined> & import("@traqula/core").GeneratorRule<undefined, "drop", import("@traqula/rules-sparql-1-1").ClearDropOperation, undefined>;
+    load: import("@traqula/core").ParserRule<any, "load"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "load", import("@traqula/rules-sparql-1-1").LoadOperation, undefined> & import("@traqula/core").GeneratorRule<undefined, "load", import("@traqula/rules-sparql-1-1").LoadOperation, undefined>;
+    builtInStr: import("@traqula/core").ParserRule<any, "builtInStr"> & gram.RuleDefExpressionFunctionX<"builtInStr", [import("@traqula/rules-sparql-1-1").Expression]>;
+    builtInLang: import("@traqula/core").ParserRule<any, "builtInLang"> & gram.RuleDefExpressionFunctionX<"builtInLang", [import("@traqula/rules-sparql-1-1").Expression]>;
+    builtInLangmatches: import("@traqula/core").ParserRule<any, "builtInLangmatches"> & gram.RuleDefExpressionFunctionX<"builtInLangmatches", [import("@traqula/rules-sparql-1-1").Expression, import("@traqula/rules-sparql-1-1").Expression]>;
+    builtInDatatype: import("@traqula/core").ParserRule<any, "builtInDatatype"> & gram.RuleDefExpressionFunctionX<"builtInDatatype", [import("@traqula/rules-sparql-1-1").Expression]>;
+    builtInBound: import("@traqula/core").ParserRule<any, "builtInBound"> & gram.RuleDefExpressionFunctionX<"builtInBound", [import("@rdfjs/types").Variable]>;
+    builtInIri: import("@traqula/core").ParserRule<any, "builtInIri"> & gram.RuleDefExpressionFunctionX<"builtInIri", [import("@traqula/rules-sparql-1-1").Expression]>;
+    builtInUri: import("@traqula/core").ParserRule<any, "builtInUri"> & gram.RuleDefExpressionFunctionX<"builtInUri", [import("@traqula/rules-sparql-1-1").Expression]>;
+    builtInBnode: import("@traqula/core").ParserRule<any, "builtInBnode"> & gram.RuleDefExpressionFunctionX<"builtInBnode", [] | [import("@traqula/rules-sparql-1-1").Expression]>;
+    builtInRand: import("@traqula/core").ParserRule<any, "builtInRand"> & gram.RuleDefExpressionFunctionX<"builtInRand", []>;
+    builtInAbs: import("@traqula/core").ParserRule<any, "builtInAbs"> & gram.RuleDefExpressionFunctionX<"builtInAbs", [import("@traqula/rules-sparql-1-1").Expression]>;
+    builtInCeil: import("@traqula/core").ParserRule<any, "builtInCeil"> & gram.RuleDefExpressionFunctionX<"builtInCeil", [import("@traqula/rules-sparql-1-1").Expression]>;
+    builtInFloor: import("@traqula/core").ParserRule<any, "builtInFloor"> & gram.RuleDefExpressionFunctionX<"builtInFloor", [import("@traqula/rules-sparql-1-1").Expression]>;
+    builtInRound: import("@traqula/core").ParserRule<any, "builtInRound"> & gram.RuleDefExpressionFunctionX<"builtInRound", [import("@traqula/rules-sparql-1-1").Expression]>;
+    builtInConcat: import("@traqula/core").ParserRule<any, "builtInConcat"> & gram.RuleDefExpressionFunctionX<"builtInConcat", import("@traqula/rules-sparql-1-1").Expression[]>;
+    builtInStrlen: import("@traqula/core").ParserRule<any, "builtInStrlen"> & gram.RuleDefExpressionFunctionX<"builtInStrlen", [import("@traqula/rules-sparql-1-1").Expression]>;
+    builtInUcase: import("@traqula/core").ParserRule<any, "builtInUcase"> & gram.RuleDefExpressionFunctionX<"builtInUcase", [import("@traqula/rules-sparql-1-1").Expression]>;
+    builtInLcase: import("@traqula/core").ParserRule<any, "builtInLcase"> & gram.RuleDefExpressionFunctionX<"builtInLcase", [import("@traqula/rules-sparql-1-1").Expression]>;
+    builtInEncode_for_uri: import("@traqula/core").ParserRule<any, "builtInEncode_for_uri"> & gram.RuleDefExpressionFunctionX<"builtInEncode_for_uri", [import("@traqula/rules-sparql-1-1").Expression]>;
+    builtInContains: import("@traqula/core").ParserRule<any, "builtInContains"> & gram.RuleDefExpressionFunctionX<"builtInContains", [import("@traqula/rules-sparql-1-1").Expression, import("@traqula/rules-sparql-1-1").Expression]>;
+    builtInStrstarts: import("@traqula/core").ParserRule<any, "builtInStrstarts"> & gram.RuleDefExpressionFunctionX<"builtInStrstarts", [import("@traqula/rules-sparql-1-1").Expression, import("@traqula/rules-sparql-1-1").Expression]>;
+    builtInStrends: import("@traqula/core").ParserRule<any, "builtInStrends"> & gram.RuleDefExpressionFunctionX<"builtInStrends", [import("@traqula/rules-sparql-1-1").Expression, import("@traqula/rules-sparql-1-1").Expression]>;
+    builtInStrbefore: import("@traqula/core").ParserRule<any, "builtInStrbefore"> & gram.RuleDefExpressionFunctionX<"builtInStrbefore", [import("@traqula/rules-sparql-1-1").Expression, import("@traqula/rules-sparql-1-1").Expression]>;
+    builtInStrafter: import("@traqula/core").ParserRule<any, "builtInStrafter"> & gram.RuleDefExpressionFunctionX<"builtInStrafter", [import("@traqula/rules-sparql-1-1").Expression, import("@traqula/rules-sparql-1-1").Expression]>;
+    builtInYear: import("@traqula/core").ParserRule<any, "builtInYear"> & gram.RuleDefExpressionFunctionX<"builtInYear", [import("@traqula/rules-sparql-1-1").Expression]>;
+    builtInMonth: import("@traqula/core").ParserRule<any, "builtInMonth"> & gram.RuleDefExpressionFunctionX<"builtInMonth", [import("@traqula/rules-sparql-1-1").Expression]>;
+    builtInDay: import("@traqula/core").ParserRule<any, "builtInDay"> & gram.RuleDefExpressionFunctionX<"builtInDay", [import("@traqula/rules-sparql-1-1").Expression]>;
+    builtInHours: import("@traqula/core").ParserRule<any, "builtInHours"> & gram.RuleDefExpressionFunctionX<"builtInHours", [import("@traqula/rules-sparql-1-1").Expression]>;
+    builtInMinutes: import("@traqula/core").ParserRule<any, "builtInMinutes"> & gram.RuleDefExpressionFunctionX<"builtInMinutes", [import("@traqula/rules-sparql-1-1").Expression]>;
+    builtInSeconds: import("@traqula/core").ParserRule<any, "builtInSeconds"> & gram.RuleDefExpressionFunctionX<"builtInSeconds", [import("@traqula/rules-sparql-1-1").Expression]>;
+    builtInTimezone: import("@traqula/core").ParserRule<any, "builtInTimezone"> & gram.RuleDefExpressionFunctionX<"builtInTimezone", [import("@traqula/rules-sparql-1-1").Expression]>;
+    builtInTz: import("@traqula/core").ParserRule<any, "builtInTz"> & gram.RuleDefExpressionFunctionX<"builtInTz", [import("@traqula/rules-sparql-1-1").Expression]>;
+    builtInNow: import("@traqula/core").ParserRule<any, "builtInNow"> & gram.RuleDefExpressionFunctionX<"builtInNow", []>;
+    builtInUuid: import("@traqula/core").ParserRule<any, "builtInUuid"> & gram.RuleDefExpressionFunctionX<"builtInUuid", []>;
+    builtInStruuid: import("@traqula/core").ParserRule<any, "builtInStruuid"> & gram.RuleDefExpressionFunctionX<"builtInStruuid", []>;
+    builtInMd5: import("@traqula/core").ParserRule<any, "builtInMd5"> & gram.RuleDefExpressionFunctionX<"builtInMd5", [import("@traqula/rules-sparql-1-1").Expression]>;
+    builtInSha1: import("@traqula/core").ParserRule<any, "builtInSha1"> & gram.RuleDefExpressionFunctionX<"builtInSha1", [import("@traqula/rules-sparql-1-1").Expression]>;
+    builtInSha256: import("@traqula/core").ParserRule<any, "builtInSha256"> & gram.RuleDefExpressionFunctionX<"builtInSha256", [import("@traqula/rules-sparql-1-1").Expression]>;
+    builtInSha384: import("@traqula/core").ParserRule<any, "builtInSha384"> & gram.RuleDefExpressionFunctionX<"builtInSha384", [import("@traqula/rules-sparql-1-1").Expression]>;
+    builtInSha512: import("@traqula/core").ParserRule<any, "builtInSha512"> & gram.RuleDefExpressionFunctionX<"builtInSha512", [import("@traqula/rules-sparql-1-1").Expression]>;
+    builtInCoalesce: import("@traqula/core").ParserRule<any, "builtInCoalesce"> & gram.RuleDefExpressionFunctionX<"builtInCoalesce", import("@traqula/rules-sparql-1-1").Expression[]>;
+    builtInIf: import("@traqula/core").ParserRule<any, "builtInIf"> & gram.RuleDefExpressionFunctionX<"builtInIf", [import("@traqula/rules-sparql-1-1").Expression, import("@traqula/rules-sparql-1-1").Expression, import("@traqula/rules-sparql-1-1").Expression]>;
+    builtInStrlang: import("@traqula/core").ParserRule<any, "builtInStrlang"> & gram.RuleDefExpressionFunctionX<"builtInStrlang", [import("@traqula/rules-sparql-1-1").Expression, import("@traqula/rules-sparql-1-1").Expression]>;
+    builtInStrdt: import("@traqula/core").ParserRule<any, "builtInStrdt"> & gram.RuleDefExpressionFunctionX<"builtInStrdt", [import("@traqula/rules-sparql-1-1").Expression, import("@traqula/rules-sparql-1-1").Expression]>;
+    builtInSameterm: import("@traqula/core").ParserRule<any, "builtInSameterm"> & gram.RuleDefExpressionFunctionX<"builtInSameterm", [import("@traqula/rules-sparql-1-1").Expression, import("@traqula/rules-sparql-1-1").Expression]>;
+    builtInIsiri: import("@traqula/core").ParserRule<any, "builtInIsiri"> & gram.RuleDefExpressionFunctionX<"builtInIsiri", [import("@traqula/rules-sparql-1-1").Expression]>;
+    builtInIsuri: import("@traqula/core").ParserRule<any, "builtInIsuri"> & gram.RuleDefExpressionFunctionX<"builtInIsuri", [import("@traqula/rules-sparql-1-1").Expression]>;
+    builtInIsblank: import("@traqula/core").ParserRule<any, "builtInIsblank"> & gram.RuleDefExpressionFunctionX<"builtInIsblank", [import("@traqula/rules-sparql-1-1").Expression]>;
+    builtInIsliteral: import("@traqula/core").ParserRule<any, "builtInIsliteral"> & gram.RuleDefExpressionFunctionX<"builtInIsliteral", [import("@traqula/rules-sparql-1-1").Expression]>;
+    builtInIsnumeric: import("@traqula/core").ParserRule<any, "builtInIsnumeric"> & gram.RuleDefExpressionFunctionX<"builtInIsnumeric", [import("@traqula/rules-sparql-1-1").Expression]>;
+    builtInRegex: import("@traqula/core").ParserRule<any, "builtInRegex"> & gram.RuleDefExpressionFunctionX<"builtInRegex", [import("@traqula/rules-sparql-1-1").Expression, import("@traqula/rules-sparql-1-1").Expression] | [import("@traqula/rules-sparql-1-1").Expression, import("@traqula/rules-sparql-1-1").Expression, import("@traqula/rules-sparql-1-1").Expression]>;
+    builtInSubstr: import("@traqula/core").ParserRule<any, "builtInSubstr"> & gram.RuleDefExpressionFunctionX<"builtInSubstr", [import("@traqula/rules-sparql-1-1").Expression, import("@traqula/rules-sparql-1-1").Expression] | [import("@traqula/rules-sparql-1-1").Expression, import("@traqula/rules-sparql-1-1").Expression, import("@traqula/rules-sparql-1-1").Expression]>;
+    builtInReplace: import("@traqula/core").ParserRule<any, "builtInReplace"> & gram.RuleDefExpressionFunctionX<"builtInReplace", [import("@traqula/rules-sparql-1-1").Expression, import("@traqula/rules-sparql-1-1").Expression, import("@traqula/rules-sparql-1-1").Expression] | [import("@traqula/rules-sparql-1-1").Expression, import("@traqula/rules-sparql-1-1").Expression, import("@traqula/rules-sparql-1-1").Expression, import("@traqula/rules-sparql-1-1").Expression]>;
+    builtInExists: import("@traqula/core").ParserRule<any, "builtInExists"> & gram.RuleDefExpressionFunctionX<"builtInExists", [import("@traqula/rules-sparql-1-1").Pattern]>;
+    builtInNotexists: import("@traqula/core").ParserRule<any, "builtInNotexists"> & gram.RuleDefExpressionFunctionX<"builtInNotexists", [import("@traqula/rules-sparql-1-1").Pattern]>;
+    builtInCount: import("@traqula/core").ParserRule<any, "builtInCount"> & gram.RuleDefExpressionAggregatorX<"builtInCount">;
+    builtInSum: import("@traqula/core").ParserRule<any, "builtInSum"> & gram.RuleDefExpressionAggregatorX<"builtInSum">;
+    builtInMin: import("@traqula/core").ParserRule<any, "builtInMin"> & gram.RuleDefExpressionAggregatorX<"builtInMin">;
+    builtInMax: import("@traqula/core").ParserRule<any, "builtInMax"> & gram.RuleDefExpressionAggregatorX<"builtInMax">;
+    builtInAvg: import("@traqula/core").ParserRule<any, "builtInAvg"> & gram.RuleDefExpressionAggregatorX<"builtInAvg">;
+    builtInSample: import("@traqula/core").ParserRule<any, "builtInSample"> & gram.RuleDefExpressionAggregatorX<"builtInSample">;
+    builtInGroup_concat: import("@traqula/core").ParserRule<any, "builtInGroup_concat"> & SparqlGrammarRule<"builtInGroup_concat", import("@traqula/rules-sparql-1-1").AggregateExpression>;
+    quads: import("@traqula/core").ParserRule<any, "quads"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "quads", import("@traqula/rules-sparql-1-1").Quads[], undefined> & import("@traqula/core").GeneratorRule<undefined, "quads", import("@traqula/rules-sparql-1-1").Quads[], undefined>;
+    functionCall: import("@traqula/core").ParserRule<any, "functionCall"> & SparqlGrammarRule<"functionCall", import("@traqula/rules-sparql-1-1").FunctionCallExpression>;
+    create: import("@traqula/core").ParserRule<any, "create"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "create", import("@traqula/rules-sparql-1-1").CreateOperation, undefined> & import("@traqula/core").GeneratorRule<undefined, "create", import("@traqula/rules-sparql-1-1").CreateOperation, undefined>;
+    bind: import("@traqula/core").ParserRule<any, "bind"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "bind", import("@traqula/rules-sparql-1-1").BindPattern, undefined> & import("@traqula/core").GeneratorRule<undefined, "bind", import("@traqula/rules-sparql-1-1").BindPattern, undefined>;
+    aggregate: import("@traqula/core").ParserRule<any, "aggregate"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "aggregate", import("@traqula/rules-sparql-1-1").AggregateExpression, undefined> & import("@traqula/core").GeneratorRule<undefined, "aggregate", import("@traqula/rules-sparql-1-1").AggregateExpression, undefined>;
+    rdfLiteral: import("@traqula/core").ParserRule<any, "rdfLiteral"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "rdfLiteral", import("@rdfjs/types").Literal, undefined> & import("@traqula/core").GeneratorRule<undefined, "rdfLiteral", import("@rdfjs/types").Literal, undefined>;
+    iri: import("@traqula/core").ParserRule<any, "iri"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "iri", import("@traqula/rules-sparql-1-1").IriTerm, undefined> & import("@traqula/core").GeneratorRule<undefined, "iri", import("@traqula/rules-sparql-1-1").IriTerm, undefined>;
+    numericLiteral: import("@traqula/core").ParserRule<any, "numericLiteral"> & SparqlGrammarRule<"numericLiteral", import("@rdfjs/types").Literal>;
+    numericLiteralUnsigned: import("@traqula/core").ParserRule<any, "numericLiteralUnsigned"> & SparqlGrammarRule<"numericLiteralUnsigned", import("@rdfjs/types").Literal>;
+    numericLiteralPositive: import("@traqula/core").ParserRule<any, "numericLiteralPositive"> & SparqlGrammarRule<"numericLiteralPositive", import("@rdfjs/types").Literal>;
+    numericLiteralNegative: import("@traqula/core").ParserRule<any, "numericLiteralNegative"> & SparqlGrammarRule<"numericLiteralNegative", import("@rdfjs/types").Literal>;
+    booleanLiteral: import("@traqula/core").ParserRule<any, "booleanLiteral"> & SparqlGrammarRule<"booleanLiteral", import("@rdfjs/types").Literal>;
+    prefixedName: import("@traqula/core").ParserRule<any, "prefixedName"> & SparqlGrammarRule<"prefixedName", import("@traqula/rules-sparql-1-1").IriTerm>;
+    blankNode: import("@traqula/core").ParserRule<any, "blankNode"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "blankNode", import("@rdfjs/types").BlankNode, undefined> & import("@traqula/core").GeneratorRule<undefined, "blankNode", import("@rdfjs/types").BlankNode, undefined>;
+    datasetClause: import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "datasetClause", gram.IDatasetClause, undefined>;
+    defaultGraphClause: import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "defaultGraphClause", import("@traqula/rules-sparql-1-1").IriTerm, undefined>;
+    namedGraphClause: import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "namedGraphClause", import("@traqula/rules-sparql-1-1").IriTerm, undefined>;
+    sourceSelector: import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "sourceSelector", import("@traqula/rules-sparql-1-1").IriTerm, undefined>;
+    prologue: import("@traqula/core").ParserRule<any, "prologue"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "prologue", Pick<import("@traqula/rules-sparql-1-1").BaseQuery, "base" | "prefixes">, undefined> & import("@traqula/core").GeneratorRule<undefined, "prologue", Pick<import("@traqula/rules-sparql-1-1").BaseQuery, "base" | "prefixes">, undefined>;
+    baseDecl: import("@traqula/core").ParserRule<any, "baseDecl"> & SparqlGrammarRule<"baseDecl", string>;
+    prefixDecl: import("@traqula/core").ParserRule<any, "prefixDecl"> & SparqlGrammarRule<"prefixDecl", [string, string]>;
+    verb: import("@traqula/core").ParserRule<any, "verb"> & SparqlGrammarRule<"verb", import("@rdfjs/types").Variable | import("@traqula/rules-sparql-1-1").IriTerm>;
+    varOrIri: import("@traqula/core").ParserRule<any, "varOrIri"> & SparqlGrammarRule<"varOrIri", import("@rdfjs/types").Variable | import("@traqula/rules-sparql-1-1").IriTerm>;
+    VerbA: import("@traqula/core").ParserRule<any, "VerbA"> & SparqlGrammarRule<"VerbA", import("@traqula/rules-sparql-1-1").VerbA>;
+    varOrTerm: import("@traqula/core").ParserRule<any, "varOrTerm"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "varOrTerm", import("@traqula/rules-sparql-1-1").Term, undefined> & import("@traqula/core").GeneratorRule<undefined, "varOrTerm", import("@traqula/rules-sparql-1-1").Term, undefined>;
+    graphTerm: import("@traqula/core").ParserRule<any, "graphTerm"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "graphTerm", import("@traqula/rules-sparql-1-1").GraphTerm, undefined> & import("@traqula/core").GeneratorRule<undefined, "graphTerm", import("@traqula/rules-sparql-1-1").GraphTerm, undefined>;
+    pathAlternative: import("@traqula/core").ParserRule<any, "pathAlternative"> & SparqlGrammarRule<"pathAlternative", import("@traqula/rules-sparql-1-1").PropertyPath | import("@traqula/rules-sparql-1-1").IriTerm>;
+    pathSequence: import("@traqula/core").ParserRule<any, "pathSequence"> & SparqlGrammarRule<"pathSequence", import("@traqula/rules-sparql-1-1").PropertyPath | import("@traqula/rules-sparql-1-1").IriTerm>;
+    pathEltOrInverse: import("@traqula/core").ParserRule<any, "pathEltOrInverse"> & SparqlGrammarRule<"pathEltOrInverse", import("@traqula/rules-sparql-1-1").PropertyPath | import("@traqula/rules-sparql-1-1").IriTerm>;
+    pathElt: import("@traqula/core").ParserRule<any, "pathElt"> & SparqlGrammarRule<"pathElt", import("@traqula/rules-sparql-1-1").PropertyPath | import("@traqula/rules-sparql-1-1").IriTerm>;
+    pathMod: import("@traqula/core").ParserRule<any, "pathMod"> & SparqlGrammarRule<"pathMod", "?" | "*" | "+">;
+    pathPrimary: import("@traqula/core").ParserRule<any, "pathPrimary"> & SparqlGrammarRule<"pathPrimary", import("@traqula/rules-sparql-1-1").PropertyPath | import("@traqula/rules-sparql-1-1").IriTerm>;
+    pathNegatedPropertySet: import("@traqula/core").ParserRule<any, "pathNegatedPropertySet"> & SparqlGrammarRule<"pathNegatedPropertySet", [import("@traqula/rules-sparql-1-1").IriTermOrElt] | [{
+        type: "path";
+        pathType: "|";
+        items: (import("@traqula/rules-sparql-1-1").IriTermOrElt)[];
+    }]>;
+    pathOneInPropertySet: import("@traqula/core").ParserRule<any, "pathOneInPropertySet"> & SparqlGrammarRule<"pathOneInPropertySet", import("@traqula/rules-sparql-1-1").IriTermOrElt>;
+    triplesBlock: import("@traqula/core").ParserRule<any, "triplesBlock"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "triplesBlock", import("@traqula/rules-sparql-1-1").BgpPattern, undefined> & import("@traqula/core").GeneratorRule<undefined, "triplesBlock", import("@traqula/rules-sparql-1-1").BgpPattern, undefined>;
+    triplesSameSubjectPath: import("@traqula/core").ParserRule<any, "triplesSameSubjectPath"> & SparqlGrammarRule<"triplesSameSubjectPath", import("@traqula/rules-sparql-1-1").Triple[]>;
+    propertyListPathNotEmpty: import("@traqula/core").ParserRule<any, "propertyListPathNotEmpty"> & SparqlGrammarRule<"propertyListPathNotEmpty", import("@traqula/rules-sparql-1-1").Triple[], Pick<import("@traqula/rules-sparql-1-1").Triple, "subject">>;
+    propertyListNotEmpty: import("@traqula/core").ParserRule<any, "propertyListNotEmpty"> & SparqlGrammarRule<"propertyListNotEmpty", import("@traqula/rules-sparql-1-1").Triple[], Pick<import("@traqula/rules-sparql-1-1").Triple, "subject">>;
+    propertyListPath: import("@traqula/core").ParserRule<any, "propertyListPath"> & SparqlGrammarRule<"propertyListPath", import("@traqula/rules-sparql-1-1").Triple[], Pick<import("@traqula/rules-sparql-1-1").Triple, "subject">>;
+    propertyList: import("@traqula/core").ParserRule<any, "propertyList"> & SparqlGrammarRule<"propertyList", import("@traqula/rules-sparql-1-1").Triple[], Pick<import("@traqula/rules-sparql-1-1").Triple, "subject">>;
+    triplesNodePath: import("@traqula/core").ParserRule<any, "triplesNodePath"> & SparqlGrammarRule<"triplesNodePath", import("@traqula/rules-sparql-1-1").ITriplesNode>;
+    triplesNode: import("@traqula/core").ParserRule<any, "triplesNode"> & SparqlGrammarRule<"triplesNode", import("@traqula/rules-sparql-1-1").ITriplesNode>;
+    triplesSameSubject: import("@traqula/core").ParserRule<any, "triplesSameSubject"> & SparqlGrammarRule<"triplesSameSubject", import("@traqula/rules-sparql-1-1").Triple[]>;
+    triplesTemplate: import("@traqula/core").ParserRule<any, "triplesTemplate"> & SparqlGrammarRule<"triplesTemplate", import("@traqula/rules-sparql-1-1").Triple[]>;
+    verbPath: import("@traqula/core").ParserRule<any, "verbPath"> & SparqlGrammarRule<"verbPath", import("@traqula/rules-sparql-1-1").PropertyPath | import("@traqula/rules-sparql-1-1").IriTerm>;
+    verbSimple: import("@traqula/core").ParserRule<any, "verbSimple"> & SparqlGrammarRule<"verbSimple", import("@rdfjs/types").Variable>;
+    objectList: import("@traqula/core").ParserRule<any, "objectList"> & SparqlGrammarRule<"objectList", import("@traqula/rules-sparql-1-1").Triple[], Pick<import("@traqula/rules-sparql-1-1").Triple, "subject" | "predicate">>;
+    objectListPath: import("@traqula/core").ParserRule<any, "objectListPath"> & SparqlGrammarRule<"objectListPath", import("@traqula/rules-sparql-1-1").Triple[], Pick<import("@traqula/rules-sparql-1-1").Triple, "subject" | "predicate">>;
+    graphNodePath: import("@traqula/core").ParserRule<any, "graphNodePath"> & SparqlGrammarRule<"graphNodePath", import("@traqula/rules-sparql-1-1").IGraphNode>;
+    graphNode: import("@traqula/core").ParserRule<any, "graphNode"> & SparqlGrammarRule<"graphNode", import("@traqula/rules-sparql-1-1").IGraphNode>;
+    objectPath: import("@traqula/core").ParserRule<any, "objectPath"> & SparqlGrammarRule<"objectPath", import("@traqula/rules-sparql-1-1").Triple[], Pick<import("@traqula/rules-sparql-1-1").Triple, "subject" | "predicate">>;
+    collection: import("@traqula/core").ParserRule<any, "collection"> & SparqlGrammarRule<"collection", import("@traqula/rules-sparql-1-1").ITriplesNode>;
+    blankNodePropertyList: import("@traqula/core").ParserRule<any, "blankNodePropertyList"> & SparqlGrammarRule<"blankNodePropertyList", import("@traqula/rules-sparql-1-1").ITriplesNode>;
+    collectionPath: import("@traqula/core").ParserRule<any, "collectionPath"> & SparqlGrammarRule<"collectionPath", import("@traqula/rules-sparql-1-1").ITriplesNode>;
+    blankNodePropertyListPath: import("@traqula/core").ParserRule<any, "blankNodePropertyListPath"> & SparqlGrammarRule<"blankNodePropertyListPath", import("@traqula/rules-sparql-1-1").ITriplesNode>;
+    whereClause: import("@traqula/core").ParserRule<any, "whereClause"> & SparqlGrammarRule<"whereClause", import("@traqula/rules-sparql-1-1").Pattern[]>;
+    groupGraphPattern: import("@traqula/core").ParserRule<any, "groupGraphPattern"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "groupGraphPattern", import("@traqula/rules-sparql-1-1").GroupPattern, undefined> & import("@traqula/core").GeneratorRule<undefined, "groupGraphPattern", import("@traqula/rules-sparql-1-1").GroupPattern, undefined>;
+    subSelect: import("@traqula/core").ParserRule<any, "subSelect"> & SparqlGrammarRule<"subSelect", Omit<import("@traqula/rules-sparql-1-1").SelectQuery, "prefixes">>;
+    groupGraphPatternSub: import("@traqula/core").ParserRule<any, "groupGraphPatternSub"> & SparqlGrammarRule<"groupGraphPatternSub", import("@traqula/rules-sparql-1-1").Pattern[]>;
+    graphPatternNotTriples: import("@traqula/core").ParserRule<any, "graphPatternNotTriples"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "graphPatternNotTriples", import("@traqula/rules-sparql-1-1").BlockPattern | import("@traqula/rules-sparql-1-1").FilterPattern | import("@traqula/rules-sparql-1-1").BindPattern | import("@traqula/rules-sparql-1-1").ValuesPattern, undefined> & import("@traqula/core").GeneratorRule<undefined, "graphPatternNotTriples", import("@traqula/rules-sparql-1-1").BlockPattern | import("@traqula/rules-sparql-1-1").FilterPattern | import("@traqula/rules-sparql-1-1").BindPattern | import("@traqula/rules-sparql-1-1").ValuesPattern, undefined>;
+    groupOrUnionGraphPattern: import("@traqula/core").ParserRule<any, "groupOrUnionGraphPattern"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "groupOrUnionGraphPattern", import("@traqula/rules-sparql-1-1").UnionPattern | import("@traqula/rules-sparql-1-1").GroupPattern, undefined> & import("@traqula/core").GeneratorRule<undefined, "groupOrUnionGraphPattern", import("@traqula/rules-sparql-1-1").UnionPattern | import("@traqula/rules-sparql-1-1").GroupPattern, undefined>;
+    optionalGraphPattern: import("@traqula/core").ParserRule<any, "optionalGraphPattern"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "optionalGraphPattern", import("@traqula/rules-sparql-1-1").OptionalPattern, undefined> & import("@traqula/core").GeneratorRule<undefined, "optionalGraphPattern", import("@traqula/rules-sparql-1-1").OptionalPattern, undefined>;
+    minusGraphPattern: import("@traqula/core").ParserRule<any, "minusGraphPattern"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "minusGraphPattern", import("@traqula/rules-sparql-1-1").MinusPattern, undefined> & import("@traqula/core").GeneratorRule<undefined, "minusGraphPattern", import("@traqula/rules-sparql-1-1").MinusPattern, undefined>;
+    graphGraphPattern: import("@traqula/core").ParserRule<any, "graphGraphPattern"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "graphGraphPattern", import("@traqula/rules-sparql-1-1").GraphPattern, undefined> & import("@traqula/core").GeneratorRule<undefined, "graphGraphPattern", import("@traqula/rules-sparql-1-1").GraphPattern, undefined>;
+    serviceGraphPattern: import("@traqula/core").ParserRule<any, "serviceGraphPattern"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "serviceGraphPattern", import("@traqula/rules-sparql-1-1").ServicePattern, undefined> & import("@traqula/core").GeneratorRule<undefined, "serviceGraphPattern", import("@traqula/rules-sparql-1-1").ServicePattern, undefined>;
+    inlineData: import("@traqula/core").ParserRule<any, "inlineData"> & SparqlGrammarRule<"inlineData", import("@traqula/rules-sparql-1-1").ValuesPattern>;
+    expression: import("@traqula/core").ParserRule<any, "expression"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "expression", import("@traqula/rules-sparql-1-1").Expression, undefined> & import("@traqula/core").GeneratorRule<undefined, "expression", import("@traqula/rules-sparql-1-1").Expression, undefined>;
+    valuesClause: import("@traqula/core").ParserRule<any, "valuesClause"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "valuesClause", import("@traqula/rules-sparql-1-1").ValuePatternRow[] | undefined, undefined> & import("@traqula/core").GeneratorRule<undefined, "valuesClause", import("@traqula/rules-sparql-1-1").ValuePatternRow[] | undefined, undefined>;
+    dataBlock: import("@traqula/core").ParserRule<any, "dataBlock"> & SparqlGrammarRule<"dataBlock", import("@traqula/rules-sparql-1-1").ValuePatternRow[]>;
+    inlineDataOneVar: import("@traqula/core").ParserRule<any, "inlineDataOneVar"> & SparqlGrammarRule<"inlineDataOneVar", import("@traqula/rules-sparql-1-1").ValuePatternRow[]>;
+    inlineDataFull: import("@traqula/core").ParserRule<any, "inlineDataFull"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "inlineDataFull", import("@traqula/rules-sparql-1-1").ValuePatternRow[], undefined> & import("@traqula/core").GeneratorRule<undefined, "inlineDataFull", import("@traqula/rules-sparql-1-1").ValuePatternRow[], undefined>;
+    dataBlockValue: import("@traqula/core").ParserRule<any, "dataBlockValue"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "dataBlockValue", import("@rdfjs/types").BlankNode | import("@rdfjs/types").Literal | import("@traqula/rules-sparql-1-1").IriTerm | undefined, undefined> & import("@traqula/core").GeneratorRule<undefined, "dataBlockValue", import("@rdfjs/types").BlankNode | import("@rdfjs/types").Literal | import("@traqula/rules-sparql-1-1").IriTerm | undefined, undefined>;
+    constraint: import("@traqula/core").ParserRule<any, "constraint"> & SparqlGrammarRule<"constraint", import("@traqula/rules-sparql-1-1").Expression>;
+    brackettedExpression: import("@traqula/core").ParserRule<any, "brackettedExpression"> & SparqlGrammarRule<"brackettedExpression", import("@traqula/rules-sparql-1-1").Expression>;
+    builtInCall: import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "builtInCall", import("@traqula/rules-sparql-1-1").Expression, undefined>;
+    argList: import("@traqula/core").ParserRule<any, "argList"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "argList", gram.IArgList, undefined> & import("@traqula/core").GeneratorRule<undefined, "argList", gram.IArgList, undefined>;
+    expressionList: import("@traqula/core").ParserRule<any, "expressionList"> & SparqlGrammarRule<"expressionList", import("@traqula/rules-sparql-1-1").Expression[]>;
+    conditionalOrExpression: import("@traqula/core").ParserRule<any, "conditionalOrExpression"> & SparqlGrammarRule<"conditionalOrExpression", import("@traqula/rules-sparql-1-1").Expression>;
+    iriOrFunction: import("@traqula/core").ParserRule<any, "iriOrFunction"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "iriOrFunction", import("@traqula/rules-sparql-1-1").IriTerm | (gram.IArgList & {
+        function: import("@traqula/rules-sparql-1-1").IriTerm;
+    }), undefined> & import("@traqula/core").GeneratorRule<undefined, "iriOrFunction", import("@traqula/rules-sparql-1-1").IriTerm | (gram.IArgList & {
+        function: import("@traqula/rules-sparql-1-1").IriTerm;
+    }), undefined>;
+    conditionalAndExpression: import("@traqula/core").ParserRule<any, "conditionalAndExpression"> & SparqlGrammarRule<"conditionalAndExpression", import("@traqula/rules-sparql-1-1").Expression>;
+    valueLogical: import("@traqula/core").ParserRule<any, "valueLogical"> & SparqlGrammarRule<"valueLogical", import("@traqula/rules-sparql-1-1").Expression>;
+    relationalExpression: import("@traqula/core").ParserRule<any, "relationalExpression"> & SparqlGrammarRule<"relationalExpression", import("@traqula/rules-sparql-1-1").Expression>;
+    numericExpression: import("@traqula/core").ParserRule<any, "numericExpression"> & SparqlGrammarRule<"numericExpression", import("@traqula/rules-sparql-1-1").Expression>;
+    additiveExpression: import("@traqula/core").ParserRule<any, "additiveExpression"> & SparqlGrammarRule<"additiveExpression", import("@traqula/rules-sparql-1-1").Expression>;
+    multiplicativeExpression: import("@traqula/core").ParserRule<any, "multiplicativeExpression"> & SparqlGrammarRule<"multiplicativeExpression", import("@traqula/rules-sparql-1-1").Expression>;
+    unaryExpression: import("@traqula/core").ParserRule<any, "unaryExpression"> & SparqlGrammarRule<"unaryExpression", import("@traqula/rules-sparql-1-1").Expression>;
+    primaryExpression: import("@traqula/core").ParserRule<any, "primaryExpression"> & SparqlGrammarRule<"primaryExpression", import("@traqula/rules-sparql-1-1").Expression>;
+    solutionModifier: import("@traqula/core").ParserRule<any, "solutionModifier"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "solutionModifier", gram.ISolutionModifier, undefined> & import("@traqula/core").GeneratorRule<undefined, "solutionModifier", gram.ISolutionModifier, undefined>;
+    limitOffsetClauses: import("@traqula/core").ParserRule<any, "limitOffsetClauses"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "limitOffsetClauses", Pick<import("@traqula/rules-sparql-1-1").SelectQuery, "offset" | "limit">, undefined> & import("@traqula/core").GeneratorRule<undefined, "limitOffsetClauses", Pick<import("@traqula/rules-sparql-1-1").SelectQuery, "offset" | "limit">, undefined>;
+    groupClause: import("@traqula/core").ParserRule<any, "groupClause"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "groupClause", import("@traqula/rules-sparql-1-1").Grouping[], undefined> & import("@traqula/core").GeneratorRule<undefined, "groupClause", import("@traqula/rules-sparql-1-1").Grouping[], undefined>;
+    havingClause: import("@traqula/core").ParserRule<any, "havingClause"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "havingClause", import("@traqula/rules-sparql-1-1").Expression[], undefined> & import("@traqula/core").GeneratorRule<undefined, "havingClause", import("@traqula/rules-sparql-1-1").Expression[], undefined>;
+    orderClause: import("@traqula/core").ParserRule<any, "orderClause"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "orderClause", import("@traqula/rules-sparql-1-1").Ordering[], undefined> & import("@traqula/core").GeneratorRule<undefined, "orderClause", import("@traqula/rules-sparql-1-1").Ordering[], undefined>;
+    groupCondition: import("@traqula/core").ParserRule<any, "groupCondition"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "groupCondition", import("@traqula/rules-sparql-1-1").Grouping, undefined> & import("@traqula/core").GeneratorRule<undefined, "groupCondition", import("@traqula/rules-sparql-1-1").Grouping, undefined>;
+    havingCondition: import("@traqula/core").ParserRule<any, "havingCondition"> & SparqlGrammarRule<"havingCondition", import("@traqula/rules-sparql-1-1").Expression>;
+    orderCondition: import("@traqula/core").ParserRule<any, "orderCondition"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "orderCondition", import("@traqula/rules-sparql-1-1").Ordering, undefined> & import("@traqula/core").GeneratorRule<undefined, "orderCondition", import("@traqula/rules-sparql-1-1").Ordering, undefined>;
+    limitClause: import("@traqula/core").ParserRule<any, "limitClause"> & SparqlGrammarRule<"limitClause", number>;
+    offsetClause: import("@traqula/core").ParserRule<any, "offsetClause"> & SparqlGrammarRule<"offsetClause", number>;
+    selectQuery: import("@traqula/core").ParserRule<any, "selectQuery"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "selectQuery", Omit<import("@traqula/rules-sparql-1-1").SelectQuery, gram.HandledByBase>, undefined> & import("@traqula/core").GeneratorRule<undefined, "selectQuery", Omit<import("@traqula/rules-sparql-1-1").SelectQuery, gram.HandledByBase>, undefined>;
+    constructQuery: import("@traqula/core").ParserRule<any, "constructQuery"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "constructQuery", Omit<import("@traqula/rules-sparql-1-1").ConstructQuery, gram.HandledByBase>, undefined> & import("@traqula/core").GeneratorRule<undefined, "constructQuery", Omit<import("@traqula/rules-sparql-1-1").ConstructQuery, gram.HandledByBase>, undefined>;
+    describeQuery: import("@traqula/core").ParserRule<any, "describeQuery"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "describeQuery", Omit<import("@traqula/rules-sparql-1-1").DescribeQuery, gram.HandledByBase>, undefined> & import("@traqula/core").GeneratorRule<undefined, "describeQuery", Omit<import("@traqula/rules-sparql-1-1").DescribeQuery, gram.HandledByBase>, undefined>;
+    askQuery: import("@traqula/core").ParserRule<any, "askQuery"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "askQuery", Omit<import("@traqula/rules-sparql-1-1").AskQuery, gram.HandledByBase>, undefined> & import("@traqula/core").GeneratorRule<undefined, "askQuery", Omit<import("@traqula/rules-sparql-1-1").AskQuery, gram.HandledByBase>, undefined>;
+    selectClause: import("@traqula/core").ParserRule<any, "selectClause"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "selectClause", gram.ISelectClause, undefined> & import("@traqula/core").GeneratorRule<undefined, "selectClause", gram.ISelectClause, undefined>;
+    constructTemplate: import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "constructTemplate", import("@traqula/rules-sparql-1-1").Triple[] | undefined, undefined>;
+    constructTriples: import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "constructTriples", import("@traqula/rules-sparql-1-1").Triple[], undefined>;
+    update1: import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "update1", import("@traqula/rules-sparql-1-1").UpdateOperation, undefined>;
+    insertData: import("@traqula/core").ParserRule<any, "insertData"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "insertData", import("@traqula/rules-sparql-1-1").InsertOperation, undefined> & import("@traqula/core").GeneratorRule<undefined, "insertData", import("@traqula/rules-sparql-1-1").InsertOperation, undefined>;
+    deleteData: import("@traqula/core").ParserRule<any, "deleteData"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "deleteData", import("@traqula/rules-sparql-1-1").DeleteOperation, undefined> & import("@traqula/core").GeneratorRule<undefined, "deleteData", import("@traqula/rules-sparql-1-1").DeleteOperation, undefined>;
+    deleteWhere: import("@traqula/core").ParserRule<any, "deleteWhere"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "deleteWhere", import("@traqula/rules-sparql-1-1").DeleteWhereOperation, undefined> & import("@traqula/core").GeneratorRule<undefined, "deleteWhere", import("@traqula/rules-sparql-1-1").DeleteWhereOperation, undefined>;
+    modify: import("@traqula/core").ParserRule<any, "modify"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "modify", import("@traqula/rules-sparql-1-1").ModifyOperation, undefined> & import("@traqula/core").GeneratorRule<undefined, "modify", import("@traqula/rules-sparql-1-1").ModifyOperation, undefined>;
+    graphRef: import("@traqula/core").ParserRule<any, "graphRef"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "graphRef", import("@traqula/rules-sparql-1-1").IriTerm, undefined> & import("@traqula/core").GeneratorRule<undefined, "graphRef", import("@traqula/rules-sparql-1-1").IriTerm, undefined>;
+    graphRefAll: import("@traqula/core").ParserRule<any, "graphRefAll"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "graphRefAll", import("@traqula/rules-sparql-1-1").GraphReference, undefined> & import("@traqula/core").GeneratorRule<undefined, "graphRefAll", import("@traqula/rules-sparql-1-1").GraphReference, undefined>;
+    graphOrDefault: import("@traqula/core").ParserRule<any, "graphOrDefault"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "graphOrDefault", import("@traqula/rules-sparql-1-1").GraphOrDefault, undefined> & import("@traqula/core").GeneratorRule<undefined, "graphOrDefault", import("@traqula/rules-sparql-1-1").GraphOrDefault, undefined>;
+    quadData: import("@traqula/core").ParserRule<any, "quadData"> & import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "quadData", import("@traqula/rules-sparql-1-1").Quads[], undefined> & import("@traqula/core").GeneratorRule<undefined, "quadData", import("@traqula/rules-sparql-1-1").Quads[], undefined>;
+    quadPattern: import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "quadPattern", import("@traqula/rules-sparql-1-1").Quads[], undefined>;
+    deleteClause: import("@traqula/core").ParserRule<any, "deleteClause"> & SparqlGrammarRule<"deleteClause", import("@traqula/rules-sparql-1-1").Quads[]>;
+    insertClause: import("@traqula/core").ParserRule<any, "insertClause"> & SparqlGrammarRule<"insertClause", import("@traqula/rules-sparql-1-1").Quads[]>;
+    usingClause: import("@traqula/core").ParserRule<any, "usingClause"> & SparqlGrammarRule<"usingClause", {
+        value: import("@traqula/rules-sparql-1-1").IriTerm;
+        type: "default" | "named";
+    }>;
+    quadsNotTriples: import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "quadsNotTriples", import("@traqula/rules-sparql-1-1").GraphQuads, undefined>;
+    queryOrUpdate: import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "queryOrUpdate", Query | Update | Pick<Update, "base" | "prefixes">, undefined>;
+}>;
+export declare class Parser extends SparqlParser<SparqlQuery> {
+    constructor();
+}

package/lib/Parser.js

@@ -0,0 +1,111 @@
+import { ParserBuilder } from '@traqula/core';
+import { sparqlCodepointEscape, gram, lex as l, SparqlParser } from '@traqula/rules-sparql-1-1';
+import { queryUnitParserBuilder } from './queryUnitParser';
+import { updateParserBuilder } from './updateUnitParser';
+// Create merge of
+// ```
+// Prologue
+// ( SelectQuery | ConstructQuery | DescribeQuery | AskQuery )
+// ValuesClause
+// ```
+// and:
+// ```
+// Prologue ( Update1 ( ';' Update )? )?
+// ```
+const queryOrUpdate = {
+    name: 'queryOrUpdate',
+    impl: ({ ACTION, SUBRULE, SUBRULE2, OR1, OR2, CONSUME, OPTION1, MANY }) => () => {
+        const prologueValues = SUBRULE(gram.prologue, undefined);
+        return OR1([
+            { ALT: () => {
+                    const queryType = OR2([
+                        { ALT: () => SUBRULE(gram.selectQuery, undefined) },
+                        { ALT: () => SUBRULE(gram.constructQuery, undefined) },
+                        { ALT: () => SUBRULE(gram.describeQuery, undefined) },
+                        { ALT: () => SUBRULE(gram.askQuery, undefined) },
+                    ]);
+                    const values = SUBRULE(gram.valuesClause, undefined);
+                    return ACTION(() => ({
+                        ...prologueValues,
+                        ...queryType,
+                        type: 'query',
+                        ...(values && { values }),
+                    }));
+                } },
+            { ALT: () => {
+                    // Prologue ( Update1 ( ';' Update )? )?
+                    // Is equivalent to:
+                    let parsedSemi = true;
+                    const updateResult = {
+                        ...prologueValues,
+                        type: 'update',
+                        updates: [],
+                    };
+                    MANY({
+                        GATE: () => parsedSemi,
+                        DEF: () => {
+                            parsedSemi = false;
+                            const updateOperation = SUBRULE(gram.update1, undefined);
+                            updateResult.updates.push(updateOperation);
+                            OPTION1(() => {
+                                CONSUME(l.symbols.semi);
+                                const prologueValues = SUBRULE2(gram.prologue, undefined);
+                                ACTION(() => {
+                                    updateResult.base = prologueValues.base ?? updateResult.base;
+                                    updateResult.prefixes = prologueValues.prefixes ?
+                                        { ...updateResult.prefixes, ...prologueValues.prefixes } :
+                                        updateResult.prefixes;
+                                });
+                                parsedSemi = true;
+                            });
+                        },
+                    });
+                    ACTION(() => {
+                        const blankLabelsUsedInInsertData = new Set();
+                        for (const updateOperation of updateResult.updates) {
+                            const iterBlankNodes = (callback) => {
+                                if ('updateType' in updateOperation && updateOperation.updateType === 'insert') {
+                                    for (const quad of updateOperation.insert) {
+                                        for (const triple of quad.triples) {
+                                            for (const position of ['subject', 'object']) {
+                                                if (triple[position].termType === 'BlankNode') {
+                                                    callback(triple[position].value);
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            };
+                            iterBlankNodes((label) => {
+                                if (blankLabelsUsedInInsertData.has(label)) {
+                                    throw new Error('Detected reuse blank node across different INSERT DATA clauses');
+                                }
+                            });
+                            iterBlankNodes(label => blankLabelsUsedInInsertData.add(label));
+                        }
+                    });
+                    return updateResult.updates.length > 0 ? updateResult : prologueValues;
+                } },
+        ]);
+    },
+};
+export const sparql11ParserBuilder = ParserBuilder.createBuilder(queryUnitParserBuilder)
+    .merge(updateParserBuilder, [])
+    .deleteRule('queryUnit')
+    .deleteRule('query')
+    .deleteRule('updateUnit')
+    .deleteRule('update')
+    .addRule(queryOrUpdate);
+export class Parser extends SparqlParser {
+    constructor() {
+        const parser = sparql11ParserBuilder.build({
+            tokenVocabulary: l.sparql11Tokens.tokenVocabulary,
+            queryPreProcessor: sparqlCodepointEscape,
+            parserConfig: {
+                skipValidations: true,
+            },
+        });
+        super(parser);
+    }
+}
+//# sourceMappingURL=Parser.js.map

package/lib/Parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Parser.js","sourceRoot":"","sources":["Parser.ts"],"names":[],"mappings":"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","sourcesContent":["import { ParserBuilder } from '@traqula/core';\nimport type { Query, SparqlQuery, Update, SparqlGrammarRule } from '@traqula/rules-sparql-1-1';\nimport { sparqlCodepointEscape, gram, lex as l, SparqlParser } from '@traqula/rules-sparql-1-1';\nimport { queryUnitParserBuilder } from './queryUnitParser';\nimport { updateParserBuilder } from './updateUnitParser';\n\n// Create merge of\n// ```\n// Prologue\n// ( SelectQuery | ConstructQuery | DescribeQuery | AskQuery )\n// ValuesClause\n// ```\n// and:\n// ```\n// Prologue ( Update1 ( ';' Update )? )?\n// ```\nconst queryOrUpdate: SparqlGrammarRule<'queryOrUpdate', Query | Update | Pick<Update, 'base' | 'prefixes'>> = {\n  name: 'queryOrUpdate',\n  impl: ({ ACTION, SUBRULE, SUBRULE2, OR1, OR2, CONSUME, OPTION1, MANY }) => () => {\n    const prologueValues = SUBRULE(gram.prologue, undefined);\n    return OR1<Query | Update | Pick<Update, 'base' | 'prefixes'>>([\n      { ALT: () => {\n        const queryType = OR2<Omit<Query, gram.HandledByBase>>([\n          { ALT: () => SUBRULE(gram.selectQuery, undefined) },\n          { ALT: () => SUBRULE(gram.constructQuery, undefined) },\n          { ALT: () => SUBRULE(gram.describeQuery, undefined) },\n          { ALT: () => SUBRULE(gram.askQuery, undefined) },\n        ]);\n        const values = SUBRULE(gram.valuesClause, undefined);\n        return ACTION(() => (<Query>{\n          ...prologueValues,\n          ...queryType,\n          type: 'query',\n          ...(values && { values }),\n        }));\n      } },\n      { ALT: () => {\n        // Prologue ( Update1 ( ';' Update )? )?\n        // Is equivalent to:\n\n        let parsedSemi = true;\n        const updateResult: Update = {\n          ...prologueValues,\n          type: 'update',\n          updates: [],\n        };\n        MANY({\n          GATE: () => parsedSemi,\n          DEF: () => {\n            parsedSemi = false;\n            const updateOperation = SUBRULE(gram.update1, undefined);\n\n            updateResult.updates.push(updateOperation);\n\n            OPTION1(() => {\n              CONSUME(l.symbols.semi);\n              const prologueValues = SUBRULE2(gram.prologue, undefined);\n\n              ACTION(() => {\n                updateResult.base = prologueValues.base ?? updateResult.base;\n                updateResult.prefixes = prologueValues.prefixes ?\n                    { ...updateResult.prefixes, ...prologueValues.prefixes } :\n                  updateResult.prefixes;\n              });\n\n              parsedSemi = true;\n            });\n          },\n        });\n\n        ACTION(() => {\n          const blankLabelsUsedInInsertData = new Set<string>();\n          for (const updateOperation of updateResult.updates) {\n            const iterBlankNodes = (callback: (blankNodeLabel: string) => void): void => {\n              if ('updateType' in updateOperation && updateOperation.updateType === 'insert') {\n                for (const quad of updateOperation.insert) {\n                  for (const triple of quad.triples) {\n                    for (const position of <const> [ 'subject', 'object' ]) {\n                      if (triple[position].termType === 'BlankNode') {\n                        callback(triple[position].value);\n                      }\n                    }\n                  }\n                }\n              }\n            };\n            iterBlankNodes((label) => {\n              if (blankLabelsUsedInInsertData.has(label)) {\n                throw new Error('Detected reuse blank node across different INSERT DATA clauses');\n              }\n            });\n            iterBlankNodes(label => blankLabelsUsedInInsertData.add(label));\n          }\n        });\n\n        return updateResult.updates.length > 0 ? updateResult : prologueValues;\n      } },\n    ]);\n  },\n};\n\nexport const sparql11ParserBuilder = ParserBuilder.createBuilder(queryUnitParserBuilder)\n  .merge(updateParserBuilder, <const> [])\n  .deleteRule('queryUnit')\n  .deleteRule('query')\n  .deleteRule('updateUnit')\n  .deleteRule('update')\n  .addRule(queryOrUpdate);\n\nexport class Parser extends SparqlParser<SparqlQuery> {\n  public constructor() {\n    const parser = sparql11ParserBuilder.build({\n      tokenVocabulary: l.sparql11Tokens.tokenVocabulary,\n      queryPreProcessor: sparqlCodepointEscape,\n      parserConfig: {\n        skipValidations: true,\n      },\n    });\n    super(parser);\n  }\n}\n"]}