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

package/lib/index.cjs

@@ -34,16 +34,16 @@ __export(grammar_exports2, {
   annotationBlock: () => annotationBlock,
   annotationBlockPath: () => annotationBlockPath,
   annotationPath: () => annotationPath,
+  buildInHasLang: () => buildInHasLang2,
+  buildInHasLangDir: () => buildInHasLangDir2,
+  buildInIsTriple: () => buildInIsTriple,
+  buildInLangDir: () => buildInLangDir2,
+  buildInLangStrDir: () => buildInLangStrDir,
+  buildInObject: () => buildInObject,
+  buildInPredicate: () => buildInPredicate,
+  buildInSubject: () => buildInSubject,
+  buildInTriple: () => buildInTriple,
   builtInCall: () => builtInCall2,
-  builtinHasLang: () => builtinHasLang2,
-  builtinHasLangDir: () => builtinHasLangDir2,
-  builtinIsTriple: () => builtinIsTriple,
-  builtinLangDir: () => builtinLangDir2,
-  builtinLangStrDir: () => builtinLangStrDir,
-  builtinObject: () => builtinObject,
-  builtinPredicate: () => builtinPredicate,
-  builtinSubject: () => builtinSubject,
-  builtinTriple: () => builtinTriple,
   dataBlockValue: () => dataBlockValue2,
   exprTripleTerm: () => exprTripleTerm,
   exprTripleTermObject: () => exprTripleTermObject,
@@ -260,6 +260,7 @@ __export(grammar_exports, {
   quads: () => quads,
   quadsNotTriples: () => quadsNotTriples,
   query: () => query,
+  queryOrUpdate: () => queryOrUpdate,
   queryUnit: () => queryUnit,
   rdfLiteral: () => rdfLiteral,
   regexExpression: () => regexExpression,
@@ -308,7 +309,7 @@ __export(lexer_exports, {
   ask: () => ask,
   baseDecl: () => baseDecl,
   bind: () => bind,
-  builtIn: () => BuildinCalls_exports,
+  builtIn: () => BuiltInCalls_exports,
   by: () => by,
   clear: () => clear,
   construct: () => construct,
@@ -345,7 +346,7 @@ __export(lexer_exports, {
   separator: () => separator,
   service: () => service,
   silent: () => silent,
-  sparql11Tokens: () => sparql11Tokens,
+  sparql11LexerBuilder: () => sparql11LexerBuilder,
   symbols: () => symbols_exports,
   terminals: () => terminals_exports,
   to: () => to,
@@ -357,10 +358,10 @@ __export(lexer_exports, {
   where: () => where
 });
 
-// ../rules-sparql-1-1/lib/lexer/BuildinCalls.ts
-var BuildinCalls_exports = {};
-__export(BuildinCalls_exports, {
-  BuildInCalls: () => BuildInCalls,
+// ../rules-sparql-1-1/lib/lexer/BuiltInCalls.ts
+var BuiltInCalls_exports = {};
+__export(BuiltInCalls_exports, {
+  BuiltInCalls: () => BuiltInCalls,
   abs: () => abs,
   allBuiltInCalls: () => allBuiltInCalls,
   avg: () => avg,
@@ -753,10 +754,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;
 }
@@ -818,7 +819,7 @@ var WeakMap_default = WeakMap;
 
 // ../../node_modules/lodash-es/_baseCreate.js
 var objectCreate = Object.create;
-var baseCreate = /* @__PURE__ */ function() {
+var baseCreate = /* @__PURE__ */ (function() {
   function object3() {
   }
   return function(proto) {
@@ -833,7 +834,7 @@ var baseCreate = /* @__PURE__ */ function() {
     object3.prototype = void 0;
     return result;
   };
-}();
+})();
 var baseCreate_default = baseCreate;
 
 // ../../node_modules/lodash-es/_apply.js
@@ -898,14 +899,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
@@ -1143,9 +1144,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;
@@ -1211,7 +1212,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) {
@@ -1220,7 +1221,7 @@ var nodeUtil = function() {
     return freeProcess && freeProcess.binding && freeProcess.binding("util");
   } catch (e) {
   }
-}();
+})();
 var nodeUtil_default = nodeUtil;
 
 // ../../node_modules/lodash-es/isTypedArray.js
@@ -9765,6 +9766,7 @@ applyMixins(Parser, [
 
 // ../core/lib/lexer-builder/LexerBuilder.ts
 var LexerBuilder = class _LexerBuilder {
+  tokens;
   static create(starter) {
     return new _LexerBuilder(starter);
   }
@@ -9922,71 +9924,71 @@ var Transformer = class {
   }
 };
 
-// ../rules-sparql-1-1/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 || {});
+// ../rules-sparql-1-1/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);
 }
@@ -10490,7 +10492,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);
 
 // ../rules-sparql-1-1/lib/factoryMixins/ContextFactory.ts
 var nodeType = "contextDef";
@@ -10935,10 +10937,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;
     }
@@ -11654,6 +11653,120 @@ var verbA = {
   }
 };
 
+// ../rules-sparql-1-1/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: F3 }) => {
+    for (const context of ast) {
+      if (F3.isContextDefinitionBase(context)) {
+        SUBRULE(baseDecl2, context);
+      } else if (F3.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: F3 }) => {
+    F3.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: F3 }) => {
+    F3.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: F3 }) => {
+    if (F3.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: F3 }) => {
+    F3.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: F3 }) => {
+    if (F3.isTermNamed(ast)) {
+      SUBRULE(iri2, ast);
+    } else if (F3.isTermLiteral(ast)) {
+      SUBRULE(rdfLiteral, ast);
+    } else if (F3.isTermBlank(ast)) {
+      SUBRULE(blankNode, ast);
+    }
+  }
+};
+
 // ../rules-sparql-1-1/lib/grammar/dataSetClause.ts
 function datasetClauseUsing(name, token) {
   return {
@@ -11909,55 +12022,55 @@ function baseAggregateFunc(func) {
 }
 
 // ../rules-sparql-1-1/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) },
@@ -12029,15 +12142,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([
@@ -12069,15 +12182,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);
@@ -12145,120 +12258,6 @@ var aggregate = {
   }
 };
 
-// ../rules-sparql-1-1/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: F3 }) => {
-    for (const context of ast) {
-      if (F3.isContextDefinitionBase(context)) {
-        SUBRULE(baseDecl2, context);
-      } else if (F3.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: F3 }) => {
-    F3.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: F3 }) => {
-    F3.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: F3 }) => {
-    if (F3.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: F3 }) => {
-    F3.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: F3 }) => {
-    if (F3.isTermNamed(ast)) {
-      SUBRULE(iri2, ast);
-    } else if (F3.isTermLiteral(ast)) {
-      SUBRULE(rdfLiteral, ast);
-    } else if (F3.isTermBlank(ast)) {
-      SUBRULE(blankNode, ast);
-    }
-  }
-};
-
 // ../rules-sparql-1-1/lib/grammar/propertyPaths.ts
 var path = {
   name: "path",
@@ -14514,24 +14513,86 @@ var quadsNotTriples = {
   }
 };
 
+// ../rules-sparql-1-1/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/lexer.ts
 var lexer_exports2 = {};
 __export(lexer_exports2, {
   LANG_DIR: () => LANG_DIR,
   annotationClose: () => annotationClose,
   annotationOpen: () => annotationOpen,
-  builtinHasLang: () => builtinHasLang,
-  builtinHasLangDir: () => builtinHasLangDir,
-  builtinIsTRIPLE: () => builtinIsTRIPLE,
-  builtinLangDir: () => builtinLangDir,
-  builtinOBJECT: () => builtinOBJECT,
-  builtinPREDICATE: () => builtinPREDICATE,
-  builtinSUBJECT: () => builtinSUBJECT,
-  builtinStrLangDir: () => builtinStrLangDir,
-  builtinTRIPLE: () => builtinTRIPLE,
+  buildInHasLang: () => buildInHasLang,
+  buildInHasLangDir: () => buildInHasLangDir,
+  buildInIsTRIPLE: () => buildInIsTRIPLE,
+  buildInLangDir: () => buildInLangDir,
+  buildInOBJECT: () => buildInOBJECT,
+  buildInPREDICATE: () => buildInPREDICATE,
+  buildInSUBJECT: () => buildInSUBJECT,
+  buildInStrLangDir: () => buildInStrLangDir,
+  buildInTRIPLE: () => buildInTRIPLE,
   reificationClose: () => reificationClose,
   reificationOpen: () => reificationOpen,
-  sparql12Tokens: () => sparql12Tokens,
+  sparql12LexerBuilder: () => sparql12LexerBuilder,
   tilde: () => tilde,
   tripleTermClose: () => tripleTermClose,
   tripleTermOpen: () => tripleTermOpen,
@@ -14545,29 +14606,29 @@ var reificationOpen = createToken2({ name: "ReificationOpen", pattern: "<<", lab
 var reificationClose = createToken2({ name: "ReificationClose", pattern: ">>", label: "Reification close >>" });
 var tripleTermOpen = createToken2({ name: "TripleTermOpen", pattern: "<<(", label: "Triple Term Open <<(" });
 var tripleTermClose = createToken2({ name: "TripleTermClose", pattern: ")>>", label: "Triple Term Close )>>" });
-var builtinLangDir = createToken2({ name: "BuiltInLangdir", pattern: /langdir/i, label: "LANGDIR" });
-var builtinStrLangDir = createToken2({
+var buildInLangDir = createToken2({ name: "BuiltInLangdir", pattern: /langdir/i, label: "LANGDIR" });
+var buildInStrLangDir = createToken2({
   name: "BuiltInStrLangdir",
   pattern: /strlangdir/i,
   label: "STRLANGDIR"
 });
-var builtinHasLang = createToken2({ name: "BuiltInHasLang", pattern: /haslang/i, label: "hasLANG" });
-var builtinHasLangDir = createToken2({
+var buildInHasLang = createToken2({ name: "BuiltInHasLang", pattern: /haslang/i, label: "hasLANG" });
+var buildInHasLangDir = createToken2({
   name: "BuiltInHasLangdir",
   pattern: /haslangdir/i,
   label: "hasLANGDIR"
 });
-var builtinIsTRIPLE = createToken2({ name: "BuiltInIsTriple", pattern: /istriple/i, label: "isTRIPLE" });
-var builtinTRIPLE = createToken2({ name: "BuiltInTriple", pattern: /triple/i, label: "TRIPLE" });
-var builtinSUBJECT = createToken2({ name: "BuiltInSubject", pattern: /subject/i, label: "SUBJECT" });
-var builtinPREDICATE = createToken2({ name: "BuiltInPredicate", pattern: /predicate/i, label: "PREDICATE" });
-var builtinOBJECT = createToken2({ name: "BuiltInObject", pattern: /object/i, label: "OBJECT" });
+var buildInIsTRIPLE = createToken2({ name: "BuiltInIsTriple", pattern: /istriple/i, label: "isTRIPLE" });
+var buildInTRIPLE = createToken2({ name: "BuiltInTriple", pattern: /triple/i, label: "TRIPLE" });
+var buildInSUBJECT = createToken2({ name: "BuiltInSubject", pattern: /subject/i, label: "SUBJECT" });
+var buildInPREDICATE = createToken2({ name: "BuiltInPredicate", pattern: /predicate/i, label: "PREDICATE" });
+var buildInOBJECT = createToken2({ name: "BuiltInObject", pattern: /object/i, label: "OBJECT" });
 var LANG_DIR = createToken2({
   name: "LANG_DIR",
   pattern: /@[a-z]+(?:-[\da-z]+)*(?:--[a-z]+)?/i,
   label: "LANG_DIR"
 });
-var sparql12Tokens = LexerBuilder.create(lexer_exports.sparql11Tokens).addBefore(
+var sparql12LexerBuilder = LexerBuilder.create(lexer_exports.sparql11LexerBuilder).addBefore(
   lexer_exports.symbols.logicAnd,
   tilde,
   annotationOpen,
@@ -14579,15 +14640,15 @@ var sparql12Tokens = LexerBuilder.create(lexer_exports.sparql11Tokens).addBefore
   version
 ).addBefore(
   lexer_exports.builtIn.langmatches,
-  builtinLangDir,
-  builtinStrLangDir,
-  builtinHasLangDir,
-  builtinHasLang,
-  builtinIsTRIPLE,
-  builtinTRIPLE,
-  builtinSUBJECT,
-  builtinPREDICATE,
-  builtinOBJECT
+  buildInLangDir,
+  buildInStrLangDir,
+  buildInHasLangDir,
+  buildInHasLang,
+  buildInIsTRIPLE,
+  buildInTRIPLE,
+  buildInSUBJECT,
+  buildInPREDICATE,
+  buildInOBJECT
 ).addBefore(lexer_exports.terminals.langTag, LANG_DIR).delete(lexer_exports.terminals.langTag);
 
 // lib/validator.ts
@@ -15012,28 +15073,28 @@ var exprTripleTermObject = {
   name: "exprTripleTermObject",
   impl: exprTripleTermSubject.impl
 };
-var builtinLangDir2 = funcExpr1(builtinLangDir);
-var builtinLangStrDir = funcExpr3(builtinStrLangDir);
-var builtinHasLang2 = funcExpr1(builtinHasLang);
-var builtinHasLangDir2 = funcExpr1(builtinHasLangDir);
-var builtinIsTriple = funcExpr1(builtinIsTRIPLE);
-var builtinTriple = funcExpr3(builtinTRIPLE);
-var builtinSubject = funcExpr1(builtinSUBJECT);
-var builtinPredicate = funcExpr1(builtinPREDICATE);
-var builtinObject = funcExpr1(builtinOBJECT);
+var buildInLangDir2 = funcExpr1(buildInLangDir);
+var buildInLangStrDir = funcExpr3(buildInStrLangDir);
+var buildInHasLang2 = funcExpr1(buildInHasLang);
+var buildInHasLangDir2 = funcExpr1(buildInHasLangDir);
+var buildInIsTriple = funcExpr1(buildInIsTRIPLE);
+var buildInTriple = funcExpr3(buildInTRIPLE);
+var buildInSubject = funcExpr1(buildInSUBJECT);
+var buildInPredicate = funcExpr1(buildInPREDICATE);
+var buildInObject = funcExpr1(buildInOBJECT);
 var builtInCall2 = {
   name: "builtInCall",
   impl: ($) => (C) => $.OR2([
     { ALT: () => grammar_exports.builtInCall.impl($)(C) },
-    { ALT: () => $.SUBRULE(builtinLangDir2) },
-    { ALT: () => $.SUBRULE(builtinLangStrDir) },
-    { ALT: () => $.SUBRULE(builtinHasLang2) },
-    { ALT: () => $.SUBRULE(builtinHasLangDir2) },
-    { ALT: () => $.SUBRULE(builtinIsTriple) },
-    { ALT: () => $.SUBRULE(builtinTriple) },
-    { ALT: () => $.SUBRULE(builtinSubject) },
-    { ALT: () => $.SUBRULE(builtinPredicate) },
-    { ALT: () => $.SUBRULE(builtinObject) }
+    { ALT: () => $.SUBRULE(buildInLangDir2) },
+    { ALT: () => $.SUBRULE(buildInLangStrDir) },
+    { ALT: () => $.SUBRULE(buildInHasLang2) },
+    { ALT: () => $.SUBRULE(buildInHasLangDir2) },
+    { ALT: () => $.SUBRULE(buildInIsTriple) },
+    { ALT: () => $.SUBRULE(buildInTriple) },
+    { ALT: () => $.SUBRULE(buildInSubject) },
+    { ALT: () => $.SUBRULE(buildInPredicate) },
+    { ALT: () => $.SUBRULE(buildInObject) }
   ])
 };
 var rdfLiteral2 = {
@@ -15108,20 +15169,6 @@ var generateGraphTerm = {
 
 // lib/Factory.ts
 var Factory2 = class extends Factory {
-  constructor() {
-    super(...arguments);
-    /**
-     * Overwritten triple constructor to always contain an empty annotations list
-     */
-    this.triple = (subject, predicate, object3, loc) => ({
-      type: "triple",
-      subject,
-      predicate,
-      object: object3,
-      annotations: [],
-      loc: loc ?? this.sourceLocation(subject, predicate, object3)
-    });
-  }
   termTriple(subject, predicate, object3, loc) {
     return {
       type: "term",
@@ -15156,6 +15203,17 @@ var Factory2 = class extends Factory {
       loc
     };
   }
+  /**
+   * Overwritten triple constructor to always contain an empty annotations list
+   */
+  triple = (subject, predicate, object3, loc) => ({
+    type: "triple",
+    subject,
+    predicate,
+    object: object3,
+    annotations: [],
+    loc: loc ?? this.sourceLocation(subject, predicate, object3)
+  });
   annotatedTriple(subject, predicate, object3, annotations, loc) {
     return {
       type: "triple",