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

package/lib/expressionParser.d.ts

@@ -0,0 +1,93 @@
+import { ParserBuilder } from '@traqula/core';
+import { gram } from '@traqula/rules-sparql-1-1';
+export declare const expressionParserBuilder: ParserBuilder<import("@traqula/rules-sparql-1-1").SparqlContext, "string" | "var" | "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" | "builtInCount" | "builtInSum" | "builtInMin" | "builtInMax" | "builtInAvg" | "builtInSample" | "builtInGroup_concat" | "aggregate" | "rdfLiteral" | "iri" | "numericLiteral" | "numericLiteralUnsigned" | "numericLiteralPositive" | "numericLiteralNegative" | "booleanLiteral" | "prefixedName" | "expression" | "brackettedExpression" | "builtInCall" | "argList" | "expressionList" | "conditionalOrExpression" | "iriOrFunction" | "conditionalAndExpression" | "valueLogical" | "relationalExpression" | "numericExpression" | "additiveExpression" | "multiplicativeExpression" | "unaryExpression" | "primaryExpression", {
+    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>;
+    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>;
+    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]>;
+    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"> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"builtInGroup_concat", import("@traqula/rules-sparql-1-1").AggregateExpression>;
+    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"> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"numericLiteral", import("@rdfjs/types").Literal>;
+    numericLiteralUnsigned: import("@traqula/core").ParserRule<any, "numericLiteralUnsigned"> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"numericLiteralUnsigned", import("@rdfjs/types").Literal>;
+    numericLiteralPositive: import("@traqula/core").ParserRule<any, "numericLiteralPositive"> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"numericLiteralPositive", import("@rdfjs/types").Literal>;
+    numericLiteralNegative: import("@traqula/core").ParserRule<any, "numericLiteralNegative"> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"numericLiteralNegative", import("@rdfjs/types").Literal>;
+    booleanLiteral: import("@traqula/core").ParserRule<any, "booleanLiteral"> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"booleanLiteral", import("@rdfjs/types").Literal>;
+    prefixedName: import("@traqula/core").ParserRule<any, "prefixedName"> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"prefixedName", import("@traqula/rules-sparql-1-1").IriTerm>;
+    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>;
+    brackettedExpression: import("@traqula/core").ParserRule<any, "brackettedExpression"> & import("@traqula/rules-sparql-1-1").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"> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"expressionList", import("@traqula/rules-sparql-1-1").Expression[]>;
+    conditionalOrExpression: import("@traqula/core").ParserRule<any, "conditionalOrExpression"> & import("@traqula/rules-sparql-1-1").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"> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"conditionalAndExpression", import("@traqula/rules-sparql-1-1").Expression>;
+    valueLogical: import("@traqula/core").ParserRule<any, "valueLogical"> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"valueLogical", import("@traqula/rules-sparql-1-1").Expression>;
+    relationalExpression: import("@traqula/core").ParserRule<any, "relationalExpression"> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"relationalExpression", import("@traqula/rules-sparql-1-1").Expression>;
+    numericExpression: import("@traqula/core").ParserRule<any, "numericExpression"> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"numericExpression", import("@traqula/rules-sparql-1-1").Expression>;
+    additiveExpression: import("@traqula/core").ParserRule<any, "additiveExpression"> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"additiveExpression", import("@traqula/rules-sparql-1-1").Expression>;
+    multiplicativeExpression: import("@traqula/core").ParserRule<any, "multiplicativeExpression"> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"multiplicativeExpression", import("@traqula/rules-sparql-1-1").Expression>;
+    unaryExpression: import("@traqula/core").ParserRule<any, "unaryExpression"> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"unaryExpression", import("@traqula/rules-sparql-1-1").Expression>;
+    primaryExpression: import("@traqula/core").ParserRule<any, "primaryExpression"> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"primaryExpression", import("@traqula/rules-sparql-1-1").Expression>;
+}>;

package/lib/expressionParser.js

@@ -0,0 +1,51 @@
+import { ParserBuilder } from '@traqula/core';
+import { gram } from '@traqula/rules-sparql-1-1';
+const rulesNoBuiltIn = [
+    gram.expression,
+    gram.conditionalOrExpression,
+    gram.conditionalAndExpression,
+    gram.valueLogical,
+    gram.relationalExpression,
+    gram.numericExpression,
+    gram.expressionList,
+    gram.additiveExpression,
+    gram.multiplicativeExpression,
+    gram.unaryExpression,
+    gram.primaryExpression,
+    gram.brackettedExpression,
+    // BuiltInCall,
+    gram.iriOrFunction,
+    gram.rdfLiteral,
+    gram.numericLiteral,
+    gram.numericLiteralUnsigned,
+    gram.numericLiteralPositive,
+    gram.numericLiteralNegative,
+    gram.booleanLiteral,
+    gram.var_,
+    gram.builtInStr,
+    gram.builtInLang,
+    gram.builtInLangmatches,
+    gram.builtInDatatype,
+    gram.builtInBound,
+    gram.builtInIri,
+    gram.builtInUri,
+    gram.builtInBnodeSparqlJs,
+    gram.builtInRand,
+    gram.builtInAbs,
+    gram.builtInCeil,
+    gram.builtInFloor,
+    gram.builtInRound,
+    gram.builtInConcat,
+    gram.builtInStrlen,
+    gram.builtInUcase,
+    gram.builtInLcase,
+    gram.builtInEncode_for_uri,
+];
+const builtInPatch = {
+    name: 'builtInCall',
+    impl: ({ OR, SUBRULE }) => () => OR(gram.builtInCallList(SUBRULE).slice(0, -2)),
+};
+export const expressionParserBuilder = ParserBuilder.createBuilder(rulesNoBuiltIn)
+    .addMany(gram.builtInContains, gram.builtInStrstarts, gram.builtInStrends, gram.builtInStrbefore, gram.builtInStrafter, gram.builtInYear, gram.builtInMonth, gram.builtInDay, gram.builtInHours, gram.builtInMinutes, gram.builtInSeconds, gram.builtInTimezone, gram.builtInTz, gram.builtInNow, gram.builtInUuid, gram.builtInStruuid, gram.builtInMd5, gram.builtInSha1, gram.builtInSha256, gram.builtInSha384, gram.builtInSha512, gram.builtInCoalesce, gram.builtInIf, gram.builtInStrlang, gram.builtInStrdt, gram.builtInSameterm, gram.builtInIsiri, gram.builtInIsuri, gram.builtInIsblank, gram.builtInIsliteral, gram.builtInIsnumeric, gram.regexExpression, gram.substringExpression, gram.strReplaceExpression, gram.aggregateCount, gram.aggregateSum, gram.aggregateMin, gram.aggregateMax, gram.aggregateAvg, gram.aggregateSample, gram.aggregateGroup_concat, gram.aggregate, gram.iri, gram.prefixedName, gram.argList, gram.string)
+    .addRule(builtInPatch);
+//# sourceMappingURL=expressionParser.js.map

package/lib/expressionParser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"expressionParser.js","sourceRoot":"","sources":["expressionParser.ts"],"names":[],"mappings":"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","sourcesContent":["import { ParserBuilder } from '@traqula/core';\nimport { gram } from '@traqula/rules-sparql-1-1';\n\nconst rulesNoBuiltIn = <const> [\n  gram.expression,\n  gram.conditionalOrExpression,\n  gram.conditionalAndExpression,\n  gram.valueLogical,\n  gram.relationalExpression,\n  gram.numericExpression,\n  gram.expressionList,\n  gram.additiveExpression,\n  gram.multiplicativeExpression,\n  gram.unaryExpression,\n  gram.primaryExpression,\n  gram.brackettedExpression,\n  // BuiltInCall,\n  gram.iriOrFunction,\n  gram.rdfLiteral,\n  gram.numericLiteral,\n  gram.numericLiteralUnsigned,\n  gram.numericLiteralPositive,\n  gram.numericLiteralNegative,\n  gram.booleanLiteral,\n  gram.var_,\n  gram.builtInStr,\n  gram.builtInLang,\n  gram.builtInLangmatches,\n  gram.builtInDatatype,\n  gram.builtInBound,\n  gram.builtInIri,\n  gram.builtInUri,\n  gram.builtInBnodeSparqlJs,\n  gram.builtInRand,\n  gram.builtInAbs,\n  gram.builtInCeil,\n  gram.builtInFloor,\n  gram.builtInRound,\n  gram.builtInConcat,\n  gram.builtInStrlen,\n  gram.builtInUcase,\n  gram.builtInLcase,\n  gram.builtInEncode_for_uri,\n];\n\nconst builtInPatch: typeof gram.builtInCall = {\n  name: 'builtInCall',\n  impl: ({ OR, SUBRULE }) => () => OR(gram.builtInCallList(SUBRULE).slice(0, -2)),\n};\n\nexport const expressionParserBuilder = ParserBuilder.createBuilder(rulesNoBuiltIn)\n  .addMany(\n    gram.builtInContains,\n    gram.builtInStrstarts,\n    gram.builtInStrends,\n    gram.builtInStrbefore,\n    gram.builtInStrafter,\n    gram.builtInYear,\n    gram.builtInMonth,\n    gram.builtInDay,\n    gram.builtInHours,\n    gram.builtInMinutes,\n    gram.builtInSeconds,\n    gram.builtInTimezone,\n    gram.builtInTz,\n    gram.builtInNow,\n    gram.builtInUuid,\n    gram.builtInStruuid,\n    gram.builtInMd5,\n    gram.builtInSha1,\n    gram.builtInSha256,\n    gram.builtInSha384,\n    gram.builtInSha512,\n    gram.builtInCoalesce,\n    gram.builtInIf,\n    gram.builtInStrlang,\n    gram.builtInStrdt,\n    gram.builtInSameterm,\n    gram.builtInIsiri,\n    gram.builtInIsuri,\n    gram.builtInIsblank,\n    gram.builtInIsliteral,\n    gram.builtInIsnumeric,\n    gram.regexExpression,\n    gram.substringExpression,\n    gram.strReplaceExpression,\n    gram.aggregateCount,\n    gram.aggregateSum,\n    gram.aggregateMin,\n    gram.aggregateMax,\n    gram.aggregateAvg,\n    gram.aggregateSample,\n    gram.aggregateGroup_concat,\n    gram.aggregate,\n    gram.iri,\n    gram.prefixedName,\n    gram.argList,\n    gram.string,\n  )\n  .addRule(builtInPatch);\n"]}