@traqula/parser-sparql-1-2 0.0.16 → 0.0.18

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (3) hide show
  1. package/lib/Parser.d.ts +129 -129
  2. package/lib/index.cjs +321 -196
  3. package/package.json +7 -7
package/lib/Parser.d.ts CHANGED
@@ -2,52 +2,49 @@ import { ParserBuilder } from '@traqula/core';
2
2
  import type { Patch, Wrap } from '@traqula/core';
3
3
  import { gram as g11, type TermIri } from '@traqula/rules-sparql-1-1';
4
4
  import type * as T12 from '@traqula/rules-sparql-1-2';
5
- export declare const sparql12ParserBuilder: ParserBuilder<T12.SparqlContext, "string" | "object" | "filter" | "graphRef" | "load" | "clear" | "drop" | "create" | "add" | "move" | "copy" | "modify" | "update" | "query" | "datasetClauses" | "bind" | "solutionModifier" | "expression" | "aggregate" | "functionCall" | "path" | "blankNode" | "queryUnit" | "selectQuery" | "subSelect" | "selectClause" | "constructQuery" | "describeQuery" | "askQuery" | "valuesClause" | "constructTemplate" | "constructTriples" | "updateUnit" | "update1" | "quadPattern" | "quadData" | "insertData" | "deleteData" | "deleteWhere" | "deleteClause" | "insertClause" | "graphOrDefault" | "graphRefAll" | "quads" | "quadsNotTriples" | "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" | "builtInCall" | "builtInRegex" | "builtInSubstr" | "builtInReplace" | "builtInExists" | "builtInNotexists" | "builtInCount" | "builtInSum" | "builtInMin" | "builtInMax" | "builtInAvg" | "builtInSample" | "builtInGroup_concat" | "usingClause" | "datasetClause" | "defaultGraphClause" | "usingClauses" | "namedGraphClause" | "sourceSelector" | "argList" | "expressionList" | "conditionalOrExpression" | "conditionalAndExpression" | "valueLogical" | "relationalExpression" | "numericExpression" | "additiveExpression" | "multiplicativeExpression" | "unaryExpression" | "primaryExpression" | "brackettedExpression" | "iriOrFunction" | "prologue" | "baseDecl" | "prefixDecl" | "verb" | "varOrTerm" | "varOrIri" | "var" | "rdfLiteral" | "numericLiteral" | "numericLiteralUnsigned" | "numericLiteralPositive" | "numericLiteralNegative" | "booleanLiteral" | "iri" | "iriFull" | "prefixedName" | "VerbA" | "pathEltOrInverse" | "pathSequence" | "pathAlternative" | "pathElt" | "pathMod" | "pathPrimary" | "pathNegatedPropertySet" | "pathOneInPropertySet" | "groupClause" | "groupCondition" | "havingClause" | "havingCondition" | "orderClause" | "orderCondition" | "limitOffsetClauses" | "limitClause" | "offsetClause" | "triplesBlock" | "triplesSameSubject" | "triplesSameSubjectPath" | "triplesTemplate" | "propertyList" | "propertyListPath" | "propertyListNotEmpty" | "propertyListPathNotEmpty" | "verbPath" | "verbSimple" | "objectList" | "objectListPath" | "objectPath" | "collection" | "collectionPath" | "triplesNode" | "triplesNodePath" | "blankNodePropertyList" | "blankNodePropertyListPath" | "graphNode" | "graphNodePath" | "whereClause" | "groupGraphPattern" | "groupGraphPatternSub" | "graphPatternNotTriples" | "optionalGraphPattern" | "graphGraphPattern" | "serviceGraphPattern" | "inlineData" | "dataBlock" | "inlineDataOneVar" | "inlineDataFull" | "dataBlockValue" | "minusGraphPattern" | "groupOrUnionGraphPattern" | "constraint" | "queryOrUpdate" | "reifiedTriple" | "versionDecl" | "versionSpecifier" | "reifiedTripleBlock" | "reifiedTripleBlockPath" | "varOrReifierId" | "reifier" | "annotationPath" | "annotation" | "annotationBlockPath" | "annotationBlock" | "reifiedTripleSubject" | "reifiedTripleObject" | "tripleTerm" | "tripleTermSubject" | "tripleTermObject" | "tripleTermData" | "tripleTermDataSubject" | "tripleTermDataObject" | "exprTripleTerm" | "exprTripleTermSubject" | "exprTripleTermObject" | "builtInLangdir" | "builtInStrLangdir" | "builtInHasLang" | "builtInHasLangdir" | "builtInIsTriple" | "builtInTriple" | "builtInSubject" | "builtInPredicate" | "builtInObject", {
5
+ export declare const sparql12ParserBuilder: ParserBuilder<T12.SparqlContext, "string" | "object" | "path" | "pathEltOrInverse" | "pathSequence" | "pathAlternative" | "pathElt" | "pathMod" | "pathPrimary" | "pathNegatedPropertySet" | "pathOneInPropertySet" | "queryOrUpdate" | "triplesBlock" | "triplesSameSubject" | "triplesSameSubjectPath" | "triplesTemplate" | "propertyList" | "blankNode" | "propertyListPath" | "propertyListNotEmpty" | "propertyListPathNotEmpty" | "verbPath" | "verbSimple" | "objectList" | "objectListPath" | "objectPath" | "collection" | "collectionPath" | "triplesNode" | "triplesNodePath" | "blankNodePropertyList" | "blankNodePropertyListPath" | "graphNode" | "graphNodePath" | "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" | "expression" | "conditionalOrExpression" | "conditionalAndExpression" | "valueLogical" | "relationalExpression" | "numericExpression" | "expressionList" | "additiveExpression" | "multiplicativeExpression" | "unaryExpression" | "primaryExpression" | "brackettedExpression" | "iriOrFunction" | "rdfLiteral" | "numericLiteral" | "numericLiteralUnsigned" | "numericLiteralPositive" | "numericLiteralNegative" | "booleanLiteral" | "var" | "builtInCall" | "aggregate" | "iri" | "prefixedName" | "argList" | "functionCall" | "varOrTerm" | "verb" | "VerbA" | "varOrIri" | "iriFull" | "subSelect" | "selectClause" | "whereClause" | "solutionModifier" | "valuesClause" | "query" | "groupGraphPattern" | "groupGraphPatternSub" | "graphPatternNotTriples" | "filter" | "bind" | "groupOrUnionGraphPattern" | "optionalGraphPattern" | "minusGraphPattern" | "graphGraphPattern" | "serviceGraphPattern" | "inlineData" | "constraint" | "dataBlock" | "inlineDataOneVar" | "inlineDataFull" | "dataBlockValue" | "groupClause" | "havingClause" | "orderClause" | "limitOffsetClauses" | "groupCondition" | "havingCondition" | "orderCondition" | "limitClause" | "offsetClause" | "queryUnit" | "prologue" | "selectQuery" | "constructQuery" | "describeQuery" | "askQuery" | "baseDecl" | "prefixDecl" | "datasetClause" | "datasetClauses" | "defaultGraphClause" | "namedGraphClause" | "sourceSelector" | "constructTemplate" | "constructTriples" | "update1" | "load" | "clear" | "drop" | "add" | "move" | "copy" | "create" | "insertData" | "deleteData" | "deleteWhere" | "modify" | "updateUnit" | "update" | "graphRef" | "graphRefAll" | "graphOrDefault" | "quadData" | "quads" | "quadPattern" | "quadsNotTriples" | "deleteClause" | "insertClause" | "usingClause" | "usingClauses" | "versionDecl" | "versionSpecifier" | "reifiedTripleBlock" | "reifiedTripleBlockPath" | "varOrReifierId" | "reifier" | "reifiedTriple" | "annotationPath" | "annotation" | "annotationBlockPath" | "annotationBlock" | "reifiedTripleSubject" | "reifiedTripleObject" | "tripleTerm" | "tripleTermSubject" | "tripleTermObject" | "tripleTermData" | "tripleTermDataSubject" | "tripleTermDataObject" | "exprTripleTerm" | "exprTripleTermSubject" | "exprTripleTermObject" | "builtInLangdir" | "builtInStrLangdir" | "builtInHasLang" | "builtInHasLangdir" | "builtInIsTriple" | "builtInTriple" | "builtInSubject" | "builtInPredicate" | "builtInObject", {
6
6
  string: import("@traqula/core").ParserRule<T12.SparqlContext, "string", import("@traqula/rules-sparql-1-1").TermLiteralStr, []>;
7
- object: import("@traqula/core").ParserRule<T12.SparqlContext, "object", T12.TripleNesting, [T12.GraphNode, import("@traqula/rules-sparql-1-1").TermIriFull | import("@traqula/rules-sparql-1-1").TermIriPrefixed | import("@traqula/rules-sparql-1-1").TermVariable | import("@traqula/rules-sparql-1-1").PropertyPathChain | import("@traqula/rules-sparql-1-1").PathModified | import("@traqula/rules-sparql-1-1").PathNegated]>;
8
- filter: import("@traqula/core").ParserRule<T12.SparqlContext, "filter", T12.PatternFilter, []>;
9
- graphRef: import("@traqula/core").ParserRule<T12.SparqlContext, "graphRef", import("@traqula/rules-sparql-1-1").GraphRefSpecific, []>;
10
- load: import("@traqula/core").ParserRule<T12.SparqlContext, "load", T12.UpdateOperationLoad, []>;
11
- clear: import("@traqula/core").ParserRule<T12.SparqlContext, "clear", T12.UpdateOperationClear, []>;
12
- drop: import("@traqula/core").ParserRule<T12.SparqlContext, "drop", T12.UpdateOperationDrop, []>;
13
- create: import("@traqula/core").ParserRule<T12.SparqlContext, "create", T12.UpdateOperationCreate, []>;
14
- add: import("@traqula/core").ParserRule<T12.SparqlContext, "add", T12.UpdateOperationAdd, []>;
15
- move: import("@traqula/core").ParserRule<T12.SparqlContext, "move", T12.UpdateOperationMove, []>;
16
- copy: import("@traqula/core").ParserRule<T12.SparqlContext, "copy", T12.UpdateOperationCopy, []>;
17
- modify: import("@traqula/core").ParserRule<T12.SparqlContext, "modify", T12.UpdateOperationModify, []>;
18
- update: import("@traqula/core").ParserRule<any, "update", unknown, any[]> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"update", import("@traqula/rules-sparql-1-1").Update, []> & import("@traqula/rules-sparql-1-1").SparqlGeneratorRule<"update", import("@traqula/rules-sparql-1-1").Update, []>;
19
- query: import("@traqula/core").ParserRule<any, "query", unknown, any[]> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"query", import("@traqula/rules-sparql-1-1").Query, []> & import("@traqula/rules-sparql-1-1").SparqlGeneratorRule<"query", import("@traqula/rules-sparql-1-1").Query, []>;
20
- datasetClauses: import("@traqula/core").ParserRule<T12.SparqlContext, "datasetClauses", T12.DatasetClauses, []>;
21
- bind: import("@traqula/core").ParserRule<T12.SparqlContext, "bind", T12.PatternBind, []>;
22
- solutionModifier: import("@traqula/core").ParserRule<T12.SparqlContext, "solutionModifier", T12.SolutionModifiers, []>;
23
- expression: import("@traqula/core").ParserRule<T12.SparqlContext, "expression", T12.Expression, []>;
24
- aggregate: import("@traqula/core").ParserRule<T12.SparqlContext, "aggregate", T12.ExpressionAggregate, []>;
25
- functionCall: import("@traqula/core").ParserRule<T12.SparqlContext, "functionCall", T12.ExpressionFunctionCall, []>;
7
+ object: import("@traqula/core").ParserRule<T12.SparqlContext, "object", T12.TripleNesting, [T12.GraphNode, import("@traqula/rules-sparql-1-1").TermIriFull | import("@traqula/rules-sparql-1-1").TermIriPrefixed | import("@traqula/rules-sparql-1-1").PropertyPathChain | import("@traqula/rules-sparql-1-1").PathModified | import("@traqula/rules-sparql-1-1").PathNegated | import("@traqula/rules-sparql-1-1").TermVariable]>;
26
8
  path: import("@traqula/core").ParserRule<any, "path", unknown, any[]> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"path", import("@traqula/rules-sparql-1-1").Path, []>;
9
+ pathEltOrInverse: import("@traqula/core").ParserRule<any, "pathEltOrInverse", unknown, any[]> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"pathEltOrInverse", import("@traqula/rules-sparql-1-1").Path, []>;
10
+ pathSequence: import("@traqula/core").ParserRule<any, "pathSequence", unknown, any[]> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"pathSequence", import("@traqula/rules-sparql-1-1").TermIriFull | import("@traqula/rules-sparql-1-1").TermIriPrefixed | import("@traqula/rules-sparql-1-1").PropertyPathChain | import("@traqula/rules-sparql-1-1").PathModified | import("@traqula/rules-sparql-1-1").PathNegated, []>;
11
+ pathAlternative: import("@traqula/core").ParserRule<any, "pathAlternative", unknown, any[]> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"pathAlternative", import("@traqula/rules-sparql-1-1").TermIriFull | import("@traqula/rules-sparql-1-1").TermIriPrefixed | import("@traqula/rules-sparql-1-1").PropertyPathChain | import("@traqula/rules-sparql-1-1").PathModified | import("@traqula/rules-sparql-1-1").PathNegated, []>;
12
+ pathElt: import("@traqula/core").ParserRule<any, "pathElt", unknown, any[]> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"pathElt", import("@traqula/rules-sparql-1-1").Path, []>;
13
+ pathMod: import("@traqula/core").ParserRule<any, "pathMod", unknown, any[]> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"pathMod", import("chevrotain").IToken & {
14
+ image: "*" | "+" | "?";
15
+ }, []>;
16
+ pathPrimary: import("@traqula/core").ParserRule<any, "pathPrimary", unknown, any[]> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"pathPrimary", import("@traqula/rules-sparql-1-1").Path, []>;
17
+ pathNegatedPropertySet: import("@traqula/core").ParserRule<any, "pathNegatedPropertySet", unknown, any[]> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"pathNegatedPropertySet", import("@traqula/rules-sparql-1-1").PathNegated, []>;
18
+ pathOneInPropertySet: import("@traqula/core").ParserRule<any, "pathOneInPropertySet", unknown, any[]> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"pathOneInPropertySet", TermIri | import("@traqula/rules-sparql-1-1").PathNegatedElt, []>;
19
+ queryOrUpdate: import("@traqula/core").ParserRule<T12.SparqlContext, "queryOrUpdate", T12.SparqlQuery, []>;
20
+ triplesBlock: import("@traqula/core").ParserRule<T12.SparqlContext, "triplesBlock", T12.PatternBgp, []>;
21
+ triplesSameSubject: import("@traqula/core").ParserRule<T12.SparqlContext, "triplesSameSubject", import("@traqula/rules-sparql-1-1").BasicGraphPattern, []>;
22
+ triplesSameSubjectPath: import("@traqula/core").ParserRule<T12.SparqlContext, "triplesSameSubjectPath", import("@traqula/rules-sparql-1-1").BasicGraphPattern, []>;
23
+ triplesTemplate: import("@traqula/core").ParserRule<T12.SparqlContext, "triplesTemplate", T12.PatternBgp, []>;
24
+ propertyList: import("@traqula/core").ParserRule<T12.SparqlContext, "propertyList", T12.TripleNesting[], [import("@traqula/rules-sparql-1-1").GraphNode]>;
27
25
  blankNode: import("@traqula/core").ParserRule<T12.SparqlContext, "blankNode", import("@traqula/rules-sparql-1-1").TermBlank, []>;
28
- queryUnit: import("@traqula/core").ParserRule<any, "queryUnit", unknown, any[]> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"queryUnit", import("@traqula/rules-sparql-1-1").Query, []>;
29
- selectQuery: import("@traqula/core").ParserRule<T12.SparqlContext, "selectQuery", Omit<T12.QuerySelect, g11.HandledByBase>, []>;
30
- subSelect: import("@traqula/core").ParserRule<T12.SparqlContext, "subSelect", Omit<T12.QuerySelect, "prefixes">, []>;
31
- selectClause: import("@traqula/core").ParserRule<T12.SparqlContext, "selectClause", Wrap<Pick<T12.QuerySelect, "variables" | "distinct" | "reduced">>, []>;
32
- constructQuery: import("@traqula/core").ParserRule<T12.SparqlContext, "constructQuery", Omit<T12.QueryConstruct, g11.HandledByBase>, []>;
33
- describeQuery: import("@traqula/core").ParserRule<T12.SparqlContext, "describeQuery", Omit<T12.QueryDescribe, g11.HandledByBase>, []>;
34
- askQuery: import("@traqula/core").ParserRule<T12.SparqlContext, "askQuery", Omit<T12.QueryAsk, g11.HandledByBase>, []>;
35
- valuesClause: import("@traqula/core").ParserRule<T12.SparqlContext, "valuesClause", T12.PatternValues[] | undefined, []>;
36
- constructTemplate: import("@traqula/core").ParserRule<T12.SparqlContext, "constructTemplate", Wrap<T12.PatternBgp>, []>;
37
- constructTriples: import("@traqula/core").ParserRule<T12.SparqlContext, "constructTriples", T12.PatternBgp, []>;
38
- updateUnit: import("@traqula/core").ParserRule<any, "updateUnit", unknown, any[]> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"updateUnit", import("@traqula/rules-sparql-1-1").Update, []>;
39
- update1: import("@traqula/core").ParserRule<T12.SparqlContext, "update1", T12.UpdateOperation, []>;
40
- quadPattern: import("@traqula/core").ParserRule<T12.SparqlContext, "quadPattern", Wrap<T12.Quads[]>, []>;
41
- quadData: import("@traqula/core").ParserRule<T12.SparqlContext, "quadData", Wrap<T12.Quads[]>, []>;
42
- insertData: import("@traqula/core").ParserRule<T12.SparqlContext, "insertData", T12.UpdateOperationInsertData, []>;
43
- deleteData: import("@traqula/core").ParserRule<T12.SparqlContext, "deleteData", T12.UpdateOperationDeleteData, []>;
44
- deleteWhere: import("@traqula/core").ParserRule<T12.SparqlContext, "deleteWhere", T12.UpdateOperationDeleteWhere, []>;
45
- deleteClause: import("@traqula/core").ParserRule<T12.SparqlContext, "deleteClause", Wrap<T12.Quads[]>, []>;
46
- insertClause: import("@traqula/core").ParserRule<T12.SparqlContext, "insertClause", Wrap<T12.Quads[]>, []>;
47
- graphOrDefault: import("@traqula/core").ParserRule<T12.SparqlContext, "graphOrDefault", import("@traqula/rules-sparql-1-1").GraphRefDefault | import("@traqula/rules-sparql-1-1").GraphRefSpecific, []>;
48
- graphRefAll: import("@traqula/core").ParserRule<T12.SparqlContext, "graphRefAll", import("@traqula/rules-sparql-1-1").GraphRef, []>;
49
- quads: import("@traqula/core").ParserRule<T12.SparqlContext, "quads", Wrap<T12.Quads[]>, []>;
50
- quadsNotTriples: import("@traqula/core").ParserRule<T12.SparqlContext, "quadsNotTriples", T12.GraphQuads, []>;
26
+ propertyListPath: import("@traqula/core").ParserRule<T12.SparqlContext, "propertyListPath", T12.TripleNesting[], [import("@traqula/rules-sparql-1-1").GraphNode]>;
27
+ propertyListNotEmpty: import("@traqula/core").ParserRule<T12.SparqlContext, "propertyListNotEmpty", T12.TripleNesting[], [import("@traqula/rules-sparql-1-1").GraphNode]>;
28
+ propertyListPathNotEmpty: import("@traqula/core").ParserRule<T12.SparqlContext, "propertyListPathNotEmpty", T12.TripleNesting[], [import("@traqula/rules-sparql-1-1").GraphNode]>;
29
+ verbPath: import("@traqula/core").ParserRule<T12.SparqlContext, "verbPath", import("@traqula/rules-sparql-1-1").Path, []>;
30
+ verbSimple: import("@traqula/core").ParserRule<T12.SparqlContext, "verbSimple", import("@traqula/rules-sparql-1-1").TermVariable, []>;
31
+ objectList: import("@traqula/core").ParserRule<T12.SparqlContext, "objectList", T12.TripleNesting[], [T12.GraphNode, import("@traqula/rules-sparql-1-1").TermIriFull | import("@traqula/rules-sparql-1-1").TermIriPrefixed | import("@traqula/rules-sparql-1-1").PropertyPathChain | import("@traqula/rules-sparql-1-1").PathModified | import("@traqula/rules-sparql-1-1").PathNegated | import("@traqula/rules-sparql-1-1").TermVariable]>;
32
+ objectListPath: import("@traqula/core").ParserRule<T12.SparqlContext, "objectListPath", T12.TripleNesting, [T12.GraphNode, import("@traqula/rules-sparql-1-1").TermIriFull | import("@traqula/rules-sparql-1-1").TermIriPrefixed | import("@traqula/rules-sparql-1-1").PropertyPathChain | import("@traqula/rules-sparql-1-1").PathModified | import("@traqula/rules-sparql-1-1").PathNegated | import("@traqula/rules-sparql-1-1").TermVariable]>;
33
+ objectPath: import("@traqula/core").ParserRule<T12.SparqlContext, "objectPath", T12.TripleNesting, [T12.GraphNode, import("@traqula/rules-sparql-1-1").TermIriFull | import("@traqula/rules-sparql-1-1").TermIriPrefixed | import("@traqula/rules-sparql-1-1").PropertyPathChain | import("@traqula/rules-sparql-1-1").PathModified | import("@traqula/rules-sparql-1-1").PathNegated | import("@traqula/rules-sparql-1-1").TermVariable]>;
34
+ collection: import("@traqula/core").ParserRule<T12.SparqlContext, "collection", T12.TripleCollectionList, []>;
35
+ collectionPath: import("@traqula/core").ParserRule<T12.SparqlContext, "collectionPath", T12.TripleCollectionList, []>;
36
+ triplesNode: import("@traqula/core").ParserRule<T12.SparqlContext, "triplesNode", T12.TripleCollection, []>;
37
+ triplesNodePath: import("@traqula/core").ParserRule<T12.SparqlContext, "triplesNodePath", T12.TripleCollection, []>;
38
+ blankNodePropertyList: import("@traqula/core").ParserRule<T12.SparqlContext, "blankNodePropertyList", Patch<import("@traqula/rules-sparql-1-1").TripleCollectionBlankNodeProperties, {
39
+ triples: T12.TripleNesting[];
40
+ identifier: T12.TermBlank | T12.TermVariable | T12.TermIri;
41
+ }>, []>;
42
+ blankNodePropertyListPath: import("@traqula/core").ParserRule<T12.SparqlContext, "blankNodePropertyListPath", Patch<import("@traqula/rules-sparql-1-1").TripleCollectionBlankNodeProperties, {
43
+ triples: T12.TripleNesting[];
44
+ identifier: T12.TermBlank | T12.TermVariable | T12.TermIri;
45
+ }>, []>;
46
+ graphNode: import("@traqula/core").ParserRule<T12.SparqlContext, "graphNode", T12.GraphNode, []>;
47
+ graphNodePath: import("@traqula/core").ParserRule<T12.SparqlContext, "graphNodePath", T12.GraphNode, []>;
51
48
  builtInStr: import("@traqula/core").ParserRule<T12.SparqlContext, "builtInStr", T12.ExpressionOperation, []>;
52
49
  builtInLang: import("@traqula/core").ParserRule<T12.SparqlContext, "builtInLang", T12.ExpressionOperation, []>;
53
50
  builtInLangmatches: import("@traqula/core").ParserRule<T12.SparqlContext, "builtInLangmatches", T12.ExpressionOperation, []>;
@@ -97,7 +94,6 @@ export declare const sparql12ParserBuilder: ParserBuilder<T12.SparqlContext, "st
97
94
  builtInIsblank: import("@traqula/core").ParserRule<T12.SparqlContext, "builtInIsblank", T12.ExpressionOperation, []>;
98
95
  builtInIsliteral: import("@traqula/core").ParserRule<T12.SparqlContext, "builtInIsliteral", T12.ExpressionOperation, []>;
99
96
  builtInIsnumeric: import("@traqula/core").ParserRule<T12.SparqlContext, "builtInIsnumeric", T12.ExpressionOperation, []>;
100
- builtInCall: import("@traqula/core").ParserRule<T12.SparqlContext, "builtInCall", import("@traqula/rules-sparql-1-1").Expression, []>;
101
97
  builtInRegex: import("@traqula/core").ParserRule<any, "builtInRegex", unknown, any[]> & g11.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]>;
102
98
  builtInSubstr: import("@traqula/core").ParserRule<T12.SparqlContext, "builtInSubstr", T12.ExpressionOperation, []>;
103
99
  builtInReplace: import("@traqula/core").ParserRule<T12.SparqlContext, "builtInReplace", T12.ExpressionOperation, []>;
@@ -110,146 +106,150 @@ export declare const sparql12ParserBuilder: ParserBuilder<T12.SparqlContext, "st
110
106
  builtInAvg: import("@traqula/core").ParserRule<T12.SparqlContext, "builtInAvg", T12.ExpressionAggregateDefault, []>;
111
107
  builtInSample: import("@traqula/core").ParserRule<T12.SparqlContext, "builtInSample", T12.ExpressionAggregateDefault, []>;
112
108
  builtInGroup_concat: import("@traqula/core").ParserRule<T12.SparqlContext, "builtInGroup_concat", T12.ExpressionAggregateDefault | T12.ExpressionAggregateSeparator, []>;
113
- usingClause: import("@traqula/core").ParserRule<T12.SparqlContext, "usingClause", Wrap<{
114
- clauseType: "default" | "named";
115
- value: T12.TermIri;
116
- }>, []>;
117
- datasetClause: import("@traqula/core").ParserRule<T12.SparqlContext, "datasetClause", Wrap<{
118
- clauseType: "default" | "named";
119
- value: T12.TermIri;
120
- }>, []>;
121
- defaultGraphClause: import("@traqula/core").ParserRule<T12.SparqlContext, "defaultGraphClause", TermIri, []>;
122
- usingClauses: import("@traqula/core").ParserRule<T12.SparqlContext, "usingClauses", T12.DatasetClauses, []>;
123
- namedGraphClause: import("@traqula/core").ParserRule<T12.SparqlContext, "namedGraphClause", Wrap<TermIri>, []>;
124
- sourceSelector: import("@traqula/core").ParserRule<T12.SparqlContext, "sourceSelector", TermIri, []>;
125
- argList: import("@traqula/core").ParserRule<T12.SparqlContext, "argList", Wrap<Patch<g11.IArgList, {
126
- args: T12.Expression[];
127
- }>>, []>;
128
- expressionList: import("@traqula/core").ParserRule<T12.SparqlContext, "expressionList", Wrap<T12.Expression[]>, []>;
109
+ expression: import("@traqula/core").ParserRule<T12.SparqlContext, "expression", T12.Expression, []>;
129
110
  conditionalOrExpression: import("@traqula/core").ParserRule<T12.SparqlContext, "conditionalOrExpression", T12.Expression, []>;
130
111
  conditionalAndExpression: import("@traqula/core").ParserRule<T12.SparqlContext, "conditionalAndExpression", T12.Expression, []>;
131
112
  valueLogical: import("@traqula/core").ParserRule<T12.SparqlContext, "valueLogical", T12.Expression, []>;
132
113
  relationalExpression: import("@traqula/core").ParserRule<T12.SparqlContext, "relationalExpression", T12.Expression, []>;
133
114
  numericExpression: import("@traqula/core").ParserRule<T12.SparqlContext, "numericExpression", T12.Expression, []>;
115
+ expressionList: import("@traqula/core").ParserRule<T12.SparqlContext, "expressionList", Wrap<T12.Expression[]>, []>;
134
116
  additiveExpression: import("@traqula/core").ParserRule<T12.SparqlContext, "additiveExpression", T12.Expression, []>;
135
117
  multiplicativeExpression: import("@traqula/core").ParserRule<T12.SparqlContext, "multiplicativeExpression", T12.Expression, []>;
136
118
  unaryExpression: import("@traqula/core").ParserRule<T12.SparqlContext, "unaryExpression", T12.Expression, []>;
137
119
  primaryExpression: import("@traqula/core").ParserRule<T12.SparqlContext, "primaryExpression", T12.Expression, []>;
138
120
  brackettedExpression: import("@traqula/core").ParserRule<T12.SparqlContext, "brackettedExpression", T12.Expression, []>;
139
121
  iriOrFunction: import("@traqula/core").ParserRule<T12.SparqlContext, "iriOrFunction", TermIri | T12.ExpressionFunctionCall, []>;
140
- prologue: import("@traqula/core").ParserRule<T12.SparqlContext, "prologue", T12.ContextDefinition[], []>;
141
- baseDecl: import("@traqula/core").ParserRule<T12.SparqlContext, "baseDecl", T12.ContextDefinition, []>;
142
- prefixDecl: import("@traqula/core").ParserRule<T12.SparqlContext, "prefixDecl", T12.ContextDefinition, []>;
143
- verb: import("@traqula/core").ParserRule<T12.SparqlContext, "verb", TermIri | import("@traqula/rules-sparql-1-1").TermVariable, []>;
144
- varOrTerm: import("@traqula/core").ParserRule<T12.SparqlContext, "varOrTerm", T12.Term, []>;
145
- varOrIri: import("@traqula/core").ParserRule<T12.SparqlContext, "varOrIri", TermIri | import("@traqula/rules-sparql-1-1").TermVariable, []>;
146
- var: import("@traqula/core").ParserRule<T12.SparqlContext, "var", import("@traqula/rules-sparql-1-1").TermVariable, []>;
147
122
  rdfLiteral: import("@traqula/core").ParserRule<T12.SparqlContext, "rdfLiteral", import("@traqula/rules-sparql-1-1").TermLiteral, []>;
148
123
  numericLiteral: import("@traqula/core").ParserRule<T12.SparqlContext, "numericLiteral", import("@traqula/rules-sparql-1-1").TermLiteralTyped, []>;
149
124
  numericLiteralUnsigned: import("@traqula/core").ParserRule<T12.SparqlContext, "numericLiteralUnsigned", import("@traqula/rules-sparql-1-1").TermLiteralTyped, []>;
150
125
  numericLiteralPositive: import("@traqula/core").ParserRule<T12.SparqlContext, "numericLiteralPositive", import("@traqula/rules-sparql-1-1").TermLiteralTyped, []>;
151
126
  numericLiteralNegative: import("@traqula/core").ParserRule<T12.SparqlContext, "numericLiteralNegative", import("@traqula/rules-sparql-1-1").TermLiteralTyped, []>;
152
127
  booleanLiteral: import("@traqula/core").ParserRule<T12.SparqlContext, "booleanLiteral", import("@traqula/rules-sparql-1-1").TermLiteralTyped, []>;
128
+ var: import("@traqula/core").ParserRule<T12.SparqlContext, "var", import("@traqula/rules-sparql-1-1").TermVariable, []>;
129
+ builtInCall: import("@traqula/core").ParserRule<T12.SparqlContext, "builtInCall", import("@traqula/rules-sparql-1-1").Expression, []>;
130
+ aggregate: import("@traqula/core").ParserRule<T12.SparqlContext, "aggregate", T12.ExpressionAggregate, []>;
153
131
  iri: import("@traqula/core").ParserRule<T12.SparqlContext, "iri", TermIri, []>;
154
- iriFull: import("@traqula/core").ParserRule<T12.SparqlContext, "iriFull", import("@traqula/rules-sparql-1-1").TermIriFull, []>;
155
132
  prefixedName: import("@traqula/core").ParserRule<T12.SparqlContext, "prefixedName", import("@traqula/rules-sparql-1-1").TermIriPrefixed, []>;
133
+ argList: import("@traqula/core").ParserRule<T12.SparqlContext, "argList", Wrap<Patch<g11.IArgList, {
134
+ args: T12.Expression[];
135
+ }>>, []>;
136
+ functionCall: import("@traqula/core").ParserRule<T12.SparqlContext, "functionCall", T12.ExpressionFunctionCall, []>;
137
+ varOrTerm: import("@traqula/core").ParserRule<T12.SparqlContext, "varOrTerm", T12.Term, []>;
138
+ verb: import("@traqula/core").ParserRule<T12.SparqlContext, "verb", TermIri | import("@traqula/rules-sparql-1-1").TermVariable, []>;
156
139
  VerbA: import("@traqula/core").ParserRule<T12.SparqlContext, "VerbA", import("@traqula/rules-sparql-1-1").TermIriFull, []>;
157
- pathEltOrInverse: import("@traqula/core").ParserRule<any, "pathEltOrInverse", unknown, any[]> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"pathEltOrInverse", import("@traqula/rules-sparql-1-1").Path, []>;
158
- pathSequence: import("@traqula/core").ParserRule<any, "pathSequence", unknown, any[]> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"pathSequence", import("@traqula/rules-sparql-1-1").TermIriFull | import("@traqula/rules-sparql-1-1").TermIriPrefixed | import("@traqula/rules-sparql-1-1").PropertyPathChain | import("@traqula/rules-sparql-1-1").PathModified | import("@traqula/rules-sparql-1-1").PathNegated, []>;
159
- pathAlternative: import("@traqula/core").ParserRule<any, "pathAlternative", unknown, any[]> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"pathAlternative", import("@traqula/rules-sparql-1-1").TermIriFull | import("@traqula/rules-sparql-1-1").TermIriPrefixed | import("@traqula/rules-sparql-1-1").PropertyPathChain | import("@traqula/rules-sparql-1-1").PathModified | import("@traqula/rules-sparql-1-1").PathNegated, []>;
160
- pathElt: import("@traqula/core").ParserRule<any, "pathElt", unknown, any[]> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"pathElt", import("@traqula/rules-sparql-1-1").Path, []>;
161
- pathMod: import("@traqula/core").ParserRule<any, "pathMod", unknown, any[]> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"pathMod", import("chevrotain").IToken & {
162
- image: "*" | "+" | "?";
163
- }, []>;
164
- pathPrimary: import("@traqula/core").ParserRule<any, "pathPrimary", unknown, any[]> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"pathPrimary", import("@traqula/rules-sparql-1-1").Path, []>;
165
- pathNegatedPropertySet: import("@traqula/core").ParserRule<any, "pathNegatedPropertySet", unknown, any[]> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"pathNegatedPropertySet", import("@traqula/rules-sparql-1-1").PathNegated, []>;
166
- pathOneInPropertySet: import("@traqula/core").ParserRule<any, "pathOneInPropertySet", unknown, any[]> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"pathOneInPropertySet", TermIri | import("@traqula/rules-sparql-1-1").PathNegatedElt, []>;
167
- groupClause: import("@traqula/core").ParserRule<T12.SparqlContext, "groupClause", T12.SolutionModifierGroup, []>;
168
- groupCondition: import("@traqula/core").ParserRule<T12.SparqlContext, "groupCondition", T12.Expression | T12.SolutionModifierGroupBind, []>;
169
- havingClause: import("@traqula/core").ParserRule<T12.SparqlContext, "havingClause", T12.SolutionModifierHaving, []>;
170
- havingCondition: import("@traqula/core").ParserRule<T12.SparqlContext, "havingCondition", T12.Expression, []>;
171
- orderClause: import("@traqula/core").ParserRule<T12.SparqlContext, "orderClause", T12.SolutionModifierOrder, []>;
172
- orderCondition: import("@traqula/core").ParserRule<T12.SparqlContext, "orderCondition", T12.Ordering, []>;
173
- limitOffsetClauses: import("@traqula/core").ParserRule<T12.SparqlContext, "limitOffsetClauses", import("@traqula/rules-sparql-1-1").SolutionModifierLimitOffset, []>;
174
- limitClause: import("@traqula/core").ParserRule<T12.SparqlContext, "limitClause", Wrap<number>, []>;
175
- offsetClause: import("@traqula/core").ParserRule<T12.SparqlContext, "offsetClause", Wrap<number>, []>;
176
- triplesBlock: import("@traqula/core").ParserRule<T12.SparqlContext, "triplesBlock", T12.PatternBgp, []>;
177
- triplesSameSubject: import("@traqula/core").ParserRule<T12.SparqlContext, "triplesSameSubject", import("@traqula/rules-sparql-1-1").BasicGraphPattern, []>;
178
- triplesSameSubjectPath: import("@traqula/core").ParserRule<T12.SparqlContext, "triplesSameSubjectPath", import("@traqula/rules-sparql-1-1").BasicGraphPattern, []>;
179
- triplesTemplate: import("@traqula/core").ParserRule<T12.SparqlContext, "triplesTemplate", T12.PatternBgp, []>;
180
- propertyList: import("@traqula/core").ParserRule<T12.SparqlContext, "propertyList", T12.TripleNesting[], [import("@traqula/rules-sparql-1-1").GraphNode]>;
181
- propertyListPath: import("@traqula/core").ParserRule<T12.SparqlContext, "propertyListPath", T12.TripleNesting[], [import("@traqula/rules-sparql-1-1").GraphNode]>;
182
- propertyListNotEmpty: import("@traqula/core").ParserRule<T12.SparqlContext, "propertyListNotEmpty", T12.TripleNesting[], [import("@traqula/rules-sparql-1-1").GraphNode]>;
183
- propertyListPathNotEmpty: import("@traqula/core").ParserRule<T12.SparqlContext, "propertyListPathNotEmpty", T12.TripleNesting[], [import("@traqula/rules-sparql-1-1").GraphNode]>;
184
- verbPath: import("@traqula/core").ParserRule<T12.SparqlContext, "verbPath", import("@traqula/rules-sparql-1-1").Path, []>;
185
- verbSimple: import("@traqula/core").ParserRule<T12.SparqlContext, "verbSimple", import("@traqula/rules-sparql-1-1").TermVariable, []>;
186
- objectList: import("@traqula/core").ParserRule<T12.SparqlContext, "objectList", T12.TripleNesting[], [T12.GraphNode, import("@traqula/rules-sparql-1-1").TermIriFull | import("@traqula/rules-sparql-1-1").TermIriPrefixed | import("@traqula/rules-sparql-1-1").TermVariable | import("@traqula/rules-sparql-1-1").PropertyPathChain | import("@traqula/rules-sparql-1-1").PathModified | import("@traqula/rules-sparql-1-1").PathNegated]>;
187
- objectListPath: import("@traqula/core").ParserRule<T12.SparqlContext, "objectListPath", T12.TripleNesting, [T12.GraphNode, import("@traqula/rules-sparql-1-1").TermIriFull | import("@traqula/rules-sparql-1-1").TermIriPrefixed | import("@traqula/rules-sparql-1-1").TermVariable | import("@traqula/rules-sparql-1-1").PropertyPathChain | import("@traqula/rules-sparql-1-1").PathModified | import("@traqula/rules-sparql-1-1").PathNegated]>;
188
- objectPath: import("@traqula/core").ParserRule<T12.SparqlContext, "objectPath", T12.TripleNesting, [T12.GraphNode, import("@traqula/rules-sparql-1-1").TermIriFull | import("@traqula/rules-sparql-1-1").TermIriPrefixed | import("@traqula/rules-sparql-1-1").TermVariable | import("@traqula/rules-sparql-1-1").PropertyPathChain | import("@traqula/rules-sparql-1-1").PathModified | import("@traqula/rules-sparql-1-1").PathNegated]>;
189
- collection: import("@traqula/core").ParserRule<T12.SparqlContext, "collection", T12.TripleCollectionList, []>;
190
- collectionPath: import("@traqula/core").ParserRule<T12.SparqlContext, "collectionPath", T12.TripleCollectionList, []>;
191
- triplesNode: import("@traqula/core").ParserRule<T12.SparqlContext, "triplesNode", T12.TripleCollection, []>;
192
- triplesNodePath: import("@traqula/core").ParserRule<T12.SparqlContext, "triplesNodePath", T12.TripleCollection, []>;
193
- blankNodePropertyList: import("@traqula/core").ParserRule<T12.SparqlContext, "blankNodePropertyList", Patch<import("@traqula/rules-sparql-1-1").TripleCollectionBlankNodeProperties, {
194
- triples: T12.TripleNesting[];
195
- identifier: T12.TermBlank | T12.TermVariable | T12.TermIri;
196
- }>, []>;
197
- blankNodePropertyListPath: import("@traqula/core").ParserRule<T12.SparqlContext, "blankNodePropertyListPath", Patch<import("@traqula/rules-sparql-1-1").TripleCollectionBlankNodeProperties, {
198
- triples: T12.TripleNesting[];
199
- identifier: T12.TermBlank | T12.TermVariable | T12.TermIri;
200
- }>, []>;
201
- graphNode: import("@traqula/core").ParserRule<T12.SparqlContext, "graphNode", T12.GraphNode, []>;
202
- graphNodePath: import("@traqula/core").ParserRule<T12.SparqlContext, "graphNodePath", T12.GraphNode, []>;
140
+ varOrIri: import("@traqula/core").ParserRule<T12.SparqlContext, "varOrIri", TermIri | import("@traqula/rules-sparql-1-1").TermVariable, []>;
141
+ iriFull: import("@traqula/core").ParserRule<T12.SparqlContext, "iriFull", import("@traqula/rules-sparql-1-1").TermIriFull, []>;
142
+ subSelect: import("@traqula/core").ParserRule<T12.SparqlContext, "subSelect", Omit<T12.QuerySelect, "prefixes">, []>;
143
+ selectClause: import("@traqula/core").ParserRule<T12.SparqlContext, "selectClause", Wrap<Pick<T12.QuerySelect, "variables" | "distinct" | "reduced">>, []>;
203
144
  whereClause: import("@traqula/core").ParserRule<T12.SparqlContext, "whereClause", Wrap<T12.PatternGroup>, []>;
145
+ solutionModifier: import("@traqula/core").ParserRule<T12.SparqlContext, "solutionModifier", T12.SolutionModifiers, []>;
146
+ valuesClause: import("@traqula/core").ParserRule<T12.SparqlContext, "valuesClause", T12.PatternValues[] | undefined, []>;
147
+ query: import("@traqula/core").ParserRule<any, "query", unknown, any[]> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"query", import("@traqula/rules-sparql-1-1").Query, []> & import("@traqula/rules-sparql-1-1").SparqlGeneratorRule<"query", import("@traqula/rules-sparql-1-1").Query, []>;
204
148
  groupGraphPattern: import("@traqula/core").ParserRule<T12.SparqlContext, "groupGraphPattern", T12.PatternGroup, []>;
205
149
  groupGraphPatternSub: import("@traqula/core").ParserRule<T12.SparqlContext, "groupGraphPatternSub", T12.Pattern[], []>;
206
150
  graphPatternNotTriples: import("@traqula/core").ParserRule<T12.SparqlContext, "graphPatternNotTriples", T12.PatternGroup | T12.PatternUnion | T12.PatternOptional | T12.PatternMinus | T12.PatternGraph | T12.PatternService | T12.PatternFilter | T12.PatternBind | T12.PatternValues, []>;
151
+ filter: import("@traqula/core").ParserRule<T12.SparqlContext, "filter", T12.PatternFilter, []>;
152
+ bind: import("@traqula/core").ParserRule<T12.SparqlContext, "bind", T12.PatternBind, []>;
153
+ groupOrUnionGraphPattern: import("@traqula/core").ParserRule<T12.SparqlContext, "groupOrUnionGraphPattern", T12.PatternGroup | T12.PatternUnion, []>;
207
154
  optionalGraphPattern: import("@traqula/core").ParserRule<T12.SparqlContext, "optionalGraphPattern", T12.PatternOptional, []>;
155
+ minusGraphPattern: import("@traqula/core").ParserRule<T12.SparqlContext, "minusGraphPattern", T12.PatternMinus, []>;
208
156
  graphGraphPattern: import("@traqula/core").ParserRule<T12.SparqlContext, "graphGraphPattern", T12.PatternGraph, []>;
209
157
  serviceGraphPattern: import("@traqula/core").ParserRule<T12.SparqlContext, "serviceGraphPattern", T12.PatternService, []>;
210
158
  inlineData: import("@traqula/core").ParserRule<T12.SparqlContext, "inlineData", T12.PatternValues, []>;
159
+ constraint: import("@traqula/core").ParserRule<T12.SparqlContext, "constraint", T12.Expression, []>;
211
160
  dataBlock: import("@traqula/core").ParserRule<T12.SparqlContext, "dataBlock", Wrap<T12.ValuePatternRow[]>, []>;
212
161
  inlineDataOneVar: import("@traqula/core").ParserRule<T12.SparqlContext, "inlineDataOneVar", Wrap<T12.ValuePatternRow[]>, []>;
213
162
  inlineDataFull: import("@traqula/core").ParserRule<T12.SparqlContext, "inlineDataFull", Wrap<T12.ValuePatternRow[]>, []>;
214
163
  dataBlockValue: import("@traqula/core").ParserRule<T12.SparqlContext, "dataBlockValue", TermIri | import("@traqula/rules-sparql-1-1").TermLiteral | T12.TermTriple | undefined, []>;
215
- minusGraphPattern: import("@traqula/core").ParserRule<T12.SparqlContext, "minusGraphPattern", T12.PatternMinus, []>;
216
- groupOrUnionGraphPattern: import("@traqula/core").ParserRule<T12.SparqlContext, "groupOrUnionGraphPattern", T12.PatternGroup | T12.PatternUnion, []>;
217
- constraint: import("@traqula/core").ParserRule<T12.SparqlContext, "constraint", T12.Expression, []>;
218
- queryOrUpdate: import("@traqula/core").ParserRule<T12.SparqlContext, "queryOrUpdate", T12.SparqlQuery, []>;
219
- reifiedTriple: import("@traqula/core").ParserRule<any, "reifiedTriple"> & T12.SparqlGrammarRule<"reifiedTriple", T12.TripleCollectionReifiedTriple, []> & T12.SparqlGeneratorRule<"reifiedTriple", T12.TripleCollectionReifiedTriple, []>;
164
+ groupClause: import("@traqula/core").ParserRule<T12.SparqlContext, "groupClause", T12.SolutionModifierGroup, []>;
165
+ havingClause: import("@traqula/core").ParserRule<T12.SparqlContext, "havingClause", T12.SolutionModifierHaving, []>;
166
+ orderClause: import("@traqula/core").ParserRule<T12.SparqlContext, "orderClause", T12.SolutionModifierOrder, []>;
167
+ limitOffsetClauses: import("@traqula/core").ParserRule<T12.SparqlContext, "limitOffsetClauses", import("@traqula/rules-sparql-1-1").SolutionModifierLimitOffset, []>;
168
+ groupCondition: import("@traqula/core").ParserRule<T12.SparqlContext, "groupCondition", T12.Expression | T12.SolutionModifierGroupBind, []>;
169
+ havingCondition: import("@traqula/core").ParserRule<T12.SparqlContext, "havingCondition", T12.Expression, []>;
170
+ orderCondition: import("@traqula/core").ParserRule<T12.SparqlContext, "orderCondition", T12.Ordering, []>;
171
+ limitClause: import("@traqula/core").ParserRule<T12.SparqlContext, "limitClause", Wrap<number>, []>;
172
+ offsetClause: import("@traqula/core").ParserRule<T12.SparqlContext, "offsetClause", Wrap<number>, []>;
173
+ queryUnit: import("@traqula/core").ParserRule<any, "queryUnit", unknown, any[]> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"queryUnit", import("@traqula/rules-sparql-1-1").Query, []>;
174
+ prologue: import("@traqula/core").ParserRule<T12.SparqlContext, "prologue", T12.ContextDefinition[], []>;
175
+ selectQuery: import("@traqula/core").ParserRule<T12.SparqlContext, "selectQuery", Omit<T12.QuerySelect, g11.HandledByBase>, []>;
176
+ constructQuery: import("@traqula/core").ParserRule<T12.SparqlContext, "constructQuery", Omit<T12.QueryConstruct, g11.HandledByBase>, []>;
177
+ describeQuery: import("@traqula/core").ParserRule<T12.SparqlContext, "describeQuery", Omit<T12.QueryDescribe, g11.HandledByBase>, []>;
178
+ askQuery: import("@traqula/core").ParserRule<T12.SparqlContext, "askQuery", Omit<T12.QueryAsk, g11.HandledByBase>, []>;
179
+ baseDecl: import("@traqula/core").ParserRule<T12.SparqlContext, "baseDecl", T12.ContextDefinition, []>;
180
+ prefixDecl: import("@traqula/core").ParserRule<T12.SparqlContext, "prefixDecl", T12.ContextDefinition, []>;
181
+ datasetClause: import("@traqula/core").ParserRule<T12.SparqlContext, "datasetClause", Wrap<{
182
+ clauseType: "default" | "named";
183
+ value: T12.TermIri;
184
+ }>, []>;
185
+ datasetClauses: import("@traqula/core").ParserRule<T12.SparqlContext, "datasetClauses", T12.DatasetClauses, []>;
186
+ defaultGraphClause: import("@traqula/core").ParserRule<T12.SparqlContext, "defaultGraphClause", TermIri, []>;
187
+ namedGraphClause: import("@traqula/core").ParserRule<T12.SparqlContext, "namedGraphClause", Wrap<TermIri>, []>;
188
+ sourceSelector: import("@traqula/core").ParserRule<T12.SparqlContext, "sourceSelector", TermIri, []>;
189
+ constructTemplate: import("@traqula/core").ParserRule<T12.SparqlContext, "constructTemplate", Wrap<T12.PatternBgp>, []>;
190
+ constructTriples: import("@traqula/core").ParserRule<T12.SparqlContext, "constructTriples", T12.PatternBgp, []>;
191
+ update1: import("@traqula/core").ParserRule<T12.SparqlContext, "update1", T12.UpdateOperation, []>;
192
+ load: import("@traqula/core").ParserRule<T12.SparqlContext, "load", T12.UpdateOperationLoad, []>;
193
+ clear: import("@traqula/core").ParserRule<T12.SparqlContext, "clear", T12.UpdateOperationClear, []>;
194
+ drop: import("@traqula/core").ParserRule<T12.SparqlContext, "drop", T12.UpdateOperationDrop, []>;
195
+ add: import("@traqula/core").ParserRule<T12.SparqlContext, "add", T12.UpdateOperationAdd, []>;
196
+ move: import("@traqula/core").ParserRule<T12.SparqlContext, "move", T12.UpdateOperationMove, []>;
197
+ copy: import("@traqula/core").ParserRule<T12.SparqlContext, "copy", T12.UpdateOperationCopy, []>;
198
+ create: import("@traqula/core").ParserRule<T12.SparqlContext, "create", T12.UpdateOperationCreate, []>;
199
+ insertData: import("@traqula/core").ParserRule<T12.SparqlContext, "insertData", T12.UpdateOperationInsertData, []>;
200
+ deleteData: import("@traqula/core").ParserRule<T12.SparqlContext, "deleteData", T12.UpdateOperationDeleteData, []>;
201
+ deleteWhere: import("@traqula/core").ParserRule<T12.SparqlContext, "deleteWhere", T12.UpdateOperationDeleteWhere, []>;
202
+ modify: import("@traqula/core").ParserRule<T12.SparqlContext, "modify", T12.UpdateOperationModify, []>;
203
+ updateUnit: import("@traqula/core").ParserRule<any, "updateUnit", unknown, any[]> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"updateUnit", import("@traqula/rules-sparql-1-1").Update, []>;
204
+ update: import("@traqula/core").ParserRule<any, "update", unknown, any[]> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"update", import("@traqula/rules-sparql-1-1").Update, []> & import("@traqula/rules-sparql-1-1").SparqlGeneratorRule<"update", import("@traqula/rules-sparql-1-1").Update, []>;
205
+ graphRef: import("@traqula/core").ParserRule<T12.SparqlContext, "graphRef", import("@traqula/rules-sparql-1-1").GraphRefSpecific, []>;
206
+ graphRefAll: import("@traqula/core").ParserRule<T12.SparqlContext, "graphRefAll", import("@traqula/rules-sparql-1-1").GraphRef, []>;
207
+ graphOrDefault: import("@traqula/core").ParserRule<T12.SparqlContext, "graphOrDefault", import("@traqula/rules-sparql-1-1").GraphRefSpecific | import("@traqula/rules-sparql-1-1").GraphRefDefault, []>;
208
+ quadData: import("@traqula/core").ParserRule<T12.SparqlContext, "quadData", Wrap<T12.Quads[]>, []>;
209
+ quads: import("@traqula/core").ParserRule<T12.SparqlContext, "quads", Wrap<T12.Quads[]>, []>;
210
+ quadPattern: import("@traqula/core").ParserRule<T12.SparqlContext, "quadPattern", Wrap<T12.Quads[]>, []>;
211
+ quadsNotTriples: import("@traqula/core").ParserRule<T12.SparqlContext, "quadsNotTriples", T12.GraphQuads, []>;
212
+ deleteClause: import("@traqula/core").ParserRule<T12.SparqlContext, "deleteClause", Wrap<T12.Quads[]>, []>;
213
+ insertClause: import("@traqula/core").ParserRule<T12.SparqlContext, "insertClause", Wrap<T12.Quads[]>, []>;
214
+ usingClause: import("@traqula/core").ParserRule<T12.SparqlContext, "usingClause", Wrap<{
215
+ clauseType: "default" | "named";
216
+ value: T12.TermIri;
217
+ }>, []>;
218
+ usingClauses: import("@traqula/core").ParserRule<T12.SparqlContext, "usingClauses", T12.DatasetClauses, []>;
220
219
  versionDecl: import("@traqula/core").ParserRule<any, "versionDecl"> & T12.SparqlGrammarRule<"versionDecl", T12.ContextDefinitionVersion, []> & T12.SparqlGeneratorRule<"versionDecl", T12.ContextDefinitionVersion, []>;
221
220
  versionSpecifier: import("@traqula/core").ParserRule<any, "versionSpecifier"> & T12.SparqlGrammarRule<"versionSpecifier", Wrap<string>>;
222
221
  reifiedTripleBlock: import("@traqula/core").ParserRule<any, "reifiedTripleBlock"> & T12.SparqlGrammarRule<"reifiedTripleBlock", import("@traqula/rules-sparql-1-1").BasicGraphPattern>;
223
222
  reifiedTripleBlockPath: import("@traqula/core").ParserRule<any, "reifiedTripleBlockPath"> & T12.SparqlGrammarRule<"reifiedTripleBlockPath", import("@traqula/rules-sparql-1-1").BasicGraphPattern>;
224
- varOrReifierId: import("@traqula/core").ParserRule<any, "varOrReifierId"> & T12.SparqlGrammarRule<"varOrReifierId", TermIri | import("@traqula/rules-sparql-1-1").TermVariable | import("@traqula/rules-sparql-1-1").TermBlank>;
225
- reifier: import("@traqula/core").ParserRule<any, "reifier"> & T12.SparqlGrammarRule<"reifier", Wrap<TermIri | import("@traqula/rules-sparql-1-1").TermVariable | import("@traqula/rules-sparql-1-1").TermBlank>>;
223
+ varOrReifierId: import("@traqula/core").ParserRule<any, "varOrReifierId"> & T12.SparqlGrammarRule<"varOrReifierId", TermIri | import("@traqula/rules-sparql-1-1").TermBlank | import("@traqula/rules-sparql-1-1").TermVariable>;
224
+ reifier: import("@traqula/core").ParserRule<any, "reifier"> & T12.SparqlGrammarRule<"reifier", Wrap<TermIri | import("@traqula/rules-sparql-1-1").TermBlank | import("@traqula/rules-sparql-1-1").TermVariable>>;
225
+ reifiedTriple: import("@traqula/core").ParserRule<any, "reifiedTriple"> & T12.SparqlGrammarRule<"reifiedTriple", T12.TripleCollectionReifiedTriple, []> & T12.SparqlGeneratorRule<"reifiedTriple", T12.TripleCollectionReifiedTriple, []>;
226
226
  annotationPath: import("@traqula/core").ParserRule<any, "annotationPath"> & T12.SparqlGrammarRule<"annotationPath", T12.Annotation[], []> & T12.SparqlGeneratorRule<"annotationPath", T12.Annotation[], []>;
227
227
  annotation: import("@traqula/core").ParserRule<any, "annotation"> & T12.SparqlGrammarRule<"annotation", T12.Annotation[], []> & T12.SparqlGeneratorRule<"annotation", T12.Annotation[], []>;
228
228
  annotationBlockPath: import("@traqula/core").ParserRule<any, "annotationBlockPath"> & T12.SparqlGrammarRule<"annotationBlockPath", Patch<import("@traqula/rules-sparql-1-1").TripleCollectionBlankNodeProperties, {
229
229
  triples: T12.TripleNesting[];
230
230
  identifier: T12.TermBlank | T12.TermVariable | T12.TermIri;
231
- }>, [TermIri | import("@traqula/rules-sparql-1-1").TermVariable | import("@traqula/rules-sparql-1-1").TermBlank]> & T12.SparqlGeneratorRule<"annotationBlockPath", Patch<import("@traqula/rules-sparql-1-1").TripleCollectionBlankNodeProperties, {
231
+ }>, [TermIri | import("@traqula/rules-sparql-1-1").TermBlank | import("@traqula/rules-sparql-1-1").TermVariable]> & T12.SparqlGeneratorRule<"annotationBlockPath", Patch<import("@traqula/rules-sparql-1-1").TripleCollectionBlankNodeProperties, {
232
232
  triples: T12.TripleNesting[];
233
233
  identifier: T12.TermBlank | T12.TermVariable | T12.TermIri;
234
234
  }>>;
235
235
  annotationBlock: import("@traqula/core").ParserRule<any, "annotationBlock"> & T12.SparqlGrammarRule<"annotationBlock", Patch<import("@traqula/rules-sparql-1-1").TripleCollectionBlankNodeProperties, {
236
236
  triples: T12.TripleNesting[];
237
237
  identifier: T12.TermBlank | T12.TermVariable | T12.TermIri;
238
- }>, [TermIri | import("@traqula/rules-sparql-1-1").TermVariable | import("@traqula/rules-sparql-1-1").TermBlank]> & T12.SparqlGeneratorRule<"annotationBlock", Patch<import("@traqula/rules-sparql-1-1").TripleCollectionBlankNodeProperties, {
238
+ }>, [TermIri | import("@traqula/rules-sparql-1-1").TermBlank | import("@traqula/rules-sparql-1-1").TermVariable]> & T12.SparqlGeneratorRule<"annotationBlock", Patch<import("@traqula/rules-sparql-1-1").TripleCollectionBlankNodeProperties, {
239
239
  triples: T12.TripleNesting[];
240
240
  identifier: T12.TermBlank | T12.TermVariable | T12.TermIri;
241
241
  }>>;
242
- reifiedTripleSubject: import("@traqula/core").ParserRule<any, "reifiedTripleSubject"> & T12.SparqlGrammarRule<"reifiedTripleSubject", T12.TripleCollectionReifiedTriple | T12.Term>;
243
- reifiedTripleObject: import("@traqula/core").ParserRule<any, "reifiedTripleObject"> & T12.SparqlGrammarRule<"reifiedTripleObject", T12.TripleCollectionReifiedTriple | T12.Term>;
242
+ reifiedTripleSubject: import("@traqula/core").ParserRule<any, "reifiedTripleSubject"> & T12.SparqlGrammarRule<"reifiedTripleSubject", T12.Term | T12.TripleCollectionReifiedTriple>;
243
+ reifiedTripleObject: import("@traqula/core").ParserRule<any, "reifiedTripleObject"> & T12.SparqlGrammarRule<"reifiedTripleObject", T12.Term | T12.TripleCollectionReifiedTriple>;
244
244
  tripleTerm: import("@traqula/core").ParserRule<any, "tripleTerm"> & T12.SparqlGrammarRule<"tripleTerm", T12.TermTriple, []> & T12.SparqlGeneratorRule<"tripleTerm", T12.TermTriple, []>;
245
- tripleTermSubject: import("@traqula/core").ParserRule<any, "tripleTermSubject"> & T12.SparqlGrammarRule<"tripleTermSubject", TermIri | import("@traqula/rules-sparql-1-1").TermVariable | import("@traqula/rules-sparql-1-1").TermLiteral | import("@traqula/rules-sparql-1-1").TermBlank | T12.TermTriple>;
246
- tripleTermObject: import("@traqula/core").ParserRule<any, "tripleTermObject"> & T12.SparqlGrammarRule<"tripleTermObject", TermIri | import("@traqula/rules-sparql-1-1").TermVariable | import("@traqula/rules-sparql-1-1").TermLiteral | import("@traqula/rules-sparql-1-1").TermBlank | T12.TermTriple>;
245
+ tripleTermSubject: import("@traqula/core").ParserRule<any, "tripleTermSubject"> & T12.SparqlGrammarRule<"tripleTermSubject", TermIri | import("@traqula/rules-sparql-1-1").TermBlank | import("@traqula/rules-sparql-1-1").TermLiteral | import("@traqula/rules-sparql-1-1").TermVariable | T12.TermTriple>;
246
+ tripleTermObject: import("@traqula/core").ParserRule<any, "tripleTermObject"> & T12.SparqlGrammarRule<"tripleTermObject", TermIri | import("@traqula/rules-sparql-1-1").TermBlank | import("@traqula/rules-sparql-1-1").TermLiteral | import("@traqula/rules-sparql-1-1").TermVariable | T12.TermTriple>;
247
247
  tripleTermData: import("@traqula/core").ParserRule<any, "tripleTermData"> & T12.SparqlGrammarRule<"tripleTermData", T12.TermTriple>;
248
248
  tripleTermDataSubject: import("@traqula/core").ParserRule<any, "tripleTermDataSubject"> & T12.SparqlGrammarRule<"tripleTermDataSubject", TermIri | import("@traqula/rules-sparql-1-1").TermLiteral | T12.TermTriple>;
249
249
  tripleTermDataObject: import("@traqula/core").ParserRule<any, "tripleTermDataObject"> & T12.SparqlGrammarRule<"tripleTermDataObject", TermIri | import("@traqula/rules-sparql-1-1").TermLiteral | T12.TermTriple>;
250
250
  exprTripleTerm: import("@traqula/core").ParserRule<any, "exprTripleTerm"> & T12.SparqlGrammarRule<"exprTripleTerm", T12.TermTriple>;
251
- exprTripleTermSubject: import("@traqula/core").ParserRule<any, "exprTripleTermSubject"> & T12.SparqlGrammarRule<"exprTripleTermSubject", TermIri | import("@traqula/rules-sparql-1-1").TermVariable | import("@traqula/rules-sparql-1-1").TermLiteral | T12.TermTriple>;
252
- exprTripleTermObject: import("@traqula/core").ParserRule<any, "exprTripleTermObject"> & T12.SparqlGrammarRule<"exprTripleTermObject", TermIri | import("@traqula/rules-sparql-1-1").TermVariable | import("@traqula/rules-sparql-1-1").TermLiteral | T12.TermTriple>;
251
+ exprTripleTermSubject: import("@traqula/core").ParserRule<any, "exprTripleTermSubject"> & T12.SparqlGrammarRule<"exprTripleTermSubject", TermIri | import("@traqula/rules-sparql-1-1").TermLiteral | import("@traqula/rules-sparql-1-1").TermVariable | T12.TermTriple>;
252
+ exprTripleTermObject: import("@traqula/core").ParserRule<any, "exprTripleTermObject"> & T12.SparqlGrammarRule<"exprTripleTermObject", TermIri | import("@traqula/rules-sparql-1-1").TermLiteral | import("@traqula/rules-sparql-1-1").TermVariable | T12.TermTriple>;
253
253
  builtInLangdir: import("@traqula/core").ParserRule<any, "builtInLangdir"> & g11.RuleDefExpressionFunctionX<"builtInLangdir", [import("@traqula/rules-sparql-1-1").Expression]>;
254
254
  builtInStrLangdir: import("@traqula/core").ParserRule<any, "builtInStrLangdir"> & g11.RuleDefExpressionFunctionX<"builtInStrLangdir", [import("@traqula/rules-sparql-1-1").Expression, import("@traqula/rules-sparql-1-1").Expression, import("@traqula/rules-sparql-1-1").Expression]>;
255
255
  builtInHasLang: import("@traqula/core").ParserRule<any, "builtInHasLang"> & g11.RuleDefExpressionFunctionX<"builtInHasLang", [import("@traqula/rules-sparql-1-1").Expression]>;
package/lib/index.cjs CHANGED
@@ -9485,7 +9485,7 @@ var DynamicParser = class extends EmbeddedActionsParser {
9485
9485
  constructor(rules5, tokenVocabulary, config = {}) {
9486
9486
  super(tokenVocabulary, {
9487
9487
  // RecoveryEnabled: true,
9488
- maxLookahead: 2,
9488
+ maxLookahead: 1,
9489
9489
  skipValidations: true,
9490
9490
  ...config
9491
9491
  });
@@ -9743,6 +9743,11 @@ ${firstError.message}`);
9743
9743
 
9744
9744
  // ../../packages/core/lib/Transformers.js
9745
9745
  var TransformerType = class {
9746
+ clone(obj) {
9747
+ const newObj = Object.create(Object.getPrototypeOf(obj));
9748
+ Object.defineProperties(newObj, Object.getOwnPropertyDescriptors(obj));
9749
+ return newObj;
9750
+ }
9746
9751
  safeObjectVisit(value, mapper) {
9747
9752
  if (value && typeof value === "object") {
9748
9753
  if (Array.isArray(value)) {
@@ -9752,104 +9757,213 @@ var TransformerType = class {
9752
9757
  }
9753
9758
  return value;
9754
9759
  }
9755
- transformNode(curObject, nodeCallBacks) {
9756
- let continueCheck;
9757
- let transformation;
9758
- const casted = curObject;
9759
- if (casted.type) {
9760
- continueCheck = nodeCallBacks[casted.type]?.continue;
9761
- transformation = nodeCallBacks[casted.type]?.transform;
9762
- }
9763
- let shouldContinue = true;
9764
- if (continueCheck) {
9765
- shouldContinue = continueCheck(curObject);
9766
- }
9767
- if (!shouldContinue) {
9768
- return curObject;
9769
- }
9770
- const copy3 = { ...curObject };
9771
- for (const [key, value] of Object.entries(copy3)) {
9772
- copy3[key] = this.safeObjectVisit(value, (obj) => this.transformNode(obj, nodeCallBacks));
9773
- }
9774
- if (transformation) {
9775
- return transformation(copy3);
9776
- }
9777
- return copy3;
9760
+ /**
9761
+ * Recursively transforms all objects that are not arrays. Mapper is called on deeper objects first.
9762
+ * @param startObject object to start iterating from
9763
+ * @param mapper mapper to transform the various objects - argument is a copy of the original
9764
+ * @param preVisitor callback that is evaluated before iterating deeper.
9765
+ * If continues is false, we do not iterate deeper, current object is still mapped. - default: true
9766
+ * If shortcut is true, we do not iterate deeper, nor do we branch out, this mapper will be the last one called.
9767
+ * - Default false
9768
+ */
9769
+ transformObject(startObject, mapper, preVisitor = () => ({})) {
9770
+ let didShortCut = false;
9771
+ const recurse = (curObject) => {
9772
+ const copy3 = this.clone(curObject);
9773
+ const context = preVisitor(copy3);
9774
+ didShortCut = context.shortcut ?? false;
9775
+ const continues = context.continue ?? true;
9776
+ if (continues && !didShortCut) {
9777
+ for (const [key, value] of Object.entries(copy3)) {
9778
+ if (didShortCut) {
9779
+ return copy3;
9780
+ }
9781
+ copy3[key] = this.safeObjectVisit(value, (obj) => recurse(obj));
9782
+ }
9783
+ }
9784
+ return mapper(copy3);
9785
+ };
9786
+ return recurse(startObject);
9778
9787
  }
9779
- visitNode(curObject, nodeCallBacks) {
9780
- let callback;
9781
- const casted = curObject;
9782
- if (casted.type) {
9783
- callback = nodeCallBacks[casted.type];
9784
- }
9785
- let shouldIterate = true;
9786
- if (callback) {
9787
- shouldIterate = callback(curObject);
9788
- }
9789
- if (shouldIterate) {
9790
- for (const value of Object.values(curObject)) {
9791
- this.safeObjectVisit(value, (obj) => this.visitNode(obj, nodeCallBacks));
9788
+ /**
9789
+ * Visitor that visits all objects. Visits deeper objects first.
9790
+ */
9791
+ visitObject(startObject, visitor, preVisitor = () => ({})) {
9792
+ let didShortCut = false;
9793
+ const recurse = (curObject) => {
9794
+ const context = preVisitor(curObject);
9795
+ didShortCut = context.shortcut ?? false;
9796
+ const continues = context.continue ?? true;
9797
+ if (continues && !didShortCut) {
9798
+ for (const value of Object.values(curObject)) {
9799
+ if (didShortCut) {
9800
+ return;
9801
+ }
9802
+ this.safeObjectVisit(value, (obj) => recurse(obj));
9803
+ }
9792
9804
  }
9793
- }
9805
+ visitor(curObject);
9806
+ };
9807
+ recurse(startObject);
9808
+ }
9809
+ transformNode(startObject, nodeCallBacks) {
9810
+ const transformWrapper = (curObject) => {
9811
+ const casted = curObject;
9812
+ if (casted.type) {
9813
+ const ogFunc = nodeCallBacks[casted.type]?.transform;
9814
+ if (ogFunc) {
9815
+ return ogFunc(casted);
9816
+ }
9817
+ }
9818
+ return curObject;
9819
+ };
9820
+ const preTransformWrapper = (curObject) => {
9821
+ const casted = curObject;
9822
+ if (casted.type) {
9823
+ const ogFunc = nodeCallBacks[casted.type]?.preVisitor;
9824
+ if (ogFunc) {
9825
+ return ogFunc(casted);
9826
+ }
9827
+ }
9828
+ return {};
9829
+ };
9830
+ return this.transformObject(startObject, transformWrapper, preTransformWrapper);
9831
+ }
9832
+ visitNode(startObject, nodeCallBacks) {
9833
+ const visitWrapper = (curObject) => {
9834
+ const casted = curObject;
9835
+ if (casted.type) {
9836
+ const ogFunc = nodeCallBacks[casted.type]?.visitor;
9837
+ if (ogFunc) {
9838
+ ogFunc(casted);
9839
+ }
9840
+ }
9841
+ };
9842
+ const preVisitWrapper = (curObject) => {
9843
+ const casted = curObject;
9844
+ if (casted.type) {
9845
+ const ogFunc = nodeCallBacks[casted.type]?.preVisitor;
9846
+ if (ogFunc) {
9847
+ return ogFunc(casted);
9848
+ }
9849
+ }
9850
+ return {};
9851
+ };
9852
+ this.visitObject(startObject, visitWrapper, preVisitWrapper);
9853
+ }
9854
+ traverseNodes(currentNode, traverse) {
9855
+ let didShortCut = false;
9856
+ const recurse = (curNode) => {
9857
+ const traverser = traverse[curNode.type];
9858
+ if (traverser) {
9859
+ const { next, shortcut } = traverser(curNode);
9860
+ didShortCut = shortcut ?? false;
9861
+ if (!didShortCut) {
9862
+ for (const node of next ?? []) {
9863
+ if (didShortCut) {
9864
+ return;
9865
+ }
9866
+ recurse(node);
9867
+ }
9868
+ }
9869
+ }
9870
+ };
9871
+ recurse(currentNode);
9794
9872
  }
9795
9873
  };
9796
9874
  var TransformerSubType = class extends TransformerType {
9797
- // Public visitObjects(curObject: object, visitor: (current: object) => void): void {
9798
- // for (const value of Object.values(curObject)) {
9799
- // this.safeObjectVisit(value, obj => this.visitObjects(obj, visitor));
9800
- // }
9801
- // }
9802
- transformNodeSpecific(curObject, nodeCallBacks, nodeSpecificCallBacks = {}) {
9803
- let continueCheck;
9804
- let transformation;
9805
- const casted = curObject;
9806
- if (casted.type && casted.subType) {
9807
- const specific = nodeSpecificCallBacks[casted.type];
9808
- if (specific) {
9809
- continueCheck = specific[casted.subType]?.continue;
9810
- transformation = specific[casted.subType]?.transform;
9811
- }
9812
- }
9813
- let shouldContinue = true;
9814
- if (continueCheck) {
9815
- shouldContinue = continueCheck(curObject);
9816
- }
9817
- if (!shouldContinue) {
9818
- return curObject;
9819
- }
9820
- const copy3 = { ...curObject };
9821
- for (const [key, value] of Object.entries(copy3)) {
9822
- copy3[key] = this.safeObjectVisit(value, (obj) => this.transformNodeSpecific(obj, nodeCallBacks, nodeSpecificCallBacks));
9823
- }
9824
- if (transformation) {
9825
- return transformation(copy3);
9826
- }
9827
- return copy3;
9875
+ transformNodeSpecific(startObject, nodeCallBacks, nodeSpecificCallBacks) {
9876
+ const transformWrapper = (curObject) => {
9877
+ let ogTransform;
9878
+ const casted = curObject;
9879
+ if (casted.type && casted.subType) {
9880
+ const specific = nodeSpecificCallBacks[casted.type];
9881
+ if (specific) {
9882
+ ogTransform = specific[casted.subType]?.transform;
9883
+ }
9884
+ if (!ogTransform) {
9885
+ ogTransform = nodeCallBacks[casted.type]?.transform;
9886
+ }
9887
+ }
9888
+ return ogTransform ? ogTransform(casted) : curObject;
9889
+ };
9890
+ const preVisitWrapper = (curObject) => {
9891
+ let ogPreVisit;
9892
+ const casted = curObject;
9893
+ if (casted.type && casted.subType) {
9894
+ const specific = nodeSpecificCallBacks[casted.type];
9895
+ if (specific) {
9896
+ ogPreVisit = specific[casted.subType]?.preVisitor;
9897
+ }
9898
+ if (!ogPreVisit) {
9899
+ ogPreVisit = nodeCallBacks[casted.type]?.preVisitor;
9900
+ }
9901
+ }
9902
+ return ogPreVisit ? ogPreVisit(casted) : curObject;
9903
+ };
9904
+ return this.transformObject(startObject, transformWrapper, preVisitWrapper);
9828
9905
  }
9829
9906
  /**
9830
9907
  * When both nodeCallBack and NodeSpecific callBack are matched, will only look at nodeSpecifCallback
9831
9908
  */
9832
- visitNodeSpecific(curObject, nodeCallBacks, nodeSpecificCallBacks = {}) {
9833
- let callback;
9834
- const casted = curObject;
9835
- if (casted.type && casted.subType) {
9836
- const specific = nodeSpecificCallBacks[casted.type];
9837
- if (specific) {
9838
- callback = specific[casted.subType];
9909
+ visitNodeSpecific(startObject, nodeCallBacks, nodeSpecificCallBacks) {
9910
+ const visitWrapper = (curObject) => {
9911
+ let ogTransform;
9912
+ const casted = curObject;
9913
+ if (casted.type && casted.subType) {
9914
+ const specific = nodeSpecificCallBacks[casted.type];
9915
+ if (specific) {
9916
+ ogTransform = specific[casted.subType]?.visitor;
9917
+ }
9918
+ if (!ogTransform) {
9919
+ ogTransform = nodeCallBacks[casted.type]?.visitor;
9920
+ }
9839
9921
  }
9840
- }
9841
- if (!callback && casted.type) {
9842
- callback = nodeCallBacks[curObject.type];
9843
- }
9844
- let shouldIterate = true;
9845
- if (callback) {
9846
- shouldIterate = callback(curObject) ?? true;
9847
- }
9848
- if (shouldIterate) {
9849
- for (const value of Object.values(curObject)) {
9850
- this.safeObjectVisit(value, (obj) => this.visitNodeSpecific(obj, nodeCallBacks, nodeSpecificCallBacks));
9922
+ if (ogTransform) {
9923
+ ogTransform(casted);
9851
9924
  }
9852
- }
9925
+ };
9926
+ const preVisitWrapper = (curObject) => {
9927
+ let ogPreVisit;
9928
+ const casted = curObject;
9929
+ if (casted.type && casted.subType) {
9930
+ const specific = nodeSpecificCallBacks[casted.type];
9931
+ if (specific) {
9932
+ ogPreVisit = specific[casted.subType]?.preVisitor;
9933
+ }
9934
+ if (!ogPreVisit) {
9935
+ ogPreVisit = nodeCallBacks[casted.type]?.preVisitor;
9936
+ }
9937
+ }
9938
+ return ogPreVisit ? ogPreVisit(casted) : curObject;
9939
+ };
9940
+ this.visitObject(startObject, visitWrapper, preVisitWrapper);
9941
+ }
9942
+ traverseSubNodes(currentNode, traverseNode, traverseSubNode) {
9943
+ let didShortCut = false;
9944
+ const recurse = (curNode) => {
9945
+ let traverser;
9946
+ const subObj = traverseSubNode[curNode.type];
9947
+ if (subObj) {
9948
+ traverser = subObj[curNode.subType];
9949
+ }
9950
+ if (!traverser) {
9951
+ traverser = traverseNode[curNode.type];
9952
+ }
9953
+ if (traverser) {
9954
+ const { next, shortcut } = traverser(curNode);
9955
+ didShortCut = shortcut ?? false;
9956
+ if (!didShortCut) {
9957
+ for (const node of next ?? []) {
9958
+ if (didShortCut) {
9959
+ return;
9960
+ }
9961
+ recurse(node);
9962
+ }
9963
+ }
9964
+ }
9965
+ };
9966
+ recurse(currentNode);
9853
9967
  }
9854
9968
  };
9855
9969
 
@@ -10091,8 +10205,9 @@ __export(lexer_exports, {
10091
10205
  construct: () => construct,
10092
10206
  copy: () => copy,
10093
10207
  create: () => create,
10094
- dataClause: () => dataClause,
10095
10208
  deleteClause: () => deleteClause,
10209
+ deleteDataClause: () => deleteDataClause,
10210
+ deleteWhereClause: () => deleteWhereClause,
10096
10211
  describe: () => describe,
10097
10212
  distinct: () => distinct,
10098
10213
  drop: () => drop2,
@@ -10104,6 +10219,7 @@ __export(lexer_exports, {
10104
10219
  having: () => having,
10105
10220
  in_: () => in_,
10106
10221
  insertClause: () => insertClause,
10222
+ insertDataClause: () => insertDataClause,
10107
10223
  limit: () => limit,
10108
10224
  load: () => load,
10109
10225
  loadInto: () => loadInto,
@@ -10402,6 +10518,44 @@ var graph = createToken2({ name: "Graph", pattern: /graph/i, label: "GRAPH" });
10402
10518
  var graphAll = createToken2({ name: "GraphAll", pattern: /all/i, label: "ALL" });
10403
10519
  var allGraphTokens = LexerBuilder.create().add(named, default_, graph, graphAll);
10404
10520
 
10521
+ // ../../packages/rules-sparql-1-1/lib/lexer/lexerPatterns.js
10522
+ var pnCharsBasePattern = /[A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]|[\uD800-\uDB7F][\uDC00-\uDFFF]/;
10523
+ var pnCharsUPattern = new RegExp(`${pnCharsBasePattern.source}|_`);
10524
+ var varNamePattern = new RegExp(`((${pnCharsUPattern.source})|[0-9])((${pnCharsUPattern.source})|[0-9]|[\xB7\u0300-\u036F\u203F-\u2040])*`);
10525
+ var iriRefPattern = /<([^\u0000-\u0020"<>\\^`{|}])*>/;
10526
+ var pnCharsPattern = new RegExp(`(${pnCharsUPattern.source})|[\\-0-9\xB7\u0300-\u036F\u203F-\u2040]`);
10527
+ var pnPrefixPattern = new RegExp(`(${pnCharsBasePattern.source})(((${pnCharsPattern.source})|\\.)*(${pnCharsPattern.source}))?`);
10528
+ var pNameNsPattern = new RegExp(`(${pnPrefixPattern.source})?:`);
10529
+ var percentPattern = /%[\dA-Fa-f]{2}/;
10530
+ var pnLocalEscPattern = /\\[!#$%&'()*+,./;=?@\\_~-]/;
10531
+ var plxPattern = new RegExp(`(${percentPattern.source})|(${pnLocalEscPattern.source})`);
10532
+ var pnLocalPattern = new RegExp(`((${pnCharsUPattern.source})|:|[0-9]|(${plxPattern.source}))(((${pnCharsPattern.source})|\\.|:|(${plxPattern.source}))*((${pnCharsPattern.source})|:|(${plxPattern.source})))?`);
10533
+ var pNameLnPattern = new RegExp(`(${pNameNsPattern.source})(${pnLocalPattern.source})`);
10534
+ var blankNodeLabelPattern = new RegExp(`_:((${pnCharsUPattern.source})|[0-9])(((${pnCharsPattern.source})|\\.)*(${pnCharsPattern.source}))?`);
10535
+ var var1Pattern = new RegExp(`\\?(${varNamePattern.source})`);
10536
+ var var2Pattern = new RegExp(`\\$(${varNamePattern.source})`);
10537
+ var langTagPattern = /@[A-Za-z]+(-[\dA-Za-z]+)*/;
10538
+ var integerPattern = /\d+/;
10539
+ var decimalPattern2 = /\d+\.\d+/;
10540
+ var exponentPattern = /[Ee][+-]?\d+/;
10541
+ var doublePattern = new RegExp(`([0-9]+\\.[0-9]*(${exponentPattern.source}))|(\\.[0-9]+(${exponentPattern.source}))|([0-9]+(${exponentPattern.source}))`);
10542
+ var interferePositivePattern = new RegExp(`\\+${integerPattern.source}`);
10543
+ var decimalPositivePattern = new RegExp(`\\+${decimalPattern2.source}`);
10544
+ var doublePositivePattern = new RegExp(`\\+${doublePattern.source}`);
10545
+ var integerNegativePattern = new RegExp(`-${integerPattern.source}`);
10546
+ var decimalNegativePattern = new RegExp(`-${decimalPattern2.source}`);
10547
+ var doubleNegativePattern = new RegExp(`-${doublePattern.source}`);
10548
+ var echarPattern = /\\[\\"'bfnrt]/u;
10549
+ var stringLiteral1Pattern = new RegExp(`'(([^\\u0027\\u005C\\u000A\r])|(${echarPattern.source}))*'`);
10550
+ var stringLiteral2Pattern = new RegExp(`"(([^\\u0022\\u005C\\u000A\\u000D])|(${echarPattern.source}))*"`);
10551
+ var stringLiteralLong1Pattern = new RegExp(`'''(('|(''))?([^'\\\\]|(${echarPattern.source})))*'''`);
10552
+ var stringLiteralLong2Pattern = new RegExp(`"""(("|(""))?([^"\\\\]|(${echarPattern.source})))*"""`);
10553
+ var wsPattern = /[\u0009\u000A\u000D ]/;
10554
+ var nilPattern = new RegExp(`\\((${wsPattern.source})*\\)`);
10555
+ var anonPattern = new RegExp(`\\[(${wsPattern.source})*\\]`);
10556
+ var commentPattern = /#[^\n]*\n/;
10557
+ var atLeastOneBlankPattern = new RegExp(`((${wsPattern.source}+)|(${commentPattern.source}))+`);
10558
+
10405
10559
  // ../../packages/rules-sparql-1-1/lib/lexer/symbols.js
10406
10560
  var symbols_exports = {};
10407
10561
  __export(symbols_exports, {
@@ -10490,40 +10644,6 @@ __export(terminals_exports, {
10490
10644
  var2: () => var2,
10491
10645
  ws: () => ws
10492
10646
  });
10493
- var pnCharsBasePattern = /[A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]|[\uD800-\uDB7F][\uDC00-\uDFFF]/;
10494
- var pnCharsUPattern = new RegExp(`${pnCharsBasePattern.source}|_`);
10495
- var varNamePattern = new RegExp(`((${pnCharsUPattern.source})|[0-9])((${pnCharsUPattern.source})|[0-9]|[\xB7\u0300-\u036F\u203F-\u2040])*`);
10496
- var iriRefPattern = /<([^\u0000-\u0020"<>\\^`{|}])*>/;
10497
- var pnCharsPattern = new RegExp(`(${pnCharsUPattern.source})|[\\-0-9\xB7\u0300-\u036F\u203F-\u2040]`);
10498
- var pnPrefixPattern = new RegExp(`(${pnCharsBasePattern.source})(((${pnCharsPattern.source})|\\.)*(${pnCharsPattern.source}))?`);
10499
- var pNameNsPattern = new RegExp(`(${pnPrefixPattern.source})?:`);
10500
- var percentPattern = /%[\dA-Fa-f]{2}/;
10501
- var pnLocalEscPattern = /\\[!#$%&'()*+,./;=?@\\_~-]/;
10502
- var plxPattern = new RegExp(`(${percentPattern.source})|(${pnLocalEscPattern.source})`);
10503
- var pnLocalPattern = new RegExp(`((${pnCharsUPattern.source})|:|[0-9]|(${plxPattern.source}))(((${pnCharsPattern.source})|\\.|:|(${plxPattern.source}))*((${pnCharsPattern.source})|:|(${plxPattern.source})))?`);
10504
- var pNameLnPattern = new RegExp(`(${pNameNsPattern.source})(${pnLocalPattern.source})`);
10505
- var blankNodeLabelPattern = new RegExp(`_:((${pnCharsUPattern.source})|[0-9])(((${pnCharsPattern.source})|\\.)*(${pnCharsPattern.source}))?`);
10506
- var var1Pattern = new RegExp(`\\?(${varNamePattern.source})`);
10507
- var var2Pattern = new RegExp(`\\$(${varNamePattern.source})`);
10508
- var langTagPattern = /@[A-Za-z]+(-[\dA-Za-z]+)*/;
10509
- var integerPattern = /\d+/;
10510
- var decimalPattern2 = /\d+\.\d+/;
10511
- var exponentPattern = /[Ee][+-]?\d+/;
10512
- var doublePattern = new RegExp(`([0-9]+\\.[0-9]*(${exponentPattern.source}))|(\\.[0-9]+(${exponentPattern.source}))|([0-9]+(${exponentPattern.source}))`);
10513
- var interferePositivePattern = new RegExp(`\\+${integerPattern.source}`);
10514
- var decimalPositivePattern = new RegExp(`\\+${decimalPattern2.source}`);
10515
- var doublePositivePattern = new RegExp(`\\+${doublePattern.source}`);
10516
- var integerNegativePattern = new RegExp(`-${integerPattern.source}`);
10517
- var decimalNegativePattern = new RegExp(`-${decimalPattern2.source}`);
10518
- var doubleNegativePattern = new RegExp(`-${doublePattern.source}`);
10519
- var echarPattern = /\\[\\"'bfnrt]/u;
10520
- var stringLiteral1Pattern = new RegExp(`'(([^\\u0027\\u005C\\u000A\r])|(${echarPattern.source}))*'`);
10521
- var stringLiteral2Pattern = new RegExp(`"(([^\\u0022\\u005C\\u000A\\u000D])|(${echarPattern.source}))*"`);
10522
- var stringLiteralLong1Pattern = new RegExp(`'''(('|(''))?([^'\\\\]|(${echarPattern.source})))*'''`);
10523
- var stringLiteralLong2Pattern = new RegExp(`"""(("|(""))?([^"\\\\]|(${echarPattern.source})))*"""`);
10524
- var wsPattern = /[\u0009\u000A\u000D ]/;
10525
- var nilPattern = new RegExp(`\\((${wsPattern.source})*\\)`);
10526
- var anonPattern = new RegExp(`\\[(${wsPattern.source})*\\]`);
10527
10647
  var iriRef = createToken2({ name: "IriRef", pattern: iriRefPattern });
10528
10648
  var pNameLn = createToken2({ name: "PNameLn", pattern: pNameLnPattern });
10529
10649
  var pNameNs = createToken2({ name: "PNameNs", pattern: pNameNsPattern, longer_alt: [pNameLn] });
@@ -10545,7 +10665,7 @@ var stringLiteral2 = createToken2({ name: "StringLiteral2", pattern: stringLiter
10545
10665
  var stringLiteralLong1 = createToken2({ name: "StringLiteralLong1", pattern: stringLiteralLong1Pattern });
10546
10666
  var stringLiteralLong2 = createToken2({ name: "StringLiteralLong2", pattern: stringLiteralLong2Pattern });
10547
10667
  var ws = createToken2({ name: "Ws", pattern: wsPattern, group: Lexer.SKIPPED });
10548
- var comment = createToken2({ name: "Comment", pattern: /#[^\n]*/, group: Lexer.SKIPPED });
10668
+ var comment = createToken2({ name: "Comment", pattern: commentPattern, group: Lexer.SKIPPED });
10549
10669
  var nil = createToken2({ name: "Nil", pattern: nilPattern });
10550
10670
  var anon = createToken2({ name: "Anon", pattern: anonPattern });
10551
10671
  var allTerminals = LexerBuilder.create().add(iriRef, pNameNs, pNameLn, blankNodeLabel, var1, var2, langTag, double, decimal, integer, integerPositive, decimalPositive, doublePositive, integerNegative, decimalNegative, doubleNegative, stringLiteralLong1, stringLiteralLong2, stringLiteral1, stringLiteral2, ws, comment, nil, anon);
@@ -10582,9 +10702,23 @@ var to = createToken2({ name: "To", pattern: /to/i, label: "TO" });
10582
10702
  var move = createToken2({ name: "Move", pattern: /move/i, label: "MOVE" });
10583
10703
  var copy = createToken2({ name: "Copy", pattern: /copy/i, label: "COPY" });
10584
10704
  var modifyWith = createToken2({ name: "ModifyWith", pattern: /with/i, label: "WITH" });
10705
+ var deleteDataClause = createToken2({
10706
+ name: "DeleteDataClause",
10707
+ pattern: new RegExp(`delete(${atLeastOneBlankPattern.source})data`, "i"),
10708
+ label: "DELETE DATA"
10709
+ });
10710
+ var deleteWhereClause = createToken2({
10711
+ name: "DeleteWhereClause",
10712
+ pattern: new RegExp(`delete(${atLeastOneBlankPattern.source})where`, "i"),
10713
+ label: "DELETE WHERE"
10714
+ });
10585
10715
  var deleteClause = createToken2({ name: "DeleteClause", pattern: /delete/i, label: "DELETE" });
10586
- var insertClause = createToken2({ name: "InsertClause", pattern: /insert/i, label: "INSERT" });
10587
- var dataClause = createToken2({ name: "DataClause", pattern: /data/i, label: "DATA", longer_alt: datatype });
10716
+ var insertDataClause = createToken2({
10717
+ name: "InsertDataClause",
10718
+ pattern: new RegExp(`insert(${atLeastOneBlankPattern.source})data`, "i"),
10719
+ label: "INSERT DATA"
10720
+ });
10721
+ var insertClause = createToken2({ name: "InsertClause", pattern: /insert/i, label: "insert" });
10588
10722
  var usingClause = createToken2({ name: "UsingClause", pattern: /using/i, label: "USING" });
10589
10723
  var optional = createToken2({ name: "Optional", pattern: /optional/i, label: "OPTIONAL" });
10590
10724
  var service = createToken2({ name: "Service", pattern: /service/i, label: "SERVICE" });
@@ -10599,8 +10733,8 @@ var false_ = createToken2({ name: "False", pattern: /false/i, label: "false" });
10599
10733
  var in_ = createToken2({ name: "In", pattern: /in/i, label: "IN" });
10600
10734
  var notIn = createToken2({ name: "NotIn", pattern: /not[\u0020\u0009\u000D\u000A]+in/i, label: "NOT IN" });
10601
10735
  var separator = createToken2({ name: "Separator", pattern: /separator/i, label: "SEPARATOR" });
10602
- var allBaseTokens = LexerBuilder.create().add(baseDecl, prefixDecl, select, distinct, reduced, construct, describe, ask, from, where, having, groupByGroup, by, order, orderAsc, orderDesc, limit, offset, values2, load, silent, loadInto, clear, drop2, create, add, to, move, copy, modifyWith, deleteClause, insertClause, dataClause, usingClause, optional, service, bind, undef, minus, union, filter2, as, a, true_, false_, in_, notIn, separator);
10603
- var sparql11LexerBuilder = LexerBuilder.create(allTerminals).merge(allBaseTokens).merge(allBuiltInCalls).merge(allGraphTokens).merge(allSymbols).moveBefore(datatype, dataClause).moveAfter(avg, a).moveBefore(a, graphAll).moveAfter(groupConcat, groupByGroup);
10736
+ var allBaseTokens = LexerBuilder.create().add(baseDecl, prefixDecl, select, distinct, reduced, construct, describe, ask, from, where, having, groupByGroup, by, order, orderAsc, orderDesc, limit, offset, values2, load, silent, loadInto, clear, drop2, create, add, to, move, copy, modifyWith, deleteWhereClause, deleteDataClause, deleteClause, insertDataClause, insertClause, usingClause, optional, service, bind, undef, minus, union, filter2, as, a, true_, false_, in_, notIn, separator);
10737
+ var sparql11LexerBuilder = LexerBuilder.create(allTerminals).merge(allBaseTokens).merge(allBuiltInCalls).merge(allGraphTokens).merge(allSymbols).moveAfter(avg, a).moveBefore(a, graphAll).moveAfter(groupConcat, groupByGroup);
10604
10738
 
10605
10739
  // ../../packages/rules-sparql-1-1/lib/factoryMixins/ContextFactory.js
10606
10740
  var nodeType = "contextDef";
@@ -11363,12 +11497,12 @@ var CommonIRIs;
11363
11497
  CommonIRIs2["NIL"] = "http://www.w3.org/1999/02/22-rdf-syntax-ns#nil";
11364
11498
  CommonIRIs2["TYPE"] = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type";
11365
11499
  })(CommonIRIs || (CommonIRIs = {}));
11366
- var TransformerSparql11 = class extends TransformerSubType {
11500
+ var AstTransformer = class extends TransformerSubType {
11367
11501
  };
11368
11502
 
11369
11503
  // ../../packages/rules-sparql-1-1/lib/validation/validators.js
11370
11504
  var F = new AstFactory();
11371
- var transformer = new TransformerSparql11();
11505
+ var transformer = new AstTransformer();
11372
11506
  function getAggregatesOfExpression(expression2) {
11373
11507
  if (F.isExpressionAggregate(expression2)) {
11374
11508
  return [expression2];
@@ -11447,77 +11581,69 @@ function queryIsGood(query2) {
11447
11581
  }
11448
11582
  }
11449
11583
  }
11584
+ function notUndefined(some2) {
11585
+ return some2 !== void 0;
11586
+ }
11450
11587
  function findPatternBoundedVars(iter, boundedVars) {
11451
- if (F.isQuery(iter) || F.isUpdate(iter)) {
11452
- if (F.isQuerySelect(iter) || F.isQueryDescribe(iter)) {
11453
- if (iter.where && iter.variables.some((x) => F.isWildcard(x))) {
11454
- findPatternBoundedVars(iter.where, boundedVars);
11455
- } else {
11456
- for (const v of iter.variables) {
11457
- findPatternBoundedVars(v, boundedVars);
11458
- }
11459
- }
11460
- if (iter.solutionModifiers.group) {
11461
- const grouping = iter.solutionModifiers.group;
11462
- for (const g of grouping.groupings) {
11463
- if ("variable" in g) {
11464
- findPatternBoundedVars(g.variable, boundedVars);
11465
- }
11466
- }
11467
- }
11468
- if (iter.values?.values && iter.values.values.length > 0) {
11469
- const values3 = iter.values.values;
11470
- for (const v of Object.keys(values3[0])) {
11588
+ transformer.traverseSubNodes(iter, {
11589
+ query: (op) => ({ next: [
11590
+ op.solutionModifiers.group
11591
+ ].filter(notUndefined) }),
11592
+ triple: (op) => ({ next: [op.subject, op.predicate, op.object] }),
11593
+ path: (op) => ({ next: op.items }),
11594
+ tripleCollection: (op) => ({ next: [op.identifier, ...op.triples] })
11595
+ }, {
11596
+ query: {
11597
+ select: (op) => ({ next: [
11598
+ ...op.variables.some((x) => F.isWildcard(x)) ? [op.where] : op.variables,
11599
+ op.solutionModifiers.group,
11600
+ op.values
11601
+ ].filter(notUndefined) }),
11602
+ describe: (op) => ({ next: [
11603
+ ...op.variables.some((x) => F.isWildcard(x)) ? [op.where] : op.variables,
11604
+ op.solutionModifiers.group,
11605
+ op.values
11606
+ ].filter(notUndefined) })
11607
+ },
11608
+ solutionModifier: {
11609
+ group: (op) => ({
11610
+ next: op.groupings.filter((g) => "variable" in g).map((x) => x.variable)
11611
+ }),
11612
+ having: (op) => ({ next: op.having }),
11613
+ order: (op) => ({ next: op.orderDefs.map((x) => x.expression) })
11614
+ },
11615
+ pattern: {
11616
+ values: (op) => {
11617
+ for (const v of Object.keys(op.values.at(0) ?? {})) {
11471
11618
  boundedVars.add(v);
11472
11619
  }
11620
+ return {};
11621
+ },
11622
+ bgp: (op) => ({ next: op.triples }),
11623
+ group: (op) => ({ next: op.patterns }),
11624
+ union: (op) => ({ next: op.patterns }),
11625
+ optional: (op) => ({ next: op.patterns }),
11626
+ service: (op) => ({ next: [op.name, ...op.patterns] }),
11627
+ bind: (op) => ({ next: [op.variable] }),
11628
+ graph: (op) => ({ next: [op.name, ...op.patterns] }),
11629
+ minus: (op) => ({ next: op.patterns.slice(0, 1) })
11630
+ },
11631
+ term: {
11632
+ variable: (op) => {
11633
+ boundedVars.add(op.value);
11634
+ return {};
11473
11635
  }
11474
11636
  }
11475
- } else if (F.isTerm(iter)) {
11476
- if (F.isTermVariable(iter)) {
11477
- boundedVars.add(iter.value);
11478
- }
11479
- } else if (F.isTriple(iter)) {
11480
- findPatternBoundedVars(iter.subject, boundedVars);
11481
- findPatternBoundedVars(iter.predicate, boundedVars);
11482
- findPatternBoundedVars(iter.object, boundedVars);
11483
- } else if (F.isPath(iter)) {
11484
- if (!F.isTerm(iter)) {
11485
- for (const item of iter.items) {
11486
- findPatternBoundedVars(item, boundedVars);
11487
- }
11488
- }
11489
- } else if (F.isTripleCollection(iter) || F.isPatternBgp(iter)) {
11490
- for (const triple of iter.triples) {
11491
- findPatternBoundedVars(triple, boundedVars);
11492
- }
11493
- } else if (F.isPatternGroup(iter) || F.isPatternUnion(iter) || F.isPatternOptional(iter) || F.isPatternService(iter)) {
11494
- for (const pattern of iter.patterns) {
11495
- findPatternBoundedVars(pattern, boundedVars);
11496
- }
11497
- if (F.isPatternService(iter)) {
11498
- findPatternBoundedVars(iter.name, boundedVars);
11499
- }
11500
- } else if (F.isPatternBind(iter)) {
11501
- findPatternBoundedVars(iter.variable, boundedVars);
11502
- } else if (F.isPatternValues(iter)) {
11503
- for (const variable of Object.keys(iter.values.at(0) ?? {})) {
11504
- boundedVars.add(variable);
11505
- }
11506
- } else if (F.isPatternGraph(iter)) {
11507
- findPatternBoundedVars(iter.name, boundedVars);
11508
- for (const pattern of iter.patterns) {
11509
- findPatternBoundedVars(pattern, boundedVars);
11510
- }
11511
- }
11637
+ });
11512
11638
  }
11513
11639
  function checkNote13(patterns) {
11514
11640
  for (const [index, pattern] of patterns.entries()) {
11515
11641
  if (F.isPatternBind(pattern) && index > 0 && F.isPatternBgp(patterns[index - 1])) {
11516
11642
  const bgp = patterns[index - 1];
11517
11643
  const variables = [];
11518
- transformer.visitNodeSpecific(bgp, {}, { term: { variable: (var_2) => {
11644
+ transformer.visitNodeSpecific(bgp, {}, { term: { variable: { visitor: (var_2) => {
11519
11645
  variables.push(var_2);
11520
- } } });
11646
+ } } } });
11521
11647
  if (variables.some((var_2) => var_2.value === pattern.variable.value)) {
11522
11648
  throw new Error(`Variable used to bind is already bound (?${pattern.variable.value})`);
11523
11649
  }
@@ -11543,12 +11669,12 @@ function updateNoReuseBlankNodeLabels(updateQuery) {
11543
11669
  const operation = update2.operation;
11544
11670
  if (operation.subType === "insertdata") {
11545
11671
  const blankNodesHere = /* @__PURE__ */ new Set();
11546
- transformer.visitNodeSpecific(operation, {}, { term: { blankNode: (blankNode2) => {
11672
+ transformer.visitNodeSpecific(operation, {}, { term: { blankNode: { visitor: (blankNode2) => {
11547
11673
  blankNodesHere.add(blankNode2.label);
11548
11674
  if (blankLabelsUsedInInsertData.has(blankNode2.label)) {
11549
11675
  throw new Error("Detected reuse blank node across different INSERT DATA clauses");
11550
11676
  }
11551
- } } });
11677
+ } } } });
11552
11678
  for (const blankNode2 of blankNodesHere) {
11553
11679
  blankLabelsUsedInInsertData.add(blankNode2);
11554
11680
  }
@@ -14235,12 +14361,11 @@ var quadData = {
14235
14361
  return ACTION(() => C.astFactory.wrap(val.val, C.astFactory.sourceLocation(open, close)));
14236
14362
  }
14237
14363
  };
14238
- function insertDeleteDelWhere(name, subType, cons1, cons2, dataRule) {
14364
+ function insertDeleteDelWhere(name, subType, cons1, dataRule) {
14239
14365
  return {
14240
14366
  name,
14241
14367
  impl: ({ ACTION, SUBRULE1, CONSUME }) => (C) => {
14242
14368
  const insDelToken = CONSUME(cons1);
14243
- CONSUME(cons2);
14244
14369
  let couldCreateBlankNodes = true;
14245
14370
  if (name !== "insertData") {
14246
14371
  couldCreateBlankNodes = ACTION(() => C.parseMode.delete("canCreateBlankNodes"));
@@ -14272,9 +14397,9 @@ function insertDeleteDelWhere(name, subType, cons1, cons2, dataRule) {
14272
14397
  }
14273
14398
  };
14274
14399
  }
14275
- var insertData = insertDeleteDelWhere("insertData", "insertdata", insertClause, dataClause, quadData);
14276
- var deleteData = insertDeleteDelWhere("deleteData", "deletedata", deleteClause, dataClause, quadData);
14277
- var deleteWhere = insertDeleteDelWhere("deleteWhere", "deletewhere", deleteClause, where, quadPattern);
14400
+ var insertData = insertDeleteDelWhere("insertData", "insertdata", insertDataClause, quadData);
14401
+ var deleteData = insertDeleteDelWhere("deleteData", "deletedata", deleteDataClause, quadData);
14402
+ var deleteWhere = insertDeleteDelWhere("deleteWhere", "deletewhere", deleteWhereClause, quadPattern);
14278
14403
  var modify = {
14279
14404
  name: "modify",
14280
14405
  impl: ({ ACTION, CONSUME, SUBRULE1, SUBRULE2, OPTION1, OPTION2, OR }) => (C) => {
package/package.json CHANGED
@@ -1,7 +1,7 @@
1
1
  {
2
2
  "name": "@traqula/parser-sparql-1-2",
3
3
  "type": "module",
4
- "version": "0.0.16",
4
+ "version": "0.0.18",
5
5
  "description": "SPARQL 1.2 parser",
6
6
  "lsd:module": true,
7
7
  "license": "MIT",
@@ -53,17 +53,17 @@
53
53
  "spec:earl": "yarn spec:earl:query-1-1 && yarn spec:earl:update-1-1"
54
54
  },
55
55
  "dependencies": {
56
- "@traqula/core": "^0.0.16",
57
- "@traqula/parser-sparql-1-1": "^0.0.16",
58
- "@traqula/rules-sparql-1-1": "^0.0.16",
59
- "@traqula/rules-sparql-1-2": "^0.0.16",
56
+ "@traqula/core": "^0.0.18",
57
+ "@traqula/parser-sparql-1-1": "^0.0.18",
58
+ "@traqula/rules-sparql-1-1": "^0.0.18",
59
+ "@traqula/rules-sparql-1-2": "^0.0.18",
60
60
  "rdf-data-factory": "^2.0.1"
61
61
  },
62
62
  "devDependencies": {
63
63
  "@rdfjs/types": "^2.0.0",
64
- "@traqula/test-utils": "^0.0.16",
64
+ "@traqula/test-utils": "^0.0.18",
65
65
  "rdf-data-factory": "^2.0.1",
66
66
  "rdf-test-suite": "^2.0.0"
67
67
  },
68
- "gitHead": "2de4ee608a2337bed63ecc5cf336b1a57c39e45f"
68
+ "gitHead": "1bb6a7d67631010ee01b325e33ff76f2f7530e02"
69
69
  }