@traqula/rules-sparql-1-1 0.0.4 → 0.0.5

package/lib/index.cjs

@@ -22,7 +22,7 @@ var index_exports = {};
 __export(index_exports, {
   CommonIRIs: () => CommonIRIs,
   Factory: () => Factory,
-  SparqlParser: () => SparqlParser,
+  MinimalSparqlParser: () => MinimalSparqlParser,
   baseAggregateFunc: () => baseAggregateFunc,
   checkNote13: () => checkNote13,
   completeParseContext: () => completeParseContext,
@@ -228,6 +228,7 @@ __export(grammar_exports, {
   quads: () => quads,
   quadsNotTriples: () => quadsNotTriples,
   query: () => query,
+  queryOrUpdate: () => queryOrUpdate,
   queryUnit: () => queryUnit,
   rdfLiteral: () => rdfLiteral,
   regexExpression: () => regexExpression,
@@ -276,7 +277,7 @@ __export(lexer_exports, {
   ask: () => ask,
   baseDecl: () => baseDecl,
   bind: () => bind,
-  builtIn: () => BuildinCalls_exports,
+  builtIn: () => BuiltInCalls_exports,
   by: () => by,
   clear: () => clear,
   construct: () => construct,
@@ -313,7 +314,7 @@ __export(lexer_exports, {
   separator: () => separator,
   service: () => service,
   silent: () => silent,
-  sparql11Tokens: () => sparql11Tokens,
+  sparql11LexerBuilder: () => sparql11LexerBuilder,
   symbols: () => symbols_exports,
   terminals: () => terminals_exports,
   to: () => to,
@@ -325,10 +326,10 @@ __export(lexer_exports, {
   where: () => where
 });
 
-// lib/lexer/BuildinCalls.ts
-var BuildinCalls_exports = {};
-__export(BuildinCalls_exports, {
-  BuildInCalls: () => BuildInCalls,
+// lib/lexer/BuiltInCalls.ts
+var BuiltInCalls_exports = {};
+__export(BuiltInCalls_exports, {
+  BuiltInCalls: () => BuiltInCalls,
   abs: () => abs,
   allBuiltInCalls: () => allBuiltInCalls,
   avg: () => avg,
@@ -721,10 +722,10 @@ var coreJsData = root_default["__core-js_shared__"];
 var coreJsData_default = coreJsData;
 
 // ../../node_modules/lodash-es/_isMasked.js
-var maskSrcKey = function() {
+var maskSrcKey = (function() {
   var uid = /[^.]+$/.exec(coreJsData_default && coreJsData_default.keys && coreJsData_default.keys.IE_PROTO || "");
   return uid ? "Symbol(src)_1." + uid : "";
-}();
+})();
 function isMasked(func) {
   return !!maskSrcKey && maskSrcKey in func;
 }
@@ -786,7 +787,7 @@ var WeakMap_default = WeakMap;
 
 // ../../node_modules/lodash-es/_baseCreate.js
 var objectCreate = Object.create;
-var baseCreate = /* @__PURE__ */ function() {
+var baseCreate = /* @__PURE__ */ (function() {
   function object2() {
   }
   return function(proto) {
@@ -801,7 +802,7 @@ var baseCreate = /* @__PURE__ */ function() {
     object2.prototype = void 0;
     return result;
   };
-}();
+})();
 var baseCreate_default = baseCreate;
 
 // ../../node_modules/lodash-es/_apply.js
@@ -866,14 +867,14 @@ function constant(value) {
 var constant_default = constant;
 
 // ../../node_modules/lodash-es/_defineProperty.js
-var defineProperty = function() {
+var defineProperty = (function() {
   try {
     var func = getNative_default(Object, "defineProperty");
     func({}, "", {});
     return func;
   } catch (e) {
   }
-}();
+})();
 var defineProperty_default = defineProperty;
 
 // ../../node_modules/lodash-es/_baseSetToString.js
@@ -1111,9 +1112,9 @@ var baseIsArguments_default = baseIsArguments;
 var objectProto6 = Object.prototype;
 var hasOwnProperty4 = objectProto6.hasOwnProperty;
 var propertyIsEnumerable = objectProto6.propertyIsEnumerable;
-var isArguments = baseIsArguments_default(/* @__PURE__ */ function() {
+var isArguments = baseIsArguments_default(/* @__PURE__ */ (function() {
   return arguments;
-}()) ? baseIsArguments_default : function(value) {
+})()) ? baseIsArguments_default : function(value) {
   return isObjectLike_default(value) && hasOwnProperty4.call(value, "callee") && !propertyIsEnumerable.call(value, "callee");
 };
 var isArguments_default = isArguments;
@@ -1179,7 +1180,7 @@ var freeExports2 = typeof exports == "object" && exports && !exports.nodeType &&
 var freeModule2 = freeExports2 && typeof module == "object" && module && !module.nodeType && module;
 var moduleExports2 = freeModule2 && freeModule2.exports === freeExports2;
 var freeProcess = moduleExports2 && freeGlobal_default.process;
-var nodeUtil = function() {
+var nodeUtil = (function() {
   try {
     var types = freeModule2 && freeModule2.require && freeModule2.require("util").types;
     if (types) {
@@ -1188,7 +1189,7 @@ var nodeUtil = function() {
     return freeProcess && freeProcess.binding && freeProcess.binding("util");
   } catch (e) {
   }
-}();
+})();
 var nodeUtil_default = nodeUtil;
 
 // ../../node_modules/lodash-es/isTypedArray.js
@@ -9733,6 +9734,7 @@ applyMixins(Parser, [
 
 // ../core/lib/lexer-builder/LexerBuilder.ts
 var LexerBuilder = class _LexerBuilder {
+  tokens;
   static create(starter) {
     return new _LexerBuilder(starter);
   }
@@ -9890,71 +9892,71 @@ var Transformer = class {
   }
 };
 
-// lib/lexer/BuildinCalls.ts
-var BuildInCalls = /* @__PURE__ */ ((BuildInCalls2) => {
-  BuildInCalls2["Str"] = "builtInStr";
-  BuildInCalls2["Lang"] = "builtInLang";
-  BuildInCalls2["Langmatches"] = "builtInLangmatches";
-  BuildInCalls2["Datatype"] = "builtInDatatype";
-  BuildInCalls2["Bound"] = "builtInBound";
-  BuildInCalls2["Iri"] = "builtInIri";
-  BuildInCalls2["Uri"] = "builtInUri";
-  BuildInCalls2["Bnode"] = "builtInBnode";
-  BuildInCalls2["Rand"] = "builtInRand";
-  BuildInCalls2["Abs"] = "builtInAbs";
-  BuildInCalls2["Ceil"] = "builtInCeil";
-  BuildInCalls2["Floor"] = "builtInFloor";
-  BuildInCalls2["Round"] = "builtInRound";
-  BuildInCalls2["Concat"] = "builtInConcat";
-  BuildInCalls2["Strlen"] = "builtInStrlen";
-  BuildInCalls2["Ucase"] = "builtInUcase";
-  BuildInCalls2["Lcase"] = "builtInLcase";
-  BuildInCalls2["Encode_for_uri"] = "builtInEncode_for_uri";
-  BuildInCalls2["Contains"] = "builtInContains";
-  BuildInCalls2["Strstarts"] = "builtInStrstarts";
-  BuildInCalls2["Strends"] = "builtInStrends";
-  BuildInCalls2["Strbefore"] = "builtInStrbefore";
-  BuildInCalls2["Strafter"] = "builtInStrafter";
-  BuildInCalls2["Year"] = "builtInYear";
-  BuildInCalls2["Month"] = "builtInMonth";
-  BuildInCalls2["Day"] = "builtInDay";
-  BuildInCalls2["Hours"] = "builtInHours";
-  BuildInCalls2["Minutes"] = "builtInMinutes";
-  BuildInCalls2["Seconds"] = "builtInSeconds";
-  BuildInCalls2["Timezone"] = "builtInTimezone";
-  BuildInCalls2["Tz"] = "builtInTz";
-  BuildInCalls2["Now"] = "builtInNow";
-  BuildInCalls2["Uuid"] = "builtInUuid";
-  BuildInCalls2["Struuid"] = "builtInStruuid";
-  BuildInCalls2["Md5"] = "builtInMd5";
-  BuildInCalls2["Sha1"] = "builtInSha1";
-  BuildInCalls2["Sha256"] = "builtInSha256";
-  BuildInCalls2["Sha384"] = "builtInSha384";
-  BuildInCalls2["Sha512"] = "builtInSha512";
-  BuildInCalls2["Coalesce"] = "builtInCoalesce";
-  BuildInCalls2["If"] = "builtInIf";
-  BuildInCalls2["Strlang"] = "builtInStrlang";
-  BuildInCalls2["Strdt"] = "builtInStrdt";
-  BuildInCalls2["Sameterm"] = "builtInSameterm";
-  BuildInCalls2["Isiri"] = "builtInIsiri";
-  BuildInCalls2["Isuri"] = "builtInIsuri";
-  BuildInCalls2["Isblank"] = "builtInIsblank";
-  BuildInCalls2["Isliteral"] = "builtInIsliteral";
-  BuildInCalls2["Isnumeric"] = "builtInIsnumeric";
-  BuildInCalls2["Regex"] = "builtInRegex";
-  BuildInCalls2["Substr"] = "builtInSubstr";
-  BuildInCalls2["Replace"] = "builtInReplace";
-  BuildInCalls2["Exists"] = "builtInExists";
-  BuildInCalls2["Notexists"] = "builtInNotexists";
-  BuildInCalls2["Count"] = "builtInCount";
-  BuildInCalls2["Sum"] = "builtInSum";
-  BuildInCalls2["Min"] = "builtInMin";
-  BuildInCalls2["Max"] = "builtInMax";
-  BuildInCalls2["Avg"] = "builtInAvg";
-  BuildInCalls2["Sample"] = "builtInSample";
-  BuildInCalls2["Group_concat"] = "builtInGroup_concat";
-  return BuildInCalls2;
-})(BuildInCalls || {});
+// lib/lexer/BuiltInCalls.ts
+var BuiltInCalls = /* @__PURE__ */ ((BuiltInCalls2) => {
+  BuiltInCalls2["Str"] = "builtInStr";
+  BuiltInCalls2["Lang"] = "builtInLang";
+  BuiltInCalls2["Langmatches"] = "builtInLangmatches";
+  BuiltInCalls2["Datatype"] = "builtInDatatype";
+  BuiltInCalls2["Bound"] = "builtInBound";
+  BuiltInCalls2["Iri"] = "builtInIri";
+  BuiltInCalls2["Uri"] = "builtInUri";
+  BuiltInCalls2["Bnode"] = "builtInBnode";
+  BuiltInCalls2["Rand"] = "builtInRand";
+  BuiltInCalls2["Abs"] = "builtInAbs";
+  BuiltInCalls2["Ceil"] = "builtInCeil";
+  BuiltInCalls2["Floor"] = "builtInFloor";
+  BuiltInCalls2["Round"] = "builtInRound";
+  BuiltInCalls2["Concat"] = "builtInConcat";
+  BuiltInCalls2["Strlen"] = "builtInStrlen";
+  BuiltInCalls2["Ucase"] = "builtInUcase";
+  BuiltInCalls2["Lcase"] = "builtInLcase";
+  BuiltInCalls2["Encode_for_uri"] = "builtInEncode_for_uri";
+  BuiltInCalls2["Contains"] = "builtInContains";
+  BuiltInCalls2["Strstarts"] = "builtInStrstarts";
+  BuiltInCalls2["Strends"] = "builtInStrends";
+  BuiltInCalls2["Strbefore"] = "builtInStrbefore";
+  BuiltInCalls2["Strafter"] = "builtInStrafter";
+  BuiltInCalls2["Year"] = "builtInYear";
+  BuiltInCalls2["Month"] = "builtInMonth";
+  BuiltInCalls2["Day"] = "builtInDay";
+  BuiltInCalls2["Hours"] = "builtInHours";
+  BuiltInCalls2["Minutes"] = "builtInMinutes";
+  BuiltInCalls2["Seconds"] = "builtInSeconds";
+  BuiltInCalls2["Timezone"] = "builtInTimezone";
+  BuiltInCalls2["Tz"] = "builtInTz";
+  BuiltInCalls2["Now"] = "builtInNow";
+  BuiltInCalls2["Uuid"] = "builtInUuid";
+  BuiltInCalls2["Struuid"] = "builtInStruuid";
+  BuiltInCalls2["Md5"] = "builtInMd5";
+  BuiltInCalls2["Sha1"] = "builtInSha1";
+  BuiltInCalls2["Sha256"] = "builtInSha256";
+  BuiltInCalls2["Sha384"] = "builtInSha384";
+  BuiltInCalls2["Sha512"] = "builtInSha512";
+  BuiltInCalls2["Coalesce"] = "builtInCoalesce";
+  BuiltInCalls2["If"] = "builtInIf";
+  BuiltInCalls2["Strlang"] = "builtInStrlang";
+  BuiltInCalls2["Strdt"] = "builtInStrdt";
+  BuiltInCalls2["Sameterm"] = "builtInSameterm";
+  BuiltInCalls2["Isiri"] = "builtInIsiri";
+  BuiltInCalls2["Isuri"] = "builtInIsuri";
+  BuiltInCalls2["Isblank"] = "builtInIsblank";
+  BuiltInCalls2["Isliteral"] = "builtInIsliteral";
+  BuiltInCalls2["Isnumeric"] = "builtInIsnumeric";
+  BuiltInCalls2["Regex"] = "builtInRegex";
+  BuiltInCalls2["Substr"] = "builtInSubstr";
+  BuiltInCalls2["Replace"] = "builtInReplace";
+  BuiltInCalls2["Exists"] = "builtInExists";
+  BuiltInCalls2["Notexists"] = "builtInNotexists";
+  BuiltInCalls2["Count"] = "builtInCount";
+  BuiltInCalls2["Sum"] = "builtInSum";
+  BuiltInCalls2["Min"] = "builtInMin";
+  BuiltInCalls2["Max"] = "builtInMax";
+  BuiltInCalls2["Avg"] = "builtInAvg";
+  BuiltInCalls2["Sample"] = "builtInSample";
+  BuiltInCalls2["Group_concat"] = "builtInGroup_concat";
+  return BuiltInCalls2;
+})(BuiltInCalls || {});
 function capitalize(string2) {
   return string2.charAt(0).toUpperCase() + string2.slice(1);
 }
@@ -10458,7 +10460,7 @@ var allBaseTokens = LexerBuilder.create().add(
   notIn,
   separator
 );
-var sparql11Tokens = LexerBuilder.create(allTerminals).merge(allBaseTokens).merge(allBuiltInCalls).merge(allGraphTokens).merge(allSymbols).moveBefore(datatype, dataClause).moveAfter(avg, a).moveBefore(a, graphAll).moveAfter(groupConcat, groupByGroup);
+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);
 
 // lib/factoryMixins/ContextFactory.ts
 var nodeType = "contextDef";
@@ -10903,10 +10905,7 @@ function SolutionModifiersFactoryMixin(Base) {
 var nodeType8 = "term";
 function TermFactoryMixin(Base) {
   return class TermFactory extends Base {
-    constructor() {
-      super(...arguments);
-      this.__blankNodeCounter = 0;
-    }
+    __blankNodeCounter = 0;
     resetBlankNodeCounter() {
       this.__blankNodeCounter = 0;
     }
@@ -11657,6 +11656,120 @@ var verbA = {
   }
 };
 
+// lib/grammar/general.ts
+var prologue = {
+  name: "prologue",
+  impl: ({ SUBRULE, MANY, OR }) => () => {
+    const result = [];
+    MANY(() => OR([
+      { ALT: () => result.push(SUBRULE(baseDecl2)) },
+      // TODO: the [spec](https://www.w3.org/TR/sparql11-query/#iriRefs) says you cannot redefine prefixes.
+      //  We might need to check this.
+      { ALT: () => result.push(SUBRULE(prefixDecl2)) }
+    ]));
+    return result;
+  },
+  gImpl: ({ SUBRULE }) => (ast, { factory: F2 }) => {
+    for (const context of ast) {
+      if (F2.isContextDefinitionBase(context)) {
+        SUBRULE(baseDecl2, context);
+      } else if (F2.isContextDefinitionPrefix(context)) {
+        SUBRULE(prefixDecl2, context);
+      }
+    }
+  }
+};
+var baseDecl2 = {
+  name: "baseDecl",
+  impl: ({ ACTION, CONSUME, SUBRULE }) => (C) => {
+    const base = CONSUME(baseDecl);
+    const val = SUBRULE(iriFull);
+    return ACTION(() => C.factory.contextDefinitionBase(C.factory.sourceLocation(base, val), val));
+  },
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
+    F2.printFilter(ast, () => PRINT_WORD("BASE"));
+    SUBRULE(iri2, ast.value);
+  }
+};
+var prefixDecl2 = {
+  name: "prefixDecl",
+  impl: ({ ACTION, CONSUME, SUBRULE }) => (C) => {
+    const prefix = CONSUME(prefixDecl);
+    const name = CONSUME(terminals_exports.pNameNs).image.slice(0, -1);
+    const value = SUBRULE(iriFull);
+    return ACTION(() => C.factory.contextDefinitionPrefix(C.factory.sourceLocation(prefix, value), name, value));
+  },
+  gImpl: ({ SUBRULE, PRINT_WORDS }) => (ast, { factory: F2 }) => {
+    F2.printFilter(ast, () => {
+      PRINT_WORDS("PREFIX", `${ast.key}:`);
+    });
+    SUBRULE(iri2, ast.value);
+  }
+};
+var verb = {
+  name: "verb",
+  impl: ({ SUBRULE, OR }) => () => OR([
+    { ALT: () => SUBRULE(varOrIri) },
+    { ALT: () => SUBRULE(verbA) }
+  ])
+};
+var varOrTerm = {
+  name: "varOrTerm",
+  impl: ({ SUBRULE, OR }) => (C) => OR([
+    { GATE: () => C.parseMode.has("canParseVars"), ALT: () => SUBRULE(var_) },
+    { ALT: () => SUBRULE(graphTerm) }
+  ]),
+  gImpl: ({ SUBRULE }) => (ast, { factory: F2 }) => {
+    if (F2.isTermVariable(ast)) {
+      return SUBRULE(var_, ast);
+    }
+    return SUBRULE(graphTerm, ast);
+  }
+};
+var varOrIri = {
+  name: "varOrIri",
+  impl: ({ SUBRULE, OR }) => (C) => OR([
+    { GATE: () => C.parseMode.has("canParseVars"), ALT: () => SUBRULE(var_) },
+    { ALT: () => SUBRULE(iri2) }
+  ])
+};
+var var_ = {
+  name: "var",
+  impl: ({ ACTION, CONSUME, OR }) => (C) => {
+    const varToken = OR([
+      { ALT: () => CONSUME(terminals_exports.var1) },
+      { ALT: () => CONSUME(terminals_exports.var2) }
+    ]);
+    return ACTION(() => C.factory.variable(varToken.image.slice(1), C.factory.sourceLocation(varToken)));
+  },
+  gImpl: ({ PRINT_WORD }) => (ast, { factory: F2 }) => {
+    F2.printFilter(ast, () => PRINT_WORD(`?${ast.value}`));
+  }
+};
+var graphTerm = {
+  name: "graphTerm",
+  impl: ({ ACTION, SUBRULE, CONSUME, OR }) => (C) => OR([
+    { ALT: () => SUBRULE(iri2) },
+    { ALT: () => SUBRULE(rdfLiteral) },
+    { ALT: () => SUBRULE(numericLiteral) },
+    { ALT: () => SUBRULE(booleanLiteral) },
+    { GATE: () => C.parseMode.has("canCreateBlankNodes"), ALT: () => SUBRULE(blankNode) },
+    { ALT: () => {
+      const tokenNil = CONSUME(terminals_exports.nil);
+      return ACTION(() => C.factory.namedNode(C.factory.sourceLocation(tokenNil), "http://www.w3.org/1999/02/22-rdf-syntax-ns#nil" /* NIL */));
+    } }
+  ]),
+  gImpl: ({ SUBRULE }) => (ast, { factory: F2 }) => {
+    if (F2.isTermNamed(ast)) {
+      SUBRULE(iri2, ast);
+    } else if (F2.isTermLiteral(ast)) {
+      SUBRULE(rdfLiteral, ast);
+    } else if (F2.isTermBlank(ast)) {
+      SUBRULE(blankNode, ast);
+    }
+  }
+};
+
 // lib/grammar/dataSetClause.ts
 function datasetClauseUsing(name, token) {
   return {
@@ -11912,55 +12025,55 @@ function baseAggregateFunc(func) {
 }
 
 // lib/grammar/builtIn.ts
-var builtInStr = funcExpr1(BuildinCalls_exports.str);
-var builtInLang = funcExpr1(BuildinCalls_exports.lang);
-var builtInLangmatches = funcExpr2(BuildinCalls_exports.langmatches);
-var builtInDatatype = funcExpr1(BuildinCalls_exports.datatype);
-var builtInBound = funcVar1(BuildinCalls_exports.bound);
-var builtInIri = funcExpr1(BuildinCalls_exports.iri);
-var builtInUri = funcExpr1(BuildinCalls_exports.uri);
-var builtInBnodeSparqlJs = funcExprOrNil1(BuildinCalls_exports.bnode);
-var builtInRand = funcNil1(BuildinCalls_exports.rand);
-var builtInAbs = funcExpr1(BuildinCalls_exports.abs);
-var builtInCeil = funcExpr1(BuildinCalls_exports.ceil);
-var builtInFloor = funcExpr1(BuildinCalls_exports.floor);
-var builtInRound = funcExpr1(BuildinCalls_exports.round);
-var builtInConcat = funcExprList1(BuildinCalls_exports.concat);
-var builtInStrlen = funcExpr1(BuildinCalls_exports.strlen);
-var builtInUcase = funcExpr1(BuildinCalls_exports.ucase);
-var builtInLcase = funcExpr1(BuildinCalls_exports.lcase);
-var builtInEncode_for_uri = funcExpr1(BuildinCalls_exports.encode_for_uri);
-var builtInContains = funcExpr2(BuildinCalls_exports.contains);
-var builtInStrstarts = funcExpr2(BuildinCalls_exports.strstarts);
-var builtInStrends = funcExpr2(BuildinCalls_exports.strends);
-var builtInStrbefore = funcExpr2(BuildinCalls_exports.strbefore);
-var builtInStrafter = funcExpr2(BuildinCalls_exports.strafter);
-var builtInYear = funcExpr1(BuildinCalls_exports.year);
-var builtInMonth = funcExpr1(BuildinCalls_exports.month);
-var builtInDay = funcExpr1(BuildinCalls_exports.day);
-var builtInHours = funcExpr1(BuildinCalls_exports.hours);
-var builtInMinutes = funcExpr1(BuildinCalls_exports.minutes);
-var builtInSeconds = funcExpr1(BuildinCalls_exports.seconds);
-var builtInTimezone = funcExpr1(BuildinCalls_exports.timezone);
-var builtInTz = funcExpr1(BuildinCalls_exports.tz);
-var builtInNow = funcNil1(BuildinCalls_exports.now);
-var builtInUuid = funcNil1(BuildinCalls_exports.uuid);
-var builtInStruuid = funcNil1(BuildinCalls_exports.struuid);
-var builtInMd5 = funcExpr1(BuildinCalls_exports.md5);
-var builtInSha1 = funcExpr1(BuildinCalls_exports.sha1);
-var builtInSha256 = funcExpr1(BuildinCalls_exports.sha256);
-var builtInSha384 = funcExpr1(BuildinCalls_exports.sha384);
-var builtInSha512 = funcExpr1(BuildinCalls_exports.sha512);
-var builtInCoalesce = funcExprList1(BuildinCalls_exports.coalesce);
-var builtInIf = funcExpr3(BuildinCalls_exports.if_);
-var builtInStrlang = funcExpr2(BuildinCalls_exports.strlang);
-var builtInStrdt = funcExpr2(BuildinCalls_exports.strdt);
-var builtInSameterm = funcExpr2(BuildinCalls_exports.sameterm);
-var builtInIsiri = funcExpr1(BuildinCalls_exports.isiri);
-var builtInIsuri = funcExpr1(BuildinCalls_exports.isuri);
-var builtInIsblank = funcExpr1(BuildinCalls_exports.isblank);
-var builtInIsliteral = funcExpr1(BuildinCalls_exports.isliteral);
-var builtInIsnumeric = funcExpr1(BuildinCalls_exports.isnumeric);
+var builtInStr = funcExpr1(BuiltInCalls_exports.str);
+var builtInLang = funcExpr1(BuiltInCalls_exports.lang);
+var builtInLangmatches = funcExpr2(BuiltInCalls_exports.langmatches);
+var builtInDatatype = funcExpr1(BuiltInCalls_exports.datatype);
+var builtInBound = funcVar1(BuiltInCalls_exports.bound);
+var builtInIri = funcExpr1(BuiltInCalls_exports.iri);
+var builtInUri = funcExpr1(BuiltInCalls_exports.uri);
+var builtInBnodeSparqlJs = funcExprOrNil1(BuiltInCalls_exports.bnode);
+var builtInRand = funcNil1(BuiltInCalls_exports.rand);
+var builtInAbs = funcExpr1(BuiltInCalls_exports.abs);
+var builtInCeil = funcExpr1(BuiltInCalls_exports.ceil);
+var builtInFloor = funcExpr1(BuiltInCalls_exports.floor);
+var builtInRound = funcExpr1(BuiltInCalls_exports.round);
+var builtInConcat = funcExprList1(BuiltInCalls_exports.concat);
+var builtInStrlen = funcExpr1(BuiltInCalls_exports.strlen);
+var builtInUcase = funcExpr1(BuiltInCalls_exports.ucase);
+var builtInLcase = funcExpr1(BuiltInCalls_exports.lcase);
+var builtInEncode_for_uri = funcExpr1(BuiltInCalls_exports.encode_for_uri);
+var builtInContains = funcExpr2(BuiltInCalls_exports.contains);
+var builtInStrstarts = funcExpr2(BuiltInCalls_exports.strstarts);
+var builtInStrends = funcExpr2(BuiltInCalls_exports.strends);
+var builtInStrbefore = funcExpr2(BuiltInCalls_exports.strbefore);
+var builtInStrafter = funcExpr2(BuiltInCalls_exports.strafter);
+var builtInYear = funcExpr1(BuiltInCalls_exports.year);
+var builtInMonth = funcExpr1(BuiltInCalls_exports.month);
+var builtInDay = funcExpr1(BuiltInCalls_exports.day);
+var builtInHours = funcExpr1(BuiltInCalls_exports.hours);
+var builtInMinutes = funcExpr1(BuiltInCalls_exports.minutes);
+var builtInSeconds = funcExpr1(BuiltInCalls_exports.seconds);
+var builtInTimezone = funcExpr1(BuiltInCalls_exports.timezone);
+var builtInTz = funcExpr1(BuiltInCalls_exports.tz);
+var builtInNow = funcNil1(BuiltInCalls_exports.now);
+var builtInUuid = funcNil1(BuiltInCalls_exports.uuid);
+var builtInStruuid = funcNil1(BuiltInCalls_exports.struuid);
+var builtInMd5 = funcExpr1(BuiltInCalls_exports.md5);
+var builtInSha1 = funcExpr1(BuiltInCalls_exports.sha1);
+var builtInSha256 = funcExpr1(BuiltInCalls_exports.sha256);
+var builtInSha384 = funcExpr1(BuiltInCalls_exports.sha384);
+var builtInSha512 = funcExpr1(BuiltInCalls_exports.sha512);
+var builtInCoalesce = funcExprList1(BuiltInCalls_exports.coalesce);
+var builtInIf = funcExpr3(BuiltInCalls_exports.if_);
+var builtInStrlang = funcExpr2(BuiltInCalls_exports.strlang);
+var builtInStrdt = funcExpr2(BuiltInCalls_exports.strdt);
+var builtInSameterm = funcExpr2(BuiltInCalls_exports.sameterm);
+var builtInIsiri = funcExpr1(BuiltInCalls_exports.isiri);
+var builtInIsuri = funcExpr1(BuiltInCalls_exports.isuri);
+var builtInIsblank = funcExpr1(BuiltInCalls_exports.isblank);
+var builtInIsliteral = funcExpr1(BuiltInCalls_exports.isliteral);
+var builtInIsnumeric = funcExpr1(BuiltInCalls_exports.isnumeric);
 function builtInCallList(SUBRULE) {
   return [
     { ALT: () => SUBRULE(aggregate) },
@@ -12032,15 +12145,15 @@ var builtInCall = {
     return OR(builtIns);
   }
 };
-var regexExpression = funcExpr2or3(BuildinCalls_exports.regex);
-var substringExpression = funcExpr2or3(BuildinCalls_exports.substr);
-var strReplaceExpression = funcExpr3or4(BuildinCalls_exports.replace);
-var existsFunc = funcGroupGraphPattern(BuildinCalls_exports.exists);
-var notExistsFunc = funcGroupGraphPattern(BuildinCalls_exports.notexists);
+var regexExpression = funcExpr2or3(BuiltInCalls_exports.regex);
+var substringExpression = funcExpr2or3(BuiltInCalls_exports.substr);
+var strReplaceExpression = funcExpr3or4(BuiltInCalls_exports.replace);
+var existsFunc = funcGroupGraphPattern(BuiltInCalls_exports.exists);
+var notExistsFunc = funcGroupGraphPattern(BuiltInCalls_exports.notexists);
 var aggregateCount = {
-  name: unCapitalize(BuildinCalls_exports.count.name),
+  name: unCapitalize(BuiltInCalls_exports.count.name),
   impl: ({ ACTION, CONSUME, SUBRULE, OR, OPTION }) => (C) => {
-    const operatorToken = CONSUME(BuildinCalls_exports.count);
+    const operatorToken = CONSUME(BuiltInCalls_exports.count);
     CONSUME(symbols_exports.LParen);
     const distinctToken = OPTION(() => CONSUME(distinct));
     const expressionVal = OR([
@@ -12072,15 +12185,15 @@ var aggregateCount = {
     });
   }
 };
-var aggregateSum = baseAggregateFunc(BuildinCalls_exports.sum);
-var aggregateMin = baseAggregateFunc(BuildinCalls_exports.min);
-var aggregateMax = baseAggregateFunc(BuildinCalls_exports.max);
-var aggregateAvg = baseAggregateFunc(BuildinCalls_exports.avg);
-var aggregateSample = baseAggregateFunc(BuildinCalls_exports.sample);
+var aggregateSum = baseAggregateFunc(BuiltInCalls_exports.sum);
+var aggregateMin = baseAggregateFunc(BuiltInCalls_exports.min);
+var aggregateMax = baseAggregateFunc(BuiltInCalls_exports.max);
+var aggregateAvg = baseAggregateFunc(BuiltInCalls_exports.avg);
+var aggregateSample = baseAggregateFunc(BuiltInCalls_exports.sample);
 var aggregateGroup_concat = {
-  name: unCapitalize(BuildinCalls_exports.groupConcat.name),
+  name: unCapitalize(BuiltInCalls_exports.groupConcat.name),
   impl: ({ ACTION, CONSUME, OPTION1, SUBRULE, OPTION2 }) => (C) => {
-    const operatorToken = CONSUME(BuildinCalls_exports.groupConcat);
+    const operatorToken = CONSUME(BuiltInCalls_exports.groupConcat);
     CONSUME(symbols_exports.LParen);
     const distinctToken = OPTION1(() => CONSUME(distinct));
     const expr = SUBRULE(expression);
@@ -12148,120 +12261,6 @@ var aggregate = {
   }
 };
 
-// lib/grammar/general.ts
-var prologue = {
-  name: "prologue",
-  impl: ({ SUBRULE, MANY, OR }) => () => {
-    const result = [];
-    MANY(() => OR([
-      { ALT: () => result.push(SUBRULE(baseDecl2)) },
-      // TODO: the [spec](https://www.w3.org/TR/sparql11-query/#iriRefs) says you cannot redefine prefixes.
-      //  We might need to check this.
-      { ALT: () => result.push(SUBRULE(prefixDecl2)) }
-    ]));
-    return result;
-  },
-  gImpl: ({ SUBRULE }) => (ast, { factory: F2 }) => {
-    for (const context of ast) {
-      if (F2.isContextDefinitionBase(context)) {
-        SUBRULE(baseDecl2, context);
-      } else if (F2.isContextDefinitionPrefix(context)) {
-        SUBRULE(prefixDecl2, context);
-      }
-    }
-  }
-};
-var baseDecl2 = {
-  name: "baseDecl",
-  impl: ({ ACTION, CONSUME, SUBRULE }) => (C) => {
-    const base = CONSUME(baseDecl);
-    const val = SUBRULE(iriFull);
-    return ACTION(() => C.factory.contextDefinitionBase(C.factory.sourceLocation(base, val), val));
-  },
-  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
-    F2.printFilter(ast, () => PRINT_WORD("BASE"));
-    SUBRULE(iri2, ast.value);
-  }
-};
-var prefixDecl2 = {
-  name: "prefixDecl",
-  impl: ({ ACTION, CONSUME, SUBRULE }) => (C) => {
-    const prefix = CONSUME(prefixDecl);
-    const name = CONSUME(terminals_exports.pNameNs).image.slice(0, -1);
-    const value = SUBRULE(iriFull);
-    return ACTION(() => C.factory.contextDefinitionPrefix(C.factory.sourceLocation(prefix, value), name, value));
-  },
-  gImpl: ({ SUBRULE, PRINT_WORDS }) => (ast, { factory: F2 }) => {
-    F2.printFilter(ast, () => {
-      PRINT_WORDS("PREFIX", `${ast.key}:`);
-    });
-    SUBRULE(iri2, ast.value);
-  }
-};
-var verb = {
-  name: "verb",
-  impl: ({ SUBRULE, OR }) => () => OR([
-    { ALT: () => SUBRULE(varOrIri) },
-    { ALT: () => SUBRULE(verbA) }
-  ])
-};
-var varOrTerm = {
-  name: "varOrTerm",
-  impl: ({ SUBRULE, OR }) => (C) => OR([
-    { GATE: () => C.parseMode.has("canParseVars"), ALT: () => SUBRULE(var_) },
-    { ALT: () => SUBRULE(graphTerm) }
-  ]),
-  gImpl: ({ SUBRULE }) => (ast, { factory: F2 }) => {
-    if (F2.isTermVariable(ast)) {
-      return SUBRULE(var_, ast);
-    }
-    return SUBRULE(graphTerm, ast);
-  }
-};
-var varOrIri = {
-  name: "varOrIri",
-  impl: ({ SUBRULE, OR }) => (C) => OR([
-    { GATE: () => C.parseMode.has("canParseVars"), ALT: () => SUBRULE(var_) },
-    { ALT: () => SUBRULE(iri2) }
-  ])
-};
-var var_ = {
-  name: "var",
-  impl: ({ ACTION, CONSUME, OR }) => (C) => {
-    const varToken = OR([
-      { ALT: () => CONSUME(terminals_exports.var1) },
-      { ALT: () => CONSUME(terminals_exports.var2) }
-    ]);
-    return ACTION(() => C.factory.variable(varToken.image.slice(1), C.factory.sourceLocation(varToken)));
-  },
-  gImpl: ({ PRINT_WORD }) => (ast, { factory: F2 }) => {
-    F2.printFilter(ast, () => PRINT_WORD(`?${ast.value}`));
-  }
-};
-var graphTerm = {
-  name: "graphTerm",
-  impl: ({ ACTION, SUBRULE, CONSUME, OR }) => (C) => OR([
-    { ALT: () => SUBRULE(iri2) },
-    { ALT: () => SUBRULE(rdfLiteral) },
-    { ALT: () => SUBRULE(numericLiteral) },
-    { ALT: () => SUBRULE(booleanLiteral) },
-    { GATE: () => C.parseMode.has("canCreateBlankNodes"), ALT: () => SUBRULE(blankNode) },
-    { ALT: () => {
-      const tokenNil = CONSUME(terminals_exports.nil);
-      return ACTION(() => C.factory.namedNode(C.factory.sourceLocation(tokenNil), "http://www.w3.org/1999/02/22-rdf-syntax-ns#nil" /* NIL */));
-    } }
-  ]),
-  gImpl: ({ SUBRULE }) => (ast, { factory: F2 }) => {
-    if (F2.isTermNamed(ast)) {
-      SUBRULE(iri2, ast);
-    } else if (F2.isTermLiteral(ast)) {
-      SUBRULE(rdfLiteral, ast);
-    } else if (F2.isTermBlank(ast)) {
-      SUBRULE(blankNode, ast);
-    }
-  }
-};
-
 // lib/grammar/propertyPaths.ts
 var path = {
   name: "path",
@@ -14517,7 +14516,69 @@ var quadsNotTriples = {
   }
 };
 
-// lib/SparqlParser.ts
+// lib/grammar/index.ts
+var queryOrUpdate = {
+  name: "queryOrUpdate",
+  impl: ({ ACTION, SUBRULE, OR1, OR2, MANY, OPTION1, CONSUME, SUBRULE2 }) => (C) => {
+    const prologueValues = SUBRULE(prologue);
+    return OR1([
+      { ALT: () => {
+        const subType = OR2([
+          { ALT: () => SUBRULE(selectQuery) },
+          { ALT: () => SUBRULE(constructQuery) },
+          { ALT: () => SUBRULE(describeQuery) },
+          { ALT: () => SUBRULE(askQuery) }
+        ]);
+        const values3 = SUBRULE(valuesClause);
+        return ACTION(() => ({
+          context: prologueValues,
+          ...subType,
+          type: "query",
+          ...values3 && { values: values3 },
+          loc: C.factory.sourceLocation(
+            prologueValues.at(0),
+            subType,
+            values3
+          )
+        }));
+      } },
+      { ALT: () => {
+        const updates = [];
+        updates.push({ context: prologueValues });
+        let parsedSemi = true;
+        MANY({
+          GATE: () => parsedSemi,
+          DEF: () => {
+            parsedSemi = false;
+            updates.at(-1).operation = SUBRULE(update1);
+            OPTION1(() => {
+              CONSUME(symbols_exports.semi);
+              parsedSemi = true;
+              const innerPrologue = SUBRULE2(prologue);
+              updates.push({ context: innerPrologue });
+            });
+          }
+        });
+        return ACTION(() => {
+          const update2 = {
+            type: "update",
+            updates,
+            loc: C.factory.sourceLocation(
+              ...updates[0].context,
+              updates[0].operation,
+              ...updates.at(-1).context,
+              updates.at(-1)?.operation
+            )
+          };
+          updateNoReuseBlankNodeLabels(update2);
+          return update2;
+        });
+      } }
+    ]);
+  }
+};
+
+// lib/MinimalSparqlParser.ts
 function completeParseContext(context) {
   return {
     factory: context.factory ?? new Factory(),
@@ -14529,11 +14590,11 @@ function completeParseContext(context) {
     skipValidation: context.skipValidation ?? false
   };
 }
-var SparqlParser = class {
+var MinimalSparqlParser = class {
   constructor(parser) {
     this.parser = parser;
-    this.F = new Factory();
   }
+  F = new Factory();
   parse(query2, context = {}) {
     return this.parser.queryOrUpdate(query2, completeParseContext(context));
   }