@traqula/generator-sparql-1-1 0.0.13 → 0.0.15

package/lib/index.cjs

@@ -25,7 +25,7 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// ../../packages/core/lib/CoreFactory.ts
+// ../../packages/core/lib/CoreFactory.js
 var CoreFactory = class {
   wrap(val, loc) {
     return { val, loc };
@@ -152,8 +152,15 @@ var CoreFactory = class {
   }
 };
 
-// ../../packages/core/lib/generator-builder/dynamicGenerator.ts
+// ../../packages/core/lib/generator-builder/dynamicGenerator.js
 var DynamicGenerator = class {
+  rules;
+  factory = new CoreFactory();
+  __context = void 0;
+  origSource = "";
+  generatedUntil = 0;
+  expectsSpace;
+  stringBuilder = [];
   constructor(rules) {
     this.rules = rules;
     for (const rule of Object.values(rules)) {
@@ -169,12 +176,6 @@ var DynamicGenerator = class {
       });
     }
   }
-  factory = new CoreFactory();
-  __context = void 0;
-  origSource = "";
-  generatedUntil = 0;
-  expectsSpace;
-  stringBuilder = [];
   setContext(context) {
     this.__context = context;
   }
@@ -262,7 +263,7 @@ var DynamicGenerator = class {
   };
 };
 
-// ../../packages/core/lib/generator-builder/generatorBuilder.ts
+// ../../packages/core/lib/generator-builder/generatorBuilder.js
 function listToRuleDefMap(rules) {
   const newRules = {};
   for (const rule of rules) {
@@ -9570,7 +9571,7 @@ applyMixins(Parser, [
   PerformanceTracer
 ]);
 
-// ../../packages/core/lib/lexer-builder/LexerBuilder.ts
+// ../../packages/core/lib/lexer-builder/LexerBuilder.js
 var LexerBuilder = class _LexerBuilder {
   tokens;
   static create(starter) {
@@ -9667,7 +9668,7 @@ var LexerBuilder = class _LexerBuilder {
   }
 };
 
-// ../../packages/core/lib/utils.ts
+// ../../packages/core/lib/utils.js
 function unCapitalize(str2) {
   return str2.charAt(0).toLowerCase() + str2.slice(1);
 }
@@ -9675,7 +9676,7 @@ function createToken2(config) {
   return createToken(config);
 }
 
-// ../../packages/core/lib/Transformers.ts
+// ../../packages/core/lib/Transformers.js
 var TransformerType = class {
   safeObjectVisit(value, mapper) {
     if (value && typeof value === "object") {
@@ -9787,7 +9788,7 @@ var TransformerSubType = class extends TransformerType {
   }
 };
 
-// ../../packages/rules-sparql-1-1/lib/grammar/index.ts
+// ../../packages/rules-sparql-1-1/lib/grammar/index.js
 var grammar_exports = {};
 __export(grammar_exports, {
   add: () => add2,
@@ -10009,7 +10010,7 @@ __export(grammar_exports, {
   whereClause: () => whereClause
 });
 
-// ../../packages/rules-sparql-1-1/lib/lexer/BuiltInCalls.ts
+// ../../packages/rules-sparql-1-1/lib/lexer/BuiltInCalls.js
 var BuiltInCalls_exports = {};
 __export(BuiltInCalls_exports, {
   BuiltInCalls: () => BuiltInCalls,
@@ -10076,7 +10077,8 @@ __export(BuiltInCalls_exports, {
   uuid: () => uuid,
   year: () => year
 });
-var BuiltInCalls = /* @__PURE__ */ ((BuiltInCalls2) => {
+var BuiltInCalls;
+(function(BuiltInCalls2) {
   BuiltInCalls2["Str"] = "builtInStr";
   BuiltInCalls2["Lang"] = "builtInLang";
   BuiltInCalls2["Langmatches"] = "builtInLangmatches";
@@ -10138,193 +10140,130 @@ var BuiltInCalls = /* @__PURE__ */ ((BuiltInCalls2) => {
   BuiltInCalls2["Avg"] = "builtInAvg";
   BuiltInCalls2["Sample"] = "builtInSample";
   BuiltInCalls2["Group_concat"] = "builtInGroup_concat";
-  return BuiltInCalls2;
-})(BuiltInCalls || {});
+})(BuiltInCalls || (BuiltInCalls = {}));
 function capitalize(string2) {
   return string2.charAt(0).toUpperCase() + string2.slice(1);
 }
-var str = createToken2({ name: capitalize("builtInStr" /* Str */), pattern: /str/i, label: "STR" });
-var lang = createToken2({ name: capitalize("builtInLang" /* Lang */), pattern: /lang/i, label: "LANG" });
+var str = createToken2({ name: capitalize(BuiltInCalls.Str), pattern: /str/i, label: "STR" });
+var lang = createToken2({ name: capitalize(BuiltInCalls.Lang), pattern: /lang/i, label: "LANG" });
 var langmatches = createToken2({
-  name: capitalize("builtInLangmatches" /* Langmatches */),
+  name: capitalize(BuiltInCalls.Langmatches),
   pattern: /langmatches/i,
   label: "LANGMATCHES"
 });
 var datatype = createToken2({
-  name: capitalize("builtInDatatype" /* Datatype */),
+  name: capitalize(BuiltInCalls.Datatype),
   pattern: /datatype/i,
   label: "DATATYPE"
 });
-var bound = createToken2({ name: capitalize("builtInBound" /* Bound */), pattern: /bound/i, label: "BOUND" });
-var iri = createToken2({ name: capitalize("builtInIri" /* Iri */), pattern: /iri/i, label: "IRI" });
-var uri = createToken2({ name: capitalize("builtInUri" /* Uri */), pattern: /uri/i, label: "URI" });
-var bnode = createToken2({ name: capitalize("builtInBnode" /* Bnode */), pattern: /bnode/i, label: "BNODE" });
-var rand = createToken2({ name: capitalize("builtInRand" /* Rand */), pattern: /rand/i, label: "RAND" });
-var abs = createToken2({ name: capitalize("builtInAbs" /* Abs */), pattern: /abs/i, label: "ABS" });
-var ceil = createToken2({ name: capitalize("builtInCeil" /* Ceil */), pattern: /ceil/i, label: "CEIL" });
-var floor = createToken2({ name: capitalize("builtInFloor" /* Floor */), pattern: /floor/i, label: "FLOOR" });
-var round = createToken2({ name: capitalize("builtInRound" /* Round */), pattern: /round/i, label: "ROUND" });
-var concat = createToken2({ name: capitalize("builtInConcat" /* Concat */), pattern: /concat/i, label: "CONCAT" });
-var strlen = createToken2({ name: capitalize("builtInStrlen" /* Strlen */), pattern: /strlen/i, label: "STRLEN" });
-var ucase = createToken2({ name: capitalize("builtInUcase" /* Ucase */), pattern: /ucase/i, label: "UCASE" });
-var lcase = createToken2({ name: capitalize("builtInLcase" /* Lcase */), pattern: /lcase/i, label: "LCASE" });
+var bound = createToken2({ name: capitalize(BuiltInCalls.Bound), pattern: /bound/i, label: "BOUND" });
+var iri = createToken2({ name: capitalize(BuiltInCalls.Iri), pattern: /iri/i, label: "IRI" });
+var uri = createToken2({ name: capitalize(BuiltInCalls.Uri), pattern: /uri/i, label: "URI" });
+var bnode = createToken2({ name: capitalize(BuiltInCalls.Bnode), pattern: /bnode/i, label: "BNODE" });
+var rand = createToken2({ name: capitalize(BuiltInCalls.Rand), pattern: /rand/i, label: "RAND" });
+var abs = createToken2({ name: capitalize(BuiltInCalls.Abs), pattern: /abs/i, label: "ABS" });
+var ceil = createToken2({ name: capitalize(BuiltInCalls.Ceil), pattern: /ceil/i, label: "CEIL" });
+var floor = createToken2({ name: capitalize(BuiltInCalls.Floor), pattern: /floor/i, label: "FLOOR" });
+var round = createToken2({ name: capitalize(BuiltInCalls.Round), pattern: /round/i, label: "ROUND" });
+var concat = createToken2({ name: capitalize(BuiltInCalls.Concat), pattern: /concat/i, label: "CONCAT" });
+var strlen = createToken2({ name: capitalize(BuiltInCalls.Strlen), pattern: /strlen/i, label: "STRLEN" });
+var ucase = createToken2({ name: capitalize(BuiltInCalls.Ucase), pattern: /ucase/i, label: "UCASE" });
+var lcase = createToken2({ name: capitalize(BuiltInCalls.Lcase), pattern: /lcase/i, label: "LCASE" });
 var encode_for_uri = createToken2({
-  name: capitalize("builtInEncode_for_uri" /* Encode_for_uri */),
+  name: capitalize(BuiltInCalls.Encode_for_uri),
   pattern: /encode_for_uri/i,
   label: "ENCODE_FOR_URI"
 });
 var contains = createToken2({
-  name: capitalize("builtInContains" /* Contains */),
+  name: capitalize(BuiltInCalls.Contains),
   pattern: /contains/i,
   label: "CONTAINS"
 });
 var strstarts = createToken2({
-  name: capitalize("builtInStrstarts" /* Strstarts */),
+  name: capitalize(BuiltInCalls.Strstarts),
   pattern: /strstarts/i,
   label: "STRSTARTS"
 });
-var strends = createToken2({ name: capitalize("builtInStrends" /* Strends */), pattern: /strends/i, label: "STRENDS" });
+var strends = createToken2({ name: capitalize(BuiltInCalls.Strends), pattern: /strends/i, label: "STRENDS" });
 var strbefore = createToken2({
-  name: capitalize("builtInStrbefore" /* Strbefore */),
+  name: capitalize(BuiltInCalls.Strbefore),
   pattern: /strbefore/i,
   label: "STRBEFORE"
 });
 var strafter = createToken2({
-  name: capitalize("builtInStrafter" /* Strafter */),
+  name: capitalize(BuiltInCalls.Strafter),
   pattern: /strafter/i,
   label: "STRAFTER"
 });
-var year = createToken2({ name: capitalize("builtInYear" /* Year */), pattern: /year/i, label: "YEAR" });
-var month = createToken2({ name: capitalize("builtInMonth" /* Month */), pattern: /month/i, label: "MONTH" });
-var day = createToken2({ name: capitalize("builtInDay" /* Day */), pattern: /day/i, label: "DAY" });
-var hours = createToken2({ name: capitalize("builtInHours" /* Hours */), pattern: /hours/i, label: "HOURS" });
-var minutes = createToken2({ name: capitalize("builtInMinutes" /* Minutes */), pattern: /minutes/i, label: "MINUTES" });
-var seconds = createToken2({ name: capitalize("builtInSeconds" /* Seconds */), pattern: /seconds/i, label: "SECONDS" });
+var year = createToken2({ name: capitalize(BuiltInCalls.Year), pattern: /year/i, label: "YEAR" });
+var month = createToken2({ name: capitalize(BuiltInCalls.Month), pattern: /month/i, label: "MONTH" });
+var day = createToken2({ name: capitalize(BuiltInCalls.Day), pattern: /day/i, label: "DAY" });
+var hours = createToken2({ name: capitalize(BuiltInCalls.Hours), pattern: /hours/i, label: "HOURS" });
+var minutes = createToken2({ name: capitalize(BuiltInCalls.Minutes), pattern: /minutes/i, label: "MINUTES" });
+var seconds = createToken2({ name: capitalize(BuiltInCalls.Seconds), pattern: /seconds/i, label: "SECONDS" });
 var timezone = createToken2({
-  name: capitalize("builtInTimezone" /* Timezone */),
+  name: capitalize(BuiltInCalls.Timezone),
   pattern: /timezone/i,
   label: "TIMEZONE"
 });
-var tz = createToken2({ name: capitalize("builtInTz" /* Tz */), pattern: /tz/i, label: "TZ" });
-var now = createToken2({ name: capitalize("builtInNow" /* Now */), pattern: /now/i, label: "NOW" });
-var uuid = createToken2({ name: capitalize("builtInUuid" /* Uuid */), pattern: /uuid/i, label: "UUID" });
-var struuid = createToken2({ name: capitalize("builtInStruuid" /* Struuid */), pattern: /struuid/i, label: "STRUUID" });
-var md5 = createToken2({ name: capitalize("builtInMd5" /* Md5 */), pattern: /md5/i, label: "MD5" });
-var sha1 = createToken2({ name: capitalize("builtInSha1" /* Sha1 */), pattern: /sha1/i, label: "SHA1" });
-var sha256 = createToken2({ name: capitalize("builtInSha256" /* Sha256 */), pattern: /sha256/i, label: "SHA256" });
-var sha384 = createToken2({ name: capitalize("builtInSha384" /* Sha384 */), pattern: /sha384/i, label: "SHA384" });
-var sha512 = createToken2({ name: capitalize("builtInSha512" /* Sha512 */), pattern: /sha512/i, label: "SHA512" });
+var tz = createToken2({ name: capitalize(BuiltInCalls.Tz), pattern: /tz/i, label: "TZ" });
+var now = createToken2({ name: capitalize(BuiltInCalls.Now), pattern: /now/i, label: "NOW" });
+var uuid = createToken2({ name: capitalize(BuiltInCalls.Uuid), pattern: /uuid/i, label: "UUID" });
+var struuid = createToken2({ name: capitalize(BuiltInCalls.Struuid), pattern: /struuid/i, label: "STRUUID" });
+var md5 = createToken2({ name: capitalize(BuiltInCalls.Md5), pattern: /md5/i, label: "MD5" });
+var sha1 = createToken2({ name: capitalize(BuiltInCalls.Sha1), pattern: /sha1/i, label: "SHA1" });
+var sha256 = createToken2({ name: capitalize(BuiltInCalls.Sha256), pattern: /sha256/i, label: "SHA256" });
+var sha384 = createToken2({ name: capitalize(BuiltInCalls.Sha384), pattern: /sha384/i, label: "SHA384" });
+var sha512 = createToken2({ name: capitalize(BuiltInCalls.Sha512), pattern: /sha512/i, label: "SHA512" });
 var coalesce = createToken2({
-  name: capitalize("builtInCoalesce" /* Coalesce */),
+  name: capitalize(BuiltInCalls.Coalesce),
   pattern: /coalesce/i,
   label: "COALESCE"
 });
-var if_ = createToken2({ name: capitalize("builtInIf" /* If */), pattern: /if/i, label: "IF" });
-var strlang = createToken2({ name: capitalize("builtInStrlang" /* Strlang */), pattern: /strlang/i, label: "STRLANG" });
-var strdt = createToken2({ name: capitalize("builtInStrdt" /* Strdt */), pattern: /strdt/i, label: "STRDT" });
+var if_ = createToken2({ name: capitalize(BuiltInCalls.If), pattern: /if/i, label: "IF" });
+var strlang = createToken2({ name: capitalize(BuiltInCalls.Strlang), pattern: /strlang/i, label: "STRLANG" });
+var strdt = createToken2({ name: capitalize(BuiltInCalls.Strdt), pattern: /strdt/i, label: "STRDT" });
 var sameterm = createToken2({
-  name: capitalize("builtInSameterm" /* Sameterm */),
+  name: capitalize(BuiltInCalls.Sameterm),
   pattern: /sameterm/i,
   label: "SAMETERM"
 });
-var isiri = createToken2({ name: capitalize("builtInIsiri" /* Isiri */), pattern: /isiri/i, label: "ISIRI" });
-var isuri = createToken2({ name: capitalize("builtInIsuri" /* Isuri */), pattern: /isuri/i, label: "ISURI" });
-var isblank = createToken2({ name: capitalize("builtInIsblank" /* Isblank */), pattern: /isblank/i, label: "ISBLANK" });
+var isiri = createToken2({ name: capitalize(BuiltInCalls.Isiri), pattern: /isiri/i, label: "ISIRI" });
+var isuri = createToken2({ name: capitalize(BuiltInCalls.Isuri), pattern: /isuri/i, label: "ISURI" });
+var isblank = createToken2({ name: capitalize(BuiltInCalls.Isblank), pattern: /isblank/i, label: "ISBLANK" });
 var isliteral = createToken2({
-  name: capitalize("builtInIsliteral" /* Isliteral */),
+  name: capitalize(BuiltInCalls.Isliteral),
   pattern: /isliteral/i,
   label: "ISLITERAL"
 });
 var isnumeric = createToken2({
-  name: capitalize("builtInIsnumeric" /* Isnumeric */),
+  name: capitalize(BuiltInCalls.Isnumeric),
   pattern: /isnumeric/i,
   label: "ISNUMERIC"
 });
-var regex = createToken2({ name: capitalize("builtInRegex" /* Regex */), pattern: /regex/i, label: "REGEX" });
-var substr = createToken2({ name: capitalize("builtInSubstr" /* Substr */), pattern: /substr/i, label: "SUBSTR" });
-var replace = createToken2({ name: capitalize("builtInReplace" /* Replace */), pattern: /replace/i, label: "REPLACE" });
-var exists = createToken2({ name: capitalize("builtInExists" /* Exists */), pattern: /exists/i, label: "EXISTS" });
+var regex = createToken2({ name: capitalize(BuiltInCalls.Regex), pattern: /regex/i, label: "REGEX" });
+var substr = createToken2({ name: capitalize(BuiltInCalls.Substr), pattern: /substr/i, label: "SUBSTR" });
+var replace = createToken2({ name: capitalize(BuiltInCalls.Replace), pattern: /replace/i, label: "REPLACE" });
+var exists = createToken2({ name: capitalize(BuiltInCalls.Exists), pattern: /exists/i, label: "EXISTS" });
 var notexists = createToken2({
-  name: capitalize("builtInNotexists" /* Notexists */),
+  name: capitalize(BuiltInCalls.Notexists),
   pattern: /not exists/i,
   label: "NOT EXISTS"
 });
-var count = createToken2({ name: capitalize("builtInCount" /* Count */), pattern: /count/i, label: "COUNT" });
-var sum = createToken2({ name: capitalize("builtInSum" /* Sum */), pattern: /sum/i, label: "SUM" });
-var min = createToken2({ name: capitalize("builtInMin" /* Min */), pattern: /min/i, label: "MIN" });
-var max = createToken2({ name: capitalize("builtInMax" /* Max */), pattern: /max/i, label: "MAX" });
-var avg = createToken2({ name: capitalize("builtInAvg" /* Avg */), pattern: /avg/i, label: "AVG" });
-var sample = createToken2({ name: capitalize("builtInSample" /* Sample */), pattern: /sample/i, label: "SAMPLE" });
+var count = createToken2({ name: capitalize(BuiltInCalls.Count), pattern: /count/i, label: "COUNT" });
+var sum = createToken2({ name: capitalize(BuiltInCalls.Sum), pattern: /sum/i, label: "SUM" });
+var min = createToken2({ name: capitalize(BuiltInCalls.Min), pattern: /min/i, label: "MIN" });
+var max = createToken2({ name: capitalize(BuiltInCalls.Max), pattern: /max/i, label: "MAX" });
+var avg = createToken2({ name: capitalize(BuiltInCalls.Avg), pattern: /avg/i, label: "AVG" });
+var sample = createToken2({ name: capitalize(BuiltInCalls.Sample), pattern: /sample/i, label: "SAMPLE" });
 var groupConcat = createToken2({
-  name: capitalize("builtInGroup_concat" /* Group_concat */),
+  name: capitalize(BuiltInCalls.Group_concat),
   pattern: /group_concat/i,
   label: "GROUP_CONCAT"
 });
-var allBuiltInCalls = LexerBuilder.create().add(
-  langmatches,
-  datatype,
-  lang,
-  bound,
-  iri,
-  uri,
-  bnode,
-  rand,
-  abs,
-  ceil,
-  floor,
-  round,
-  concat,
-  strlen,
-  ucase,
-  lcase,
-  encode_for_uri,
-  contains,
-  strstarts,
-  strends,
-  strbefore,
-  strafter,
-  year,
-  month,
-  day,
-  hours,
-  minutes,
-  seconds,
-  timezone,
-  tz,
-  now,
-  uuid,
-  struuid,
-  md5,
-  sha1,
-  sha256,
-  sha384,
-  sha512,
-  coalesce,
-  if_,
-  strlang,
-  strdt,
-  sameterm,
-  isiri,
-  isuri,
-  isblank,
-  isliteral,
-  isnumeric,
-  regex,
-  substr,
-  replace,
-  exists,
-  notexists,
-  count,
-  sum,
-  min,
-  max,
-  avg,
-  sample,
-  groupConcat,
-  str
-);
+var allBuiltInCalls = LexerBuilder.create().add(langmatches, datatype, lang, bound, iri, uri, bnode, rand, abs, ceil, floor, round, concat, strlen, ucase, lcase, encode_for_uri, contains, strstarts, strends, strbefore, strafter, year, month, day, hours, minutes, seconds, timezone, tz, now, uuid, struuid, md5, sha1, sha256, sha384, sha512, coalesce, if_, strlang, strdt, sameterm, isiri, isuri, isblank, isliteral, isnumeric, regex, substr, replace, exists, notexists, count, sum, min, max, avg, sample, groupConcat, str);
 
-// ../../packages/rules-sparql-1-1/lib/lexer/graph.ts
+// ../../packages/rules-sparql-1-1/lib/lexer/graph.js
 var graph_exports = {};
 __export(graph_exports, {
   allGraphTokens: () => allGraphTokens,
@@ -10337,14 +10276,9 @@ var named = createToken2({ name: "NamedGraph", pattern: /named/i, label: "NAMED"
 var default_ = createToken2({ name: "DefaultGraph", pattern: /default/i, label: "DEFAULT" });
 var graph = createToken2({ name: "Graph", pattern: /graph/i, label: "GRAPH" });
 var graphAll = createToken2({ name: "GraphAll", pattern: /all/i, label: "ALL" });
-var allGraphTokens = LexerBuilder.create().add(
-  named,
-  default_,
-  graph,
-  graphAll
-);
+var allGraphTokens = LexerBuilder.create().add(named, default_, graph, graphAll);
 
-// ../../packages/rules-sparql-1-1/lib/lexer/symbols.ts
+// ../../packages/rules-sparql-1-1/lib/lexer/symbols.js
 var symbols_exports = {};
 __export(symbols_exports, {
   LCurly: () => LCurly,
@@ -10401,36 +10335,9 @@ var greaterThan = createToken2({ name: "GreaterThan", pattern: ">", label: ">" }
 var lessThanEqual = createToken2({ name: "LessThanEqual", pattern: "<=", label: "<=" });
 var greaterThanEqual = createToken2({ name: "GreaterThanEqual", pattern: ">=", label: ">=" });
 var hathat = createToken2({ name: "Hathat", pattern: "^^", label: "^^" });
-var allSymbols = LexerBuilder.create().add(
-  logicAnd,
-  logicOr,
-  notEqual,
-  lessThanEqual,
-  greaterThanEqual,
-  LCurly,
-  RCurly,
-  dot,
-  comma,
-  semi,
-  LParen,
-  RParen,
-  LSquare,
-  RSquare,
-  pipe,
-  slash,
-  hathat,
-  hat,
-  question,
-  star,
-  opPlus,
-  opMinus,
-  exclamation,
-  equal,
-  lessThan,
-  greaterThan
-);
+var allSymbols = LexerBuilder.create().add(logicAnd, logicOr, notEqual, lessThanEqual, greaterThanEqual, LCurly, RCurly, dot, comma, semi, LParen, RParen, LSquare, RSquare, pipe, slash, hathat, hat, question, star, opPlus, opMinus, exclamation, equal, lessThan, greaterThan);
 
-// ../../packages/rules-sparql-1-1/lib/lexer/terminals.ts
+// ../../packages/rules-sparql-1-1/lib/lexer/terminals.js
 var terminals_exports = {};
 __export(terminals_exports, {
   allTerminals: () => allTerminals,
@@ -10517,34 +10424,9 @@ var ws = createToken2({ name: "Ws", pattern: wsPattern, group: Lexer.SKIPPED });
 var comment = createToken2({ name: "Comment", pattern: /#[^\n]*/, group: Lexer.SKIPPED });
 var nil = createToken2({ name: "Nil", pattern: nilPattern });
 var anon = createToken2({ name: "Anon", pattern: anonPattern });
-var allTerminals = LexerBuilder.create().add(
-  iriRef,
-  pNameNs,
-  pNameLn,
-  blankNodeLabel,
-  var1,
-  var2,
-  langTag,
-  double,
-  decimal,
-  integer,
-  integerPositive,
-  decimalPositive,
-  doublePositive,
-  integerNegative,
-  decimalNegative,
-  doubleNegative,
-  stringLiteralLong1,
-  stringLiteralLong2,
-  stringLiteral1,
-  stringLiteral2,
-  ws,
-  comment,
-  nil,
-  anon
-);
+var allTerminals = LexerBuilder.create().add(iriRef, pNameNs, pNameLn, blankNodeLabel, var1, var2, langTag, double, decimal, integer, integerPositive, decimalPositive, doublePositive, integerNegative, decimalNegative, doubleNegative, stringLiteralLong1, stringLiteralLong2, stringLiteral1, stringLiteral2, ws, comment, nil, anon);
 
-// ../../packages/rules-sparql-1-1/lib/lexer/lexer.ts
+// ../../packages/rules-sparql-1-1/lib/lexer/lexer.js
 var baseDecl = createToken2({ name: "BaseDecl", pattern: /base/i, label: "BASE" });
 var prefixDecl = createToken2({ name: "PrefixDecl", pattern: /prefix/i, label: "PREFIX" });
 var select = createToken2({ name: "Select", pattern: /select/i, label: "SELECT" });
@@ -10593,59 +10475,10 @@ var false_ = createToken2({ name: "False", pattern: /false/i, label: "false" });
 var in_ = createToken2({ name: "In", pattern: /in/i, label: "IN" });
 var notIn = createToken2({ name: "NotIn", pattern: /not[\u0020\u0009\u000D\u000A]+in/i, label: "NOT IN" });
 var separator = createToken2({ name: "Separator", pattern: /separator/i, label: "SEPARATOR" });
-var allBaseTokens = LexerBuilder.create().add(
-  baseDecl,
-  prefixDecl,
-  select,
-  distinct,
-  reduced,
-  construct,
-  describe,
-  ask,
-  from,
-  where,
-  having,
-  groupByGroup,
-  by,
-  order,
-  orderAsc,
-  orderDesc,
-  limit,
-  offset,
-  values2,
-  load,
-  silent,
-  loadInto,
-  clear,
-  drop2,
-  create,
-  add,
-  to,
-  move,
-  copy,
-  modifyWith,
-  deleteClause,
-  insertClause,
-  dataClause,
-  usingClause,
-  optional,
-  service,
-  bind,
-  undef,
-  minus,
-  union,
-  filter2,
-  as,
-  a,
-  true_,
-  false_,
-  in_,
-  notIn,
-  separator
-);
+var allBaseTokens = LexerBuilder.create().add(baseDecl, prefixDecl, select, distinct, reduced, construct, describe, ask, from, where, having, groupByGroup, by, order, orderAsc, orderDesc, limit, offset, values2, load, silent, loadInto, clear, drop2, create, add, to, move, copy, modifyWith, deleteClause, insertClause, dataClause, usingClause, optional, service, bind, undef, minus, union, filter2, as, a, true_, false_, in_, notIn, separator);
 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);
 
-// ../../packages/rules-sparql-1-1/lib/factoryMixins/ContextFactory.ts
+// ../../packages/rules-sparql-1-1/lib/factoryMixins/ContextFactory.js
 var nodeType = "contextDef";
 function ContextFactoryMixin(Base) {
   return class ContextFactory extends Base {
@@ -10675,7 +10508,7 @@ function ContextFactoryMixin(Base) {
   };
 }
 
-// ../../packages/rules-sparql-1-1/lib/factoryMixins/ExpressionFactory.ts
+// ../../packages/rules-sparql-1-1/lib/factoryMixins/ExpressionFactory.js
 var nodeType2 = "expression";
 function ExpressionFactoryMixin(Base) {
   return class ExpressionFactory extends Base {
@@ -10755,7 +10588,7 @@ function ExpressionFactoryMixin(Base) {
   };
 }
 
-// ../../packages/rules-sparql-1-1/lib/factoryMixins/GraphRefFactory.ts
+// ../../packages/rules-sparql-1-1/lib/factoryMixins/GraphRefFactory.js
 var nodeType3 = "graphRef";
 function GraphRefFactoryMixin(Base) {
   return class GraphRefFactory extends Base {
@@ -10806,11 +10639,12 @@ function GraphRefFactoryMixin(Base) {
   };
 }
 
-// ../../packages/rules-sparql-1-1/lib/factoryMixins/mixins.ts
+// ../../packages/rules-sparql-1-1/lib/factoryMixins/mixins.js
 function asArg(arg) {
   return new FlatCall(arg);
 }
 var FlatCall = class {
+  input;
   constructor(input) {
     this.input = input;
   }
@@ -10823,7 +10657,7 @@ var FlatCall = class {
   }
 };
 
-// ../../packages/rules-sparql-1-1/lib/factoryMixins/PathFactory.ts
+// ../../packages/rules-sparql-1-1/lib/factoryMixins/PathFactory.js
 var nodeType4 = "path";
 function PathFactoryMixin(Base) {
   return class PathFactory extends Base {
@@ -10888,7 +10722,7 @@ function PathFactoryMixin(Base) {
   };
 }
 
-// ../../packages/rules-sparql-1-1/lib/factoryMixins/Patternfactory.ts
+// ../../packages/rules-sparql-1-1/lib/factoryMixins/Patternfactory.js
 var nodeType5 = "pattern";
 function PatternFactoryMixin(Base) {
   return class PatternFactory extends Base {
@@ -10986,7 +10820,7 @@ function PatternFactoryMixin(Base) {
   };
 }
 
-// ../../packages/rules-sparql-1-1/lib/factoryMixins/QueryFactory.ts
+// ../../packages/rules-sparql-1-1/lib/factoryMixins/QueryFactory.js
 var nodeType6 = "query";
 function QueryFactoryMixin(Base) {
   return class QueryFactory extends Base {
@@ -11029,7 +10863,7 @@ function QueryFactoryMixin(Base) {
   };
 }
 
-// ../../packages/rules-sparql-1-1/lib/factoryMixins/SolutionModifiersFactory.ts
+// ../../packages/rules-sparql-1-1/lib/factoryMixins/SolutionModifiersFactory.js
 var nodeType7 = "solutionModifier";
 function SolutionModifiersFactoryMixin(Base) {
   return class SolutionModifiersFactory extends Base {
@@ -11084,7 +10918,7 @@ function SolutionModifiersFactoryMixin(Base) {
   };
 }
 
-// ../../packages/rules-sparql-1-1/lib/factoryMixins/TermFactory.ts
+// ../../packages/rules-sparql-1-1/lib/factoryMixins/TermFactory.js
 var nodeType8 = "term";
 function TermFactoryMixin(Base) {
   return class TermFactory extends Base {
@@ -11164,7 +10998,7 @@ function TermFactoryMixin(Base) {
   };
 }
 
-// ../../packages/rules-sparql-1-1/lib/factoryMixins/UpdateOperationFactory.ts
+// ../../packages/rules-sparql-1-1/lib/factoryMixins/UpdateOperationFactory.js
 var nodeType9 = "updateOperation";
 function UpdateOperationFactoryMixin(Base) {
   return class UpdateOperationFactory extends Base {
@@ -11289,7 +11123,7 @@ function UpdateOperationFactoryMixin(Base) {
   };
 }
 
-// ../../packages/rules-sparql-1-1/lib/factory.ts
+// ../../packages/rules-sparql-1-1/lib/factory.js
 var Factory = class extends asArg(CoreFactory).call(ContextFactoryMixin).call(ExpressionFactoryMixin).call(GraphRefFactoryMixin).call(PathFactoryMixin).call(PatternFactoryMixin).call(QueryFactoryMixin).call(SolutionModifiersFactoryMixin).call(TermFactoryMixin).call(UpdateOperationFactoryMixin).returns() {
   alwaysSparql11(obj) {
     return true;
@@ -11374,11 +11208,23 @@ var Factory = class extends asArg(CoreFactory).call(ContextFactoryMixin).call(Ex
   }
 };
 
-// ../../packages/rules-sparql-1-1/lib/utils.ts
+// ../../packages/rules-sparql-1-1/lib/utils.js
+var CommonIRIs;
+(function(CommonIRIs2) {
+  CommonIRIs2["BOOLEAN"] = "http://www.w3.org/2001/XMLSchema#boolean";
+  CommonIRIs2["INTEGER"] = "http://www.w3.org/2001/XMLSchema#integer";
+  CommonIRIs2["DECIMAL"] = "http://www.w3.org/2001/XMLSchema#decimal";
+  CommonIRIs2["DOUBLE"] = "http://www.w3.org/2001/XMLSchema#double";
+  CommonIRIs2["STRING"] = "http://www.w3.org/2001/XMLSchema#string";
+  CommonIRIs2["FIRST"] = "http://www.w3.org/1999/02/22-rdf-syntax-ns#first";
+  CommonIRIs2["REST"] = "http://www.w3.org/1999/02/22-rdf-syntax-ns#rest";
+  CommonIRIs2["NIL"] = "http://www.w3.org/1999/02/22-rdf-syntax-ns#nil";
+  CommonIRIs2["TYPE"] = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type";
+})(CommonIRIs || (CommonIRIs = {}));
 var TransformerSparql11 = class extends TransformerSubType {
 };
 
-// ../../packages/rules-sparql-1-1/lib/validation/validators.ts
+// ../../packages/rules-sparql-1-1/lib/validation/validators.js
 var F = new Factory();
 var transformer = new TransformerSparql11();
 function getAggregatesOfExpression(expression2) {
@@ -11423,9 +11269,7 @@ function queryIsGood(query2) {
     return;
   }
   const variables = query2.variables;
-  const hasCountAggregate = variables.flatMap(
-    (varVal) => F.isTerm(varVal) ? [] : getAggregatesOfExpression(varVal.expression)
-  ).some((agg) => agg.aggregation === "count" && !agg.expression.some((arg) => F.isWildcard(arg)));
+  const hasCountAggregate = variables.flatMap((varVal) => F.isTerm(varVal) ? [] : getAggregatesOfExpression(varVal.expression)).some((agg) => agg.aggregation === "count" && !agg.expression.some((arg) => F.isWildcard(arg)));
   const groupBy2 = query2.solutionModifiers.group;
   if (hasCountAggregate || groupBy2) {
     for (const selectVar of variables) {
@@ -11570,7 +11414,7 @@ function updateNoReuseBlankNodeLabels(updateQuery) {
   }
 }
 
-// ../../packages/rules-sparql-1-1/lib/grammar/literals.ts
+// ../../packages/rules-sparql-1-1/lib/grammar/literals.js
 function stringEscapedLexical(str2) {
   const lexical = str2.replaceAll(/["\\\t\n\r\b\f]/gu, (char) => {
     switch (char) {
@@ -11601,20 +11445,12 @@ var rdfLiteral = {
     return OPTION(() => OR([
       { ALT: () => {
         const lang2 = CONSUME(terminals_exports.langTag);
-        return ACTION(() => C.factory.literalTerm(
-          C.factory.sourceLocation(value, lang2),
-          value.value,
-          lang2.image.slice(1).toLowerCase()
-        ));
+        return ACTION(() => C.factory.literalTerm(C.factory.sourceLocation(value, lang2), value.value, lang2.image.slice(1).toLowerCase()));
       } },
       { ALT: () => {
         CONSUME(symbols_exports.hathat);
         const iriVal = SUBRULE1(iri2);
-        return ACTION(() => C.factory.literalTerm(
-          C.factory.sourceLocation(value, iriVal),
-          value.value,
-          iriVal
-        ));
+        return ACTION(() => C.factory.literalTerm(C.factory.sourceLocation(value, iriVal), value.value, iriVal));
       } }
     ])) ?? value;
   },
@@ -11642,45 +11478,33 @@ var numericLiteralUnsigned = {
   name: "numericLiteralUnsigned",
   impl: ({ ACTION, CONSUME, OR }) => (C) => {
     const parsed = OR([
-      { ALT: () => [CONSUME(terminals_exports.integer), "http://www.w3.org/2001/XMLSchema#integer" /* INTEGER */] },
-      { ALT: () => [CONSUME(terminals_exports.decimal), "http://www.w3.org/2001/XMLSchema#decimal" /* DECIMAL */] },
-      { ALT: () => [CONSUME(terminals_exports.double), "http://www.w3.org/2001/XMLSchema#double" /* DOUBLE */] }
+      { ALT: () => [CONSUME(terminals_exports.integer), CommonIRIs.INTEGER] },
+      { ALT: () => [CONSUME(terminals_exports.decimal), CommonIRIs.DECIMAL] },
+      { ALT: () => [CONSUME(terminals_exports.double), CommonIRIs.DOUBLE] }
     ]);
-    return ACTION(() => C.factory.literalTerm(
-      C.factory.sourceLocation(parsed[0]),
-      parsed[0].image,
-      C.factory.namedNode(C.factory.sourceLocationNoMaterialize(), parsed[1])
-    ));
+    return ACTION(() => C.factory.literalTerm(C.factory.sourceLocation(parsed[0]), parsed[0].image, C.factory.namedNode(C.factory.sourceLocationNoMaterialize(), parsed[1])));
   }
 };
 var numericLiteralPositive = {
   name: "numericLiteralPositive",
   impl: ({ ACTION, CONSUME, OR }) => (C) => {
     const parsed = OR([
-      { ALT: () => [CONSUME(terminals_exports.integerPositive), "http://www.w3.org/2001/XMLSchema#integer" /* INTEGER */] },
-      { ALT: () => [CONSUME(terminals_exports.decimalPositive), "http://www.w3.org/2001/XMLSchema#decimal" /* DECIMAL */] },
-      { ALT: () => [CONSUME(terminals_exports.doublePositive), "http://www.w3.org/2001/XMLSchema#double" /* DOUBLE */] }
+      { ALT: () => [CONSUME(terminals_exports.integerPositive), CommonIRIs.INTEGER] },
+      { ALT: () => [CONSUME(terminals_exports.decimalPositive), CommonIRIs.DECIMAL] },
+      { ALT: () => [CONSUME(terminals_exports.doublePositive), CommonIRIs.DOUBLE] }
     ]);
-    return ACTION(() => C.factory.literalTerm(
-      C.factory.sourceLocation(parsed[0]),
-      parsed[0].image,
-      C.factory.namedNode(C.factory.sourceLocationNoMaterialize(), parsed[1])
-    ));
+    return ACTION(() => C.factory.literalTerm(C.factory.sourceLocation(parsed[0]), parsed[0].image, C.factory.namedNode(C.factory.sourceLocationNoMaterialize(), parsed[1])));
   }
 };
 var numericLiteralNegative = {
   name: "numericLiteralNegative",
   impl: ({ ACTION, CONSUME, OR }) => (C) => {
     const parsed = OR([
-      { ALT: () => [CONSUME(terminals_exports.integerNegative), "http://www.w3.org/2001/XMLSchema#integer" /* INTEGER */] },
-      { ALT: () => [CONSUME(terminals_exports.decimalNegative), "http://www.w3.org/2001/XMLSchema#decimal" /* DECIMAL */] },
-      { ALT: () => [CONSUME(terminals_exports.doubleNegative), "http://www.w3.org/2001/XMLSchema#double" /* DOUBLE */] }
+      { ALT: () => [CONSUME(terminals_exports.integerNegative), CommonIRIs.INTEGER] },
+      { ALT: () => [CONSUME(terminals_exports.decimalNegative), CommonIRIs.DECIMAL] },
+      { ALT: () => [CONSUME(terminals_exports.doubleNegative), CommonIRIs.DOUBLE] }
     ]);
-    return ACTION(() => C.factory.literalTerm(
-      C.factory.sourceLocation(parsed[0]),
-      parsed[0].image,
-      C.factory.namedNode(C.factory.sourceLocationNoMaterialize(), parsed[1])
-    ));
+    return ACTION(() => C.factory.literalTerm(C.factory.sourceLocation(parsed[0]), parsed[0].image, C.factory.namedNode(C.factory.sourceLocationNoMaterialize(), parsed[1])));
   }
 };
 var booleanLiteral = {
@@ -11690,11 +11514,7 @@ var booleanLiteral = {
       { ALT: () => CONSUME(true_) },
       { ALT: () => CONSUME(false_) }
     ]);
-    return ACTION(() => C.factory.literalTerm(
-      C.factory.sourceLocation(token),
-      token.image.toLowerCase(),
-      C.factory.namedNode(C.factory.sourceLocationNoMaterialize(), "http://www.w3.org/2001/XMLSchema#boolean" /* BOOLEAN */)
-    ));
+    return ACTION(() => C.factory.literalTerm(C.factory.sourceLocation(token), token.image.toLowerCase(), C.factory.namedNode(C.factory.sourceLocationNoMaterialize(), CommonIRIs.BOOLEAN)));
   }
 };
 var string = {
@@ -11806,11 +11626,11 @@ var verbA = {
   name: "VerbA",
   impl: ({ ACTION, CONSUME }) => (C) => {
     const token = CONSUME(a);
-    return ACTION(() => C.factory.namedNode(C.factory.sourceLocation(token), "http://www.w3.org/1999/02/22-rdf-syntax-ns#type" /* TYPE */, void 0));
+    return ACTION(() => C.factory.namedNode(C.factory.sourceLocation(token), CommonIRIs.TYPE, void 0));
   }
 };
 
-// ../../packages/rules-sparql-1-1/lib/grammar/general.ts
+// ../../packages/rules-sparql-1-1/lib/grammar/general.js
 var prologue = {
   name: "prologue",
   impl: ({ SUBRULE, MANY, OR }) => () => {
@@ -11910,7 +11730,7 @@ var graphTerm = {
     { 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 */));
+      return ACTION(() => C.factory.namedNode(C.factory.sourceLocation(tokenNil), CommonIRIs.NIL));
     } }
   ]),
   gImpl: ({ SUBRULE }) => (ast, { factory: F2 }) => {
@@ -11924,7 +11744,7 @@ var graphTerm = {
   }
 };
 
-// ../../packages/rules-sparql-1-1/lib/grammar/dataSetClause.ts
+// ../../packages/rules-sparql-1-1/lib/grammar/dataSetClause.js
 function datasetClauseUsing(name, token) {
   return {
     name,
@@ -11961,10 +11781,7 @@ function datasetClauseUsingStar(name, subRule, fromUsing) {
         const clause = SUBRULE(subRule);
         clauses.push(clause);
       });
-      return ACTION(() => C.factory.datasetClauses(
-        clauses.map((clause) => clause.val),
-        C.factory.sourceLocation(...clauses)
-      ));
+      return ACTION(() => C.factory.datasetClauses(clauses.map((clause) => clause.val), C.factory.sourceLocation(...clauses)));
     },
     gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
       for (const clause of ast.clauses) {
@@ -11992,7 +11809,7 @@ var sourceSelector = {
   impl: ({ SUBRULE }) => () => SUBRULE(iri2)
 };
 
-// ../../packages/rules-sparql-1-1/lib/expressionHelpers.ts
+// ../../packages/rules-sparql-1-1/lib/expressionHelpers.js
 function funcExpr1(func) {
   return {
     name: unCapitalize(func.name),
@@ -12101,29 +11918,14 @@ function funcExpr2or3(func) {
         return SUBRULE3(expression);
       });
       const close = CONSUME(symbols_exports.RParen);
-      return ACTION(() => C.factory.expressionOperation(
-        operator.image,
-        arg3 ? [arg1, arg2, arg3] : [arg1, arg2],
-        C.factory.sourceLocation(operator, close)
-      ));
+      return ACTION(() => C.factory.expressionOperation(operator.image, arg3 ? [arg1, arg2, arg3] : [arg1, arg2], C.factory.sourceLocation(operator, close)));
     }
   };
 }
 function funcExpr3or4(func) {
   return {
     name: unCapitalize(func.name),
-    impl: ({
-      ACTION,
-      CONSUME,
-      SUBRULE1,
-      SUBRULE2,
-      SUBRULE3,
-      SUBRULE4,
-      CONSUME1,
-      OPTION,
-      CONSUME2,
-      CONSUME3
-    }) => (C) => {
+    impl: ({ ACTION, CONSUME, SUBRULE1, SUBRULE2, SUBRULE3, SUBRULE4, CONSUME1, OPTION, CONSUME2, CONSUME3 }) => (C) => {
       const operator = CONSUME(func);
       CONSUME(symbols_exports.LParen);
       const arg1 = SUBRULE1(expression);
@@ -12136,11 +11938,7 @@ function funcExpr3or4(func) {
         return SUBRULE4(expression);
       });
       const close = CONSUME(symbols_exports.RParen);
-      return ACTION(() => C.factory.expressionOperation(
-        operator.image,
-        arg4 ? [arg1, arg2, arg3, arg4] : [arg1, arg2, arg3],
-        C.factory.sourceLocation(operator, close)
-      ));
+      return ACTION(() => C.factory.expressionOperation(operator.image, arg4 ? [arg1, arg2, arg3, arg4] : [arg1, arg2, arg3], C.factory.sourceLocation(operator, close)));
     }
   };
 }
@@ -12150,11 +11948,7 @@ function funcGroupGraphPattern(func) {
     impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
       const operator = CONSUME(func);
       const group = SUBRULE(groupGraphPattern);
-      return ACTION(() => C.factory.expressionPatternOperation(
-        operator.image,
-        group,
-        C.factory.sourceLocation(operator, group)
-      ));
+      return ACTION(() => C.factory.expressionPatternOperation(operator.image, group, C.factory.sourceLocation(operator, group)));
     }
   };
 }
@@ -12167,18 +11961,12 @@ function baseAggregateFunc(func) {
       const distinct2 = OPTION(() => CONSUME(distinct));
       const expr1 = SUBRULE(expression);
       const close = CONSUME(symbols_exports.RParen);
-      return ACTION(() => C.factory.aggregate(
-        operator.image,
-        distinct2 !== void 0,
-        expr1,
-        void 0,
-        C.factory.sourceLocation(operator, close)
-      ));
+      return ACTION(() => C.factory.aggregate(operator.image, distinct2 !== void 0, expr1, void 0, C.factory.sourceLocation(operator, close)));
     }
   };
 }
 
-// ../../packages/rules-sparql-1-1/lib/grammar/builtIn.ts
+// ../../packages/rules-sparql-1-1/lib/grammar/builtIn.js
 var builtInStr = funcExpr1(BuiltInCalls_exports.str);
 var builtInLang = funcExpr1(BuiltInCalls_exports.lang);
 var builtInLangmatches = funcExpr2(BuiltInCalls_exports.langmatches);
@@ -12321,21 +12109,9 @@ var aggregateCount = {
     return ACTION(() => {
       const F2 = C.factory;
       if (C.factory.isWildcard(expressionVal)) {
-        return F2.aggregate(
-          operatorToken.image,
-          Boolean(distinctToken),
-          expressionVal,
-          void 0,
-          C.factory.sourceLocation(operatorToken, closeToken)
-        );
-      }
-      return F2.aggregate(
-        operatorToken.image,
-        Boolean(distinctToken),
-        expressionVal,
-        void 0,
-        C.factory.sourceLocation(operatorToken, closeToken)
-      );
+        return F2.aggregate(operatorToken.image, Boolean(distinctToken), expressionVal, void 0, C.factory.sourceLocation(operatorToken, closeToken));
+      }
+      return F2.aggregate(operatorToken.image, Boolean(distinctToken), expressionVal, void 0, C.factory.sourceLocation(operatorToken, closeToken));
     });
   }
 };
@@ -12360,13 +12136,7 @@ var aggregateGroup_concat = {
     const closeToken = CONSUME(symbols_exports.RParen);
     return ACTION(() => {
       const F2 = C.factory;
-      return F2.aggregate(
-        operatorToken.image,
-        Boolean(distinctToken),
-        expr,
-        sep?.value ?? " ",
-        F2.sourceLocation(operatorToken, closeToken)
-      );
+      return F2.aggregate(operatorToken.image, Boolean(distinctToken), expr, sep?.value ?? " ", F2.sourceLocation(operatorToken, closeToken));
     });
   }
 };
@@ -12415,7 +12185,7 @@ var aggregate = {
   }
 };
 
-// ../../packages/rules-sparql-1-1/lib/grammar/propertyPaths.ts
+// ../../packages/rules-sparql-1-1/lib/grammar/propertyPaths.js
 var path = {
   name: "path",
   impl: ({ SUBRULE }) => () => SUBRULE(pathAlternative)
@@ -12542,11 +12312,7 @@ var pathNegatedPropertySet = {
           if (tail.length === 0) {
             return F2.path("!", [head2], F2.sourceLocation(exclamation2, close));
           }
-          return F2.path(
-            "!",
-            [F2.path("|", [head2, ...tail], F2.sourceLocation(open, close))],
-            F2.sourceLocation(exclamation2, close)
-          );
+          return F2.path("!", [F2.path("|", [head2, ...tail], F2.sourceLocation(open, close))], F2.sourceLocation(exclamation2, close));
         });
       } }
     ]);
@@ -12568,7 +12334,7 @@ var pathOneInPropertySet = {
   ])
 };
 
-// ../../packages/rules-sparql-1-1/lib/grammar/tripleBlock.ts
+// ../../packages/rules-sparql-1-1/lib/grammar/tripleBlock.js
 function triplesDotSeperated(triplesSameSubjectSubrule) {
   return ({ ACTION, AT_LEAST_ONE, SUBRULE, CONSUME, OPTION }) => (C) => {
     const triples = [];
@@ -12627,10 +12393,7 @@ function triplesSameSubjectImpl(name, allowPaths) {
     impl: ({ ACTION, SUBRULE, OR }) => (C) => OR([
       { ALT: () => {
         const subject = SUBRULE(varOrTerm);
-        const res = SUBRULE(
-          allowPaths ? propertyListPathNotEmpty : propertyListNotEmpty,
-          ACTION(() => C.factory.dematerialized(subject))
-        );
+        const res = SUBRULE(allowPaths ? propertyListPathNotEmpty : propertyListNotEmpty, ACTION(() => C.factory.dematerialized(subject)));
         return ACTION(() => {
           if (res.length > 0) {
             res[0].subject = subject;
@@ -12641,10 +12404,7 @@ function triplesSameSubjectImpl(name, allowPaths) {
       } },
       { ALT: () => {
         const subjectNode = SUBRULE(allowPaths ? triplesNodePath : triplesNode);
-        const restNode = SUBRULE(
-          allowPaths ? propertyListPath : propertyList,
-          ACTION(() => C.factory.graphNodeIdentifier(subjectNode))
-        );
+        const restNode = SUBRULE(allowPaths ? propertyListPath : propertyList, ACTION(() => C.factory.graphNodeIdentifier(subjectNode)));
         return ACTION(() => {
           if (restNode.length === 0) {
             return [subjectNode];
@@ -12685,11 +12445,7 @@ function propertyListNotEmptyImplementation(name, allowPaths) {
             { ALT: () => SUBRULE1(verbPath) },
             { ALT: () => SUBRULE1(verbSimple) }
           ]) : SUBRULE1(verb);
-          const triples = SUBRULE1(
-            allowPaths ? objectListPath : objectList,
-            subject,
-            predicate
-          );
+          const triples = SUBRULE1(allowPaths ? objectListPath : objectList, subject, predicate);
           MANY2(() => {
             CONSUME(symbols_exports.semi);
             parsedSemi = true;
@@ -12757,18 +12513,14 @@ function collectionImpl(name, allowPaths) {
       return ACTION(() => {
         const F2 = C.factory;
         const triples = [];
-        const predFirst = F2.namedNode(F2.sourceLocationNoMaterialize(), "http://www.w3.org/1999/02/22-rdf-syntax-ns#first" /* FIRST */, void 0);
-        const predRest = F2.namedNode(F2.sourceLocationNoMaterialize(), "http://www.w3.org/1999/02/22-rdf-syntax-ns#rest" /* REST */, void 0);
-        const predNil = F2.namedNode(F2.sourceLocationNoMaterialize(), "http://www.w3.org/1999/02/22-rdf-syntax-ns#nil" /* NIL */, void 0);
+        const predFirst = F2.namedNode(F2.sourceLocationNoMaterialize(), CommonIRIs.FIRST, void 0);
+        const predRest = F2.namedNode(F2.sourceLocationNoMaterialize(), CommonIRIs.REST, void 0);
+        const predNil = F2.namedNode(F2.sourceLocationNoMaterialize(), CommonIRIs.NIL, void 0);
         const listHead = F2.blankNode(void 0, F2.sourceLocationNoMaterialize());
         let iterHead = listHead;
         for (const [index, term] of terms.entries()) {
           const lastInList = index === terms.length - 1;
-          const headTriple = F2.triple(
-            iterHead,
-            predFirst,
-            term
-          );
+          const headTriple = F2.triple(iterHead, predFirst, term);
           triples.push(headTriple);
           if (lastInList) {
             const nilTriple = F2.triple(iterHead, predRest, predNil);
@@ -12817,11 +12569,7 @@ function blankNodePropertyListImpl(name, allowPaths) {
       const blankNode2 = ACTION(() => C.factory.blankNode(void 0, C.factory.sourceLocationNoMaterialize()));
       const propList = SUBRULE(propertyPathNotEmptyImpl, blankNode2);
       const endToken = CONSUME(symbols_exports.RSquare);
-      return ACTION(() => C.factory.tripleCollectionBlankNodeProperties(
-        blankNode2,
-        propList,
-        C.factory.sourceLocation(startToken, endToken)
-      ));
+      return ACTION(() => C.factory.tripleCollectionBlankNodeProperties(blankNode2, propList, C.factory.sourceLocation(startToken, endToken)));
     },
     gImpl: ({ SUBRULE, PRINT, PRINT_WORD, HANDLE_LOC }) => (ast, { factory: F2 }) => {
       F2.printFilter(ast, () => PRINT("["));
@@ -12865,7 +12613,7 @@ function graphNodeImpl(name, allowPaths) {
 var graphNode = graphNodeImpl("graphNode", false);
 var graphNodePath = graphNodeImpl("graphNodePath", true);
 
-// ../../packages/rules-sparql-1-1/lib/grammar/whereClause.ts
+// ../../packages/rules-sparql-1-1/lib/grammar/whereClause.js
 var whereClause = {
   name: "whereClause",
   impl: ({ ACTION, SUBRULE, CONSUME, OPTION }) => (C) => {
@@ -13106,17 +12854,7 @@ var inlineDataOneVar = {
 };
 var inlineDataFull = {
   name: "inlineDataFull",
-  impl: ({
-    ACTION,
-    OR,
-    MANY1,
-    MANY2,
-    MANY3,
-    MANY4,
-    SUBRULE,
-    CONSUME1,
-    CONSUME2
-  }) => (C) => {
+  impl: ({ ACTION, OR, MANY1, MANY2, MANY3, MANY4, SUBRULE, CONSUME1, CONSUME2 }) => (C) => {
     const res = [];
     const vars = [];
     return OR([
@@ -13201,10 +12939,7 @@ var groupOrUnionGraphPattern = {
       const group2 = SUBRULE2(groupGraphPattern);
       groups.push(group2);
     });
-    return ACTION(() => groups.length === 1 ? groups[0] : C.factory.patternUnion(
-      groups,
-      C.factory.sourceLocation(group, groups.at(-1))
-    ));
+    return ACTION(() => groups.length === 1 ? groups[0] : C.factory.patternUnion(groups, C.factory.sourceLocation(group, groups.at(-1))));
   },
   gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
     if (F2.isPatternUnion(ast)) {
@@ -13245,16 +12980,11 @@ var functionCall = {
   impl: ({ ACTION, SUBRULE }) => (C) => {
     const func = SUBRULE(iri2);
     const args = SUBRULE(argList);
-    return ACTION(() => C.factory.expressionFunctionCall(
-      func,
-      args.val.args,
-      args.val.distinct,
-      C.factory.sourceLocation(func, args)
-    ));
+    return ACTION(() => C.factory.expressionFunctionCall(func, args.val.args, args.val.distinct, C.factory.sourceLocation(func, args)));
   }
 };
 
-// ../../packages/rules-sparql-1-1/lib/grammar/expression.ts
+// ../../packages/rules-sparql-1-1/lib/grammar/expression.js
 var argList = {
   name: "argList",
   impl: ({ ACTION, CONSUME, SUBRULE1, OPTION, OR, AT_LEAST_ONE_SEP }) => (C) => OR([
@@ -13386,29 +13116,19 @@ function constructLeftDeep(startGenerator, restGenerator, ACTION, MANY) {
 }
 var conditionalOrExpression = {
   name: "conditionalOrExpression",
-  impl: ({ ACTION, MANY, CONSUME, SUBRULE1, SUBRULE2 }) => (C) => constructLeftDeep(
-    () => SUBRULE1(conditionalAndExpression),
-    () => {
-      CONSUME(symbols_exports.logicOr);
-      const args = SUBRULE2(conditionalAndExpression);
-      return (left) => ACTION(() => C.factory.expressionOperation("||", [left, args], C.factory.sourceLocation(left, args)));
-    },
-    ACTION,
-    MANY
-  )
+  impl: ({ ACTION, MANY, CONSUME, SUBRULE1, SUBRULE2 }) => (C) => constructLeftDeep(() => SUBRULE1(conditionalAndExpression), () => {
+    CONSUME(symbols_exports.logicOr);
+    const args = SUBRULE2(conditionalAndExpression);
+    return (left) => ACTION(() => C.factory.expressionOperation("||", [left, args], C.factory.sourceLocation(left, args)));
+  }, ACTION, MANY)
 };
 var conditionalAndExpression = {
   name: "conditionalAndExpression",
-  impl: ({ ACTION, MANY, SUBRULE1, SUBRULE2, CONSUME }) => (C) => constructLeftDeep(
-    () => SUBRULE1(valueLogical),
-    () => {
-      CONSUME(symbols_exports.logicAnd);
-      const arg = SUBRULE2(valueLogical);
-      return (left) => ACTION(() => C.factory.expressionOperation("&&", [left, arg], C.factory.sourceLocation(left, arg)));
-    },
-    ACTION,
-    MANY
-  )
+  impl: ({ ACTION, MANY, SUBRULE1, SUBRULE2, CONSUME }) => (C) => constructLeftDeep(() => SUBRULE1(valueLogical), () => {
+    CONSUME(symbols_exports.logicAnd);
+    const arg = SUBRULE2(valueLogical);
+    return (left) => ACTION(() => C.factory.expressionOperation("&&", [left, arg], C.factory.sourceLocation(left, arg)));
+  }, ACTION, MANY)
 };
 var valueLogical = {
   name: "valueLogical",
@@ -13429,11 +13149,7 @@ var relationalExpression = {
           { ALT: () => CONSUME(symbols_exports.greaterThanEqual) }
         ]);
         const expr = SUBRULE2(numericExpression);
-        return ACTION(() => C.factory.expressionOperation(
-          operator.image,
-          [args1, expr],
-          C.factory.sourceLocation(args1, expr)
-        ));
+        return ACTION(() => C.factory.expressionOperation(operator.image, [args1, expr], C.factory.sourceLocation(args1, expr)));
       } },
       { ALT: () => {
         const operator = OR3([
@@ -13441,11 +13157,7 @@ var relationalExpression = {
           { ALT: () => CONSUME(notIn) }
         ]);
         const args = SUBRULE1(expressionList);
-        return ACTION(() => C.factory.expressionOperation(
-          operator.image,
-          [args1, ...args.val],
-          C.factory.sourceLocation(args1, args)
-        ));
+        return ACTION(() => C.factory.expressionOperation(operator.image, [args1, ...args.val], C.factory.sourceLocation(args1, args)));
       } }
     ]));
     return expression2 ?? args1;
@@ -13457,89 +13169,66 @@ var numericExpression = {
 };
 var additiveExpression = {
   name: "additiveExpression",
-  impl: ({ ACTION, SUBRULE, CONSUME, SUBRULE1, SUBRULE2, MANY1, MANY2, OR1, OR2, OR3, OR4 }) => (C) => constructLeftDeep(
-    () => SUBRULE1(multiplicativeExpression),
-    () => OR1([
-      { ALT: () => {
-        const operator = OR2([
-          { ALT: () => CONSUME(symbols_exports.opPlus) },
-          { ALT: () => CONSUME(symbols_exports.opMinus) }
-        ]);
-        const arg = SUBRULE2(multiplicativeExpression);
-        return ACTION(() => (left) => C.factory.expressionOperation(operator.image, [left, arg], C.factory.sourceLocation(left, arg)));
-      } },
-      { ALT: () => {
-        const { operator, startInt } = OR3([
-          { ALT: () => {
-            const integer2 = SUBRULE(numericLiteralPositive);
-            return ACTION(() => {
-              integer2.value = integer2.value.replace(/^\+/u, "");
-              return {
-                operator: "+",
-                startInt: integer2
-              };
-            });
-          } },
-          { ALT: () => {
-            const integer2 = SUBRULE(numericLiteralNegative);
-            return ACTION(() => {
-              integer2.value = integer2.value.replace(/^-/u, "");
-              return {
-                operator: "-",
-                startInt: integer2
-              };
-            });
-          } }
+  impl: ({ ACTION, SUBRULE, CONSUME, SUBRULE1, SUBRULE2, MANY1, MANY2, OR1, OR2, OR3, OR4 }) => (C) => constructLeftDeep(() => SUBRULE1(multiplicativeExpression), () => OR1([
+    { ALT: () => {
+      const operator = OR2([
+        { ALT: () => CONSUME(symbols_exports.opPlus) },
+        { ALT: () => CONSUME(symbols_exports.opMinus) }
+      ]);
+      const arg = SUBRULE2(multiplicativeExpression);
+      return ACTION(() => (left) => C.factory.expressionOperation(operator.image, [left, arg], C.factory.sourceLocation(left, arg)));
+    } },
+    { ALT: () => {
+      const { operator, startInt } = OR3([
+        { ALT: () => {
+          const integer2 = SUBRULE(numericLiteralPositive);
+          return ACTION(() => {
+            integer2.value = integer2.value.replace(/^\+/u, "");
+            return {
+              operator: "+",
+              startInt: integer2
+            };
+          });
+        } },
+        { ALT: () => {
+          const integer2 = SUBRULE(numericLiteralNegative);
+          return ACTION(() => {
+            integer2.value = integer2.value.replace(/^-/u, "");
+            return {
+              operator: "-",
+              startInt: integer2
+            };
+          });
+        } }
+      ]);
+      const multiplicativeExpr = constructLeftDeep(() => ACTION(() => startInt), () => {
+        const innerOperator = OR4([
+          { ALT: () => CONSUME(symbols_exports.star) },
+          { ALT: () => CONSUME(symbols_exports.slash) }
         ]);
-        const multiplicativeExpr = constructLeftDeep(
-          () => ACTION(() => startInt),
-          () => {
-            const innerOperator = OR4([
-              { ALT: () => CONSUME(symbols_exports.star) },
-              { ALT: () => CONSUME(symbols_exports.slash) }
-            ]);
-            const innerExpr = SUBRULE1(unaryExpression);
-            return ACTION(() => (leftInner) => C.factory.expressionOperation(
-              innerOperator.image,
-              [leftInner, innerExpr],
-              C.factory.sourceLocation(leftInner, innerExpr)
-            ));
-          },
-          ACTION,
-          MANY2
-        );
-        return (left) => C.factory.expressionOperation(
-          operator,
-          [left, multiplicativeExpr],
-          C.factory.sourceLocation(left, multiplicativeExpr)
-        );
-      } }
-    ]),
-    ACTION,
-    MANY1
-  )
+        const innerExpr = SUBRULE1(unaryExpression);
+        return ACTION(() => (leftInner) => C.factory.expressionOperation(innerOperator.image, [leftInner, innerExpr], C.factory.sourceLocation(leftInner, innerExpr)));
+      }, ACTION, MANY2);
+      return (left) => C.factory.expressionOperation(operator, [left, multiplicativeExpr], C.factory.sourceLocation(left, multiplicativeExpr));
+    } }
+  ]), ACTION, MANY1)
 };
 var multiplicativeExpression = {
   name: "multiplicativeExpression",
-  impl: ({ ACTION, CONSUME, MANY, SUBRULE1, SUBRULE2, OR }) => (C) => constructLeftDeep(
-    () => SUBRULE1(unaryExpression),
-    () => {
-      const operator = OR([
-        { ALT: () => CONSUME(symbols_exports.star) },
-        { ALT: () => CONSUME(symbols_exports.slash) }
-      ]);
-      const expr = SUBRULE2(unaryExpression);
-      return (left) => ({
-        type: "expression",
-        subType: "operation",
-        operator: operator.image,
-        args: [left, expr],
-        loc: C.factory.sourceLocation(left, expr)
-      });
-    },
-    ACTION,
-    MANY
-  )
+  impl: ({ ACTION, CONSUME, MANY, SUBRULE1, SUBRULE2, OR }) => (C) => constructLeftDeep(() => SUBRULE1(unaryExpression), () => {
+    const operator = OR([
+      { ALT: () => CONSUME(symbols_exports.star) },
+      { ALT: () => CONSUME(symbols_exports.slash) }
+    ]);
+    const expr = SUBRULE2(unaryExpression);
+    return (left) => ({
+      type: "expression",
+      subType: "operation",
+      operator: operator.image,
+      args: [left, expr],
+      loc: C.factory.sourceLocation(left, expr)
+    });
+  }, ACTION, MANY)
 };
 var unaryExpression = {
   name: "unaryExpression",
@@ -13552,11 +13241,7 @@ var unaryExpression = {
         { ALT: () => CONSUME(symbols_exports.opMinus) }
       ]);
       const expr = SUBRULE2(primaryExpression);
-      return ACTION(() => C.factory.expressionOperation(
-        operator.image === "!" ? "!" : operator.image === "+" ? "UPLUS" : "UMINUS",
-        [expr],
-        C.factory.sourceLocation(operator, expr)
-      ));
+      return ACTION(() => C.factory.expressionOperation(operator.image === "!" ? "!" : operator.image === "+" ? "UPLUS" : "UMINUS", [expr], C.factory.sourceLocation(operator, expr)));
     } }
   ])
 };
@@ -13617,7 +13302,7 @@ var iriOrFunction = {
   }
 };
 
-// ../../packages/rules-sparql-1-1/lib/grammar/solutionModifier.ts
+// ../../packages/rules-sparql-1-1/lib/grammar/solutionModifier.js
 var solutionModifier = {
   name: "solutionModifier",
   impl: ({ ACTION, SUBRULE, OPTION1, OPTION2, OPTION3, OPTION4 }) => () => {
@@ -13794,20 +13479,12 @@ var limitOffsetClauses = {
     { ALT: () => {
       const limit2 = SUBRULE1(limitClause);
       const offset2 = OPTION1(() => SUBRULE1(offsetClause));
-      return ACTION(() => C.factory.solutionModifierLimitOffset(
-        limit2.val,
-        offset2?.val,
-        C.factory.sourceLocation(limit2, ...offset2 ? [offset2] : [])
-      ));
+      return ACTION(() => C.factory.solutionModifierLimitOffset(limit2.val, offset2?.val, C.factory.sourceLocation(limit2, ...offset2 ? [offset2] : [])));
     } },
     { ALT: () => {
       const offset2 = SUBRULE2(offsetClause);
       const limit2 = OPTION2(() => SUBRULE2(limitClause));
-      return ACTION(() => C.factory.solutionModifierLimitOffset(
-        limit2?.val,
-        offset2.val,
-        C.factory.sourceLocation(offset2, limit2)
-      ));
+      return ACTION(() => C.factory.solutionModifierLimitOffset(limit2?.val, offset2.val, C.factory.sourceLocation(offset2, limit2)));
     } }
   ]),
   gImpl: ({ PRINT_WORDS }) => (ast, { factory: F2 }) => {
@@ -13840,7 +13517,7 @@ var offsetClause = {
   }
 };
 
-// ../../packages/rules-sparql-1-1/lib/grammar/queryUnit.ts
+// ../../packages/rules-sparql-1-1/lib/grammar/queryUnit.js
 var queryUnit = {
   name: "queryUnit",
   impl: ({ SUBRULE }) => () => SUBRULE(query)
@@ -13861,11 +13538,7 @@ var query = {
       ...subType,
       type: "query",
       ...values3 && { values: values3 },
-      loc: C.factory.sourceLocation(
-        prologueValues.at(0),
-        subType,
-        values3
-      )
+      loc: C.factory.sourceLocation(prologueValues.at(0), subType, values3)
     }));
   },
   gImpl: ({ SUBRULE }) => (ast, { factory: F2 }) => {
@@ -13898,14 +13571,7 @@ var selectQuery = {
         solutionModifiers: modifiers,
         datasets: from2,
         ...selectVal.val,
-        loc: C.factory.sourceLocation(
-          selectVal,
-          where2,
-          modifiers.group,
-          modifiers.having,
-          modifiers.order,
-          modifiers.limitOffset
-        )
+        loc: C.factory.sourceLocation(selectVal, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
       };
       queryIsGood(ret);
       return ret;
@@ -13936,30 +13602,12 @@ var subSelect = {
       solutionModifiers: modifiers,
       ...selectVal.val,
       ...values3 && { values: values3 }
-    }, C.factory.sourceLocation(
-      selectVal,
-      where2,
-      modifiers.group,
-      modifiers.having,
-      modifiers.order,
-      modifiers.limitOffset,
-      values3
-    )));
+    }, C.factory.sourceLocation(selectVal, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset, values3)));
   }
 };
 var selectClause = {
   name: "selectClause",
-  impl: ({
-    ACTION,
-    AT_LEAST_ONE,
-    SUBRULE1,
-    SUBRULE2,
-    CONSUME,
-    OPTION,
-    OR1,
-    OR2,
-    OR3
-  }) => (C) => {
+  impl: ({ ACTION, AT_LEAST_ONE, SUBRULE1, SUBRULE2, CONSUME, OPTION, OR1, OR2, OR3 }) => (C) => {
     const select2 = CONSUME(select);
     const couldParseAgg = ACTION(() => C.parseMode.has("canParseAggregate") || !C.parseMode.add("canParseAggregate"));
     const distinctAndReduced = OPTION(() => OR1([
@@ -14065,14 +13713,7 @@ var constructQuery = {
           datasets: from2,
           where: where2.val,
           solutionModifiers: modifiers,
-          loc: C.factory.sourceLocation(
-            construct2,
-            where2,
-            modifiers.group,
-            modifiers.having,
-            modifiers.order,
-            modifiers.limitOffset
-          )
+          loc: C.factory.sourceLocation(construct2, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
         }));
       } },
       { ALT: () => {
@@ -14086,14 +13727,7 @@ var constructQuery = {
           datasets: from2,
           where: C.factory.patternGroup([template.val], C.factory.sourceLocation()),
           solutionModifiers: modifiers,
-          loc: C.factory.sourceLocation(
-            construct2,
-            template,
-            modifiers.group,
-            modifiers.having,
-            modifiers.order,
-            modifiers.limitOffset
-          )
+          loc: C.factory.sourceLocation(construct2, template, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
         }));
       } }
     ]);
@@ -14140,16 +13774,7 @@ var describeQuery = {
       datasets: from2,
       ...where2 && { where: where2.val },
       solutionModifiers: modifiers,
-      loc: C.factory.sourceLocation(
-        describe2,
-        ...variables,
-        from2,
-        where2,
-        modifiers.group,
-        modifiers.having,
-        modifiers.order,
-        modifiers.limitOffset
-      )
+      loc: C.factory.sourceLocation(describe2, ...variables, from2, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
     }));
   },
   gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
@@ -14180,15 +13805,7 @@ var askQuery = {
       datasets: from2,
       where: where2.val,
       solutionModifiers: modifiers,
-      loc: C.factory.sourceLocation(
-        ask2,
-        from2,
-        where2,
-        modifiers.group,
-        modifiers.having,
-        modifiers.order,
-        modifiers.limitOffset
-      )
+      loc: C.factory.sourceLocation(ask2, from2, where2, modifiers.group, modifiers.having, modifiers.order, modifiers.limitOffset)
     }));
   },
   gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
@@ -14208,10 +13825,7 @@ var constructTemplate = {
     const open = CONSUME(symbols_exports.LCurly);
     const triples = OPTION(() => SUBRULE1(constructTriples));
     const close = CONSUME(symbols_exports.RCurly);
-    return ACTION(() => C.factory.wrap(
-      triples ?? C.factory.patternBgp([], C.factory.sourceLocation()),
-      C.factory.sourceLocation(open, close)
-    ));
+    return ACTION(() => C.factory.wrap(triples ?? C.factory.patternBgp([], C.factory.sourceLocation()), C.factory.sourceLocation(open, close)));
   }
 };
 var constructTriples = {
@@ -14219,7 +13833,7 @@ var constructTriples = {
   impl: triplesTemplate.impl
 };
 
-// ../../packages/rules-sparql-1-1/lib/grammar/updateUnit.ts
+// ../../packages/rules-sparql-1-1/lib/grammar/updateUnit.js
 var updateUnit = {
   name: "updateUnit",
   impl: ({ SUBRULE }) => () => SUBRULE(update)
@@ -14248,12 +13862,7 @@ var update = {
       const update2 = {
         type: "update",
         updates,
-        loc: C.factory.sourceLocation(
-          ...updates[0].context,
-          updates[0].operation,
-          ...updates.at(-1).context,
-          updates.at(-1)?.operation
-        )
+        loc: C.factory.sourceLocation(...updates[0].context, updates[0].operation, ...updates.at(-1).context, updates.at(-1)?.operation)
       };
       updateNoReuseBlankNodeLabels(update2);
       return update2;
@@ -14339,12 +13948,7 @@ var load2 = {
       CONSUME(loadInto);
       return SUBRULE1(graphRef);
     });
-    return ACTION(() => C.factory.updateOperationLoad(
-      C.factory.sourceLocation(loadToken, source, destination),
-      source,
-      Boolean(silent2),
-      destination
-    ));
+    return ACTION(() => C.factory.updateOperationLoad(C.factory.sourceLocation(loadToken, source, destination), source, Boolean(silent2), destination));
   },
   gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
     F2.printFilter(ast, () => {
@@ -14367,12 +13971,7 @@ function clearOrDrop(operation) {
       const opToken = CONSUME(operation);
       const silent2 = OPTION(() => CONSUME(silent));
       const destination = SUBRULE1(graphRefAll);
-      return ACTION(() => C.factory.updateOperationClearDrop(
-        unCapitalize(operation.name),
-        Boolean(silent2),
-        destination,
-        C.factory.sourceLocation(opToken, destination)
-      ));
+      return ACTION(() => C.factory.updateOperationClearDrop(unCapitalize(operation.name), Boolean(silent2), destination, C.factory.sourceLocation(opToken, destination)));
     },
     gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
       F2.printFilter(ast, () => {
@@ -14393,11 +13992,7 @@ var create2 = {
     const createToken3 = CONSUME(create);
     const silent2 = OPTION(() => CONSUME(silent));
     const destination = SUBRULE1(graphRef);
-    return ACTION(() => C.factory.updateOperationCreate(
-      destination,
-      Boolean(silent2),
-      C.factory.sourceLocation(createToken3, destination)
-    ));
+    return ACTION(() => C.factory.updateOperationCreate(destination, Boolean(silent2), C.factory.sourceLocation(createToken3, destination)));
   },
   gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
     F2.printFilter(ast, () => {
@@ -14418,13 +14013,7 @@ function copyMoveAddOperation(operation) {
       const source = SUBRULE1(graphOrDefault);
       CONSUME(to);
       const destination = SUBRULE2(graphOrDefault);
-      return ACTION(() => C.factory.updateOperationAddMoveCopy(
-        unCapitalize(operation.name),
-        source,
-        destination,
-        Boolean(silent2),
-        C.factory.sourceLocation(op, destination)
-      ));
+      return ACTION(() => C.factory.updateOperationAddMoveCopy(unCapitalize(operation.name), source, destination, Boolean(silent2), C.factory.sourceLocation(op, destination)));
     },
     gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
       F2.printFilter(ast, () => {
@@ -14479,10 +14068,7 @@ function insertDeleteDelWhere(name, subType, cons1, cons2, dataRule) {
       return ACTION(() => C.factory.updateOperationInsDelDataWhere(subType, data.val, C.factory.sourceLocation(insDelToken, data)));
     },
     gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
-      F2.printFilter(ast, () => PRINT_WORD(
-        subType === "insertdata" ? "INSERT DATA" : subType === "deletedata" ? "DELETE DATA" : "DELETE WHERE",
-        "{"
-      ));
+      F2.printFilter(ast, () => PRINT_WORD(subType === "insertdata" ? "INSERT DATA" : subType === "deletedata" ? "DELETE DATA" : "DELETE WHERE", "{"));
       SUBRULE(quads, F2.wrap(ast.data, ast.loc));
       F2.printFilter(ast, () => PRINT_WORD("}"));
     }
@@ -14513,14 +14099,7 @@ var modify = {
     const using = SUBRULE1(usingClauseStar);
     CONSUME(where);
     const where2 = SUBRULE1(groupGraphPattern);
-    return ACTION(() => C.factory.updateOperationModify(
-      C.factory.sourceLocation(graph2?.withToken, del, insert, where2),
-      insert?.val ?? [],
-      del?.val ?? [],
-      where2,
-      using,
-      graph2?.graph
-    ));
+    return ACTION(() => C.factory.updateOperationModify(C.factory.sourceLocation(graph2?.withToken, del, insert, where2), insert?.val ?? [], del?.val ?? [], where2, using, graph2?.graph));
   },
   gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
     if (ast.graph) {
@@ -14660,11 +14239,7 @@ var quadsNotTriples = {
     CONSUME(symbols_exports.LCurly);
     const triples = OPTION(() => SUBRULE1(triplesTemplate));
     const close = CONSUME(symbols_exports.RCurly);
-    return ACTION(() => C.factory.graphQuads(
-      name,
-      triples ?? C.factory.patternBgp([], C.factory.sourceLocationNoMaterialize()),
-      C.factory.sourceLocation(graph2, close)
-    ));
+    return ACTION(() => C.factory.graphQuads(name, triples ?? C.factory.patternBgp([], C.factory.sourceLocationNoMaterialize()), C.factory.sourceLocation(graph2, close)));
   },
   gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F2 }) => {
     F2.printFilter(ast, () => PRINT_WORD("GRAPH"));
@@ -14675,7 +14250,7 @@ var quadsNotTriples = {
   }
 };
 
-// ../../packages/rules-sparql-1-1/lib/grammar/index.ts
+// ../../packages/rules-sparql-1-1/lib/grammar/index.js
 var queryOrUpdate = {
   name: "queryOrUpdate",
   impl: ({ ACTION, SUBRULE, OR1, OR2, MANY, OPTION1, CONSUME, SUBRULE2 }) => (C) => {
@@ -14694,11 +14269,7 @@ var queryOrUpdate = {
           ...subType,
           type: "query",
           ...values3 && { values: values3 },
-          loc: C.factory.sourceLocation(
-            prologueValues.at(0),
-            subType,
-            values3
-          )
+          loc: C.factory.sourceLocation(prologueValues.at(0), subType, values3)
         }));
       } },
       { ALT: () => {
@@ -14722,12 +14293,7 @@ var queryOrUpdate = {
           const update2 = {
             type: "update",
             updates,
-            loc: C.factory.sourceLocation(
-              ...updates[0].context,
-              updates[0].operation,
-              ...updates.at(-1).context,
-              updates.at(-1)?.operation
-            )
+            loc: C.factory.sourceLocation(...updates[0].context, updates[0].operation, ...updates.at(-1).context, updates.at(-1)?.operation)
           };
           updateNoReuseBlankNodeLabels(update2);
           return update2;
@@ -14744,7 +14310,7 @@ var queryOrUpdate = {
   }
 };
 
-// ../../packages/rules-sparql-1-1/lib/MinimalSparqlParser.ts
+// ../../packages/rules-sparql-1-1/lib/MinimalSparqlParser.js
 function completeParseContext(context) {
   return {
     factory: context.factory ?? new Factory(),