@traqula/parser-sparql-1-2 0.0.12 → 0.0.14

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 };
@@ -9370,7 +9370,7 @@ var EmbeddedActionsParser = class extends Parser {
   }
 };
 
-// ../../packages/core/lib/lexer-builder/LexerBuilder.ts
+// ../../packages/core/lib/lexer-builder/LexerBuilder.js
 var LexerBuilder = class _LexerBuilder {
   tokens;
   static create(starter) {
@@ -9467,7 +9467,7 @@ var LexerBuilder = class _LexerBuilder {
   }
 };
 
-// ../../packages/core/lib/parser-builder/dynamicParser.ts
+// ../../packages/core/lib/parser-builder/dynamicParser.js
 var DynamicParser = class extends EmbeddedActionsParser {
   context;
   setContext(context) {
@@ -9580,7 +9580,7 @@ var DynamicParser = class extends EmbeddedActionsParser {
   }
 };
 
-// ../../packages/core/lib/parser-builder/parserBuilder.ts
+// ../../packages/core/lib/parser-builder/parserBuilder.js
 function listToRuleDefMap(rules5) {
   const newRules = {};
   for (const rule of rules5) {
@@ -9694,13 +9694,7 @@ ${"-".repeat(columnIdx - 1)}^`);
 ${firstError.message}`);
     throw new Error(messageBuilder.join(""));
   }
-  build({
-    tokenVocabulary,
-    parserConfig = {},
-    lexerConfig = {},
-    queryPreProcessor = (s) => s,
-    errorHandler
-  }) {
+  build({ tokenVocabulary, parserConfig = {}, lexerConfig = {}, queryPreProcessor = (s) => s, errorHandler }) {
     const lexer = LexerBuilder.create().add(...tokenVocabulary).build({
       positionTracking: "full",
       recoveryEnabled: false,
@@ -9738,7 +9732,7 @@ ${firstError.message}`);
   }
 };
 
-// ../../packages/core/lib/utils.ts
+// ../../packages/core/lib/utils.js
 function unCapitalize(str2) {
   return str2.charAt(0).toLowerCase() + str2.slice(1);
 }
@@ -9746,7 +9740,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") {
@@ -9858,7 +9852,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,
@@ -10080,7 +10074,7 @@ __export(grammar_exports, {
   whereClause: () => whereClause
 });
 
-// ../../packages/rules-sparql-1-1/lib/lexer/index.ts
+// ../../packages/rules-sparql-1-1/lib/lexer/index.js
 var lexer_exports = {};
 __export(lexer_exports, {
   a: () => a,
@@ -10139,7 +10133,7 @@ __export(lexer_exports, {
   where: () => where
 });
 
-// ../../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,
@@ -10206,7 +10200,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";
@@ -10268,193 +10263,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,
@@ -10467,14 +10399,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,
@@ -10531,36 +10458,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,
@@ -10647,34 +10547,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" });
@@ -10723,59 +10598,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 {
@@ -10805,7 +10631,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 {
@@ -10885,7 +10711,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 {
@@ -10936,11 +10762,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;
   }
@@ -10953,7 +10780,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 {
@@ -11018,7 +10845,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 {
@@ -11116,7 +10943,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 {
@@ -11159,7 +10986,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 {
@@ -11214,7 +11041,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 {
@@ -11294,7 +11121,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 {
@@ -11419,7 +11246,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;
@@ -11504,32 +11331,41 @@ 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
 function sparqlCodepointEscape(input) {
-  const sanitizedInput = input.replaceAll(
-    /\\u([0-9a-fA-F]{4})|\\U([0-9a-fA-F]{8})/gu,
-    (_, unicode4, unicode8) => {
-      if (unicode4) {
-        const charCode2 = Number.parseInt(unicode4, 16);
-        return String.fromCodePoint(charCode2);
-      }
-      const charCode = Number.parseInt(unicode8, 16);
-      if (charCode < 65535) {
-        return String.fromCodePoint(charCode);
-      }
-      const substractedCharCode = charCode - 65536;
-      return String.fromCodePoint(55296 + (substractedCharCode >> 10), 56320 + (substractedCharCode & 1023));
+  const sanitizedInput = input.replaceAll(/\\u([0-9a-fA-F]{4})|\\U([0-9a-fA-F]{8})/gu, (_, unicode4, unicode8) => {
+    if (unicode4) {
+      const charCode2 = Number.parseInt(unicode4, 16);
+      return String.fromCodePoint(charCode2);
+    }
+    const charCode = Number.parseInt(unicode8, 16);
+    if (charCode < 65535) {
+      return String.fromCodePoint(charCode);
     }
-  );
+    const substractedCharCode = charCode - 65536;
+    return String.fromCodePoint(55296 + (substractedCharCode >> 10), 56320 + (substractedCharCode & 1023));
+  });
   if (/[\uD800-\uDBFF](?:[^\uDC00-\uDFFF]|$)/u.test(sanitizedInput)) {
     throw new Error(`Invalid unicode codepoint of surrogate pair without corresponding codepoint`);
   }
   return sanitizedInput;
 }
+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) {
@@ -11574,9 +11410,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) {
@@ -11721,7 +11555,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) {
@@ -11752,20 +11586,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;
   },
@@ -11793,45 +11619,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 = {
@@ -11841,11 +11655,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 = {
@@ -11957,11 +11767,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 }) => () => {
@@ -12061,7 +11871,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: F3 }) => {
@@ -12075,7 +11885,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,
@@ -12112,10 +11922,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: F3 }) => {
       for (const clause of ast.clauses) {
@@ -12143,7 +11950,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),
@@ -12252,29 +12059,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);
@@ -12287,11 +12079,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)));
     }
   };
 }
@@ -12301,11 +12089,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)));
     }
   };
 }
@@ -12318,18 +12102,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);
@@ -12472,21 +12250,9 @@ var aggregateCount = {
     return ACTION(() => {
       const F3 = C.factory;
       if (C.factory.isWildcard(expressionVal)) {
-        return F3.aggregate(
-          operatorToken.image,
-          Boolean(distinctToken),
-          expressionVal,
-          void 0,
-          C.factory.sourceLocation(operatorToken, closeToken)
-        );
-      }
-      return F3.aggregate(
-        operatorToken.image,
-        Boolean(distinctToken),
-        expressionVal,
-        void 0,
-        C.factory.sourceLocation(operatorToken, closeToken)
-      );
+        return F3.aggregate(operatorToken.image, Boolean(distinctToken), expressionVal, void 0, C.factory.sourceLocation(operatorToken, closeToken));
+      }
+      return F3.aggregate(operatorToken.image, Boolean(distinctToken), expressionVal, void 0, C.factory.sourceLocation(operatorToken, closeToken));
     });
   }
 };
@@ -12511,13 +12277,7 @@ var aggregateGroup_concat = {
     const closeToken = CONSUME(symbols_exports.RParen);
     return ACTION(() => {
       const F3 = C.factory;
-      return F3.aggregate(
-        operatorToken.image,
-        Boolean(distinctToken),
-        expr,
-        sep?.value ?? " ",
-        F3.sourceLocation(operatorToken, closeToken)
-      );
+      return F3.aggregate(operatorToken.image, Boolean(distinctToken), expr, sep?.value ?? " ", F3.sourceLocation(operatorToken, closeToken));
     });
   }
 };
@@ -12566,7 +12326,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)
@@ -12693,11 +12453,7 @@ var pathNegatedPropertySet = {
           if (tail.length === 0) {
             return F3.path("!", [head2], F3.sourceLocation(exclamation2, close));
           }
-          return F3.path(
-            "!",
-            [F3.path("|", [head2, ...tail], F3.sourceLocation(open, close))],
-            F3.sourceLocation(exclamation2, close)
-          );
+          return F3.path("!", [F3.path("|", [head2, ...tail], F3.sourceLocation(open, close))], F3.sourceLocation(exclamation2, close));
         });
       } }
     ]);
@@ -12719,7 +12475,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 = [];
@@ -12778,10 +12534,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;
@@ -12792,10 +12545,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];
@@ -12836,11 +12586,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;
@@ -12908,18 +12654,14 @@ function collectionImpl(name, allowPaths) {
       return ACTION(() => {
         const F3 = C.factory;
         const triples = [];
-        const predFirst = F3.namedNode(F3.sourceLocationNoMaterialize(), "http://www.w3.org/1999/02/22-rdf-syntax-ns#first" /* FIRST */, void 0);
-        const predRest = F3.namedNode(F3.sourceLocationNoMaterialize(), "http://www.w3.org/1999/02/22-rdf-syntax-ns#rest" /* REST */, void 0);
-        const predNil = F3.namedNode(F3.sourceLocationNoMaterialize(), "http://www.w3.org/1999/02/22-rdf-syntax-ns#nil" /* NIL */, void 0);
+        const predFirst = F3.namedNode(F3.sourceLocationNoMaterialize(), CommonIRIs.FIRST, void 0);
+        const predRest = F3.namedNode(F3.sourceLocationNoMaterialize(), CommonIRIs.REST, void 0);
+        const predNil = F3.namedNode(F3.sourceLocationNoMaterialize(), CommonIRIs.NIL, void 0);
         const listHead = F3.blankNode(void 0, F3.sourceLocationNoMaterialize());
         let iterHead = listHead;
         for (const [index, term] of terms.entries()) {
           const lastInList = index === terms.length - 1;
-          const headTriple = F3.triple(
-            iterHead,
-            predFirst,
-            term
-          );
+          const headTriple = F3.triple(iterHead, predFirst, term);
           triples.push(headTriple);
           if (lastInList) {
             const nilTriple = F3.triple(iterHead, predRest, predNil);
@@ -12968,11 +12710,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: F3 }) => {
       F3.printFilter(ast, () => PRINT("["));
@@ -13016,7 +12754,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) => {
@@ -13257,17 +12995,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([
@@ -13352,10 +13080,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: F3 }) => {
     if (F3.isPatternUnion(ast)) {
@@ -13396,16 +13121,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([
@@ -13537,29 +13257,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",
@@ -13580,11 +13290,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([
@@ -13592,11 +13298,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;
@@ -13608,89 +13310,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",
@@ -13703,13 +13382,7 @@ var unaryExpression = {
         { ALT: () => CONSUME(symbols_exports.opMinus) }
       ]);
       const expr = SUBRULE2(primaryExpression);
-      return ACTION(() => ({
-        type: "expression",
-        subType: "operation",
-        operator: operator.image === "!" ? "!" : operator.image === "+" ? "UPLUS" : "UMINUS",
-        args: [expr],
-        loc: C.factory.sourceLocation(operator, expr)
-      }));
+      return ACTION(() => C.factory.expressionOperation(operator.image === "!" ? "!" : operator.image === "+" ? "UPLUS" : "UMINUS", [expr], C.factory.sourceLocation(operator, expr)));
     } }
   ])
 };
@@ -13770,7 +13443,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 }) => () => {
@@ -13947,20 +13620,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: F3 }) => {
@@ -13993,7 +13658,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)
@@ -14014,11 +13679,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: F3 }) => {
@@ -14051,14 +13712,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;
@@ -14089,30 +13743,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([
@@ -14218,14 +13854,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: () => {
@@ -14239,14 +13868,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)
         }));
       } }
     ]);
@@ -14293,16 +13915,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: F3 }) => {
@@ -14333,15 +13946,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: F3 }) => {
@@ -14361,10 +13966,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 = {
@@ -14372,7 +13974,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)
@@ -14401,12 +14003,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;
@@ -14492,12 +14089,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: F3 }) => {
     F3.printFilter(ast, () => {
@@ -14520,12 +14112,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: F3 }) => {
       F3.printFilter(ast, () => {
@@ -14546,11 +14133,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: F3 }) => {
     F3.printFilter(ast, () => {
@@ -14571,13 +14154,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: F3 }) => {
       F3.printFilter(ast, () => {
@@ -14632,10 +14209,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: F3 }) => {
-      F3.printFilter(ast, () => PRINT_WORD(
-        subType === "insertdata" ? "INSERT DATA" : subType === "deletedata" ? "DELETE DATA" : "DELETE WHERE",
-        "{"
-      ));
+      F3.printFilter(ast, () => PRINT_WORD(subType === "insertdata" ? "INSERT DATA" : subType === "deletedata" ? "DELETE DATA" : "DELETE WHERE", "{"));
       SUBRULE(quads, F3.wrap(ast.data, ast.loc));
       F3.printFilter(ast, () => PRINT_WORD("}"));
     }
@@ -14666,14 +14240,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: F3 }) => {
     if (ast.graph) {
@@ -14813,11 +14380,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: F3 }) => {
     F3.printFilter(ast, () => PRINT_WORD("GRAPH"));
@@ -14828,7 +14391,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) => {
@@ -14847,11 +14410,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: () => {
@@ -14875,12 +14434,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;
@@ -14897,7 +14451,7 @@ var queryOrUpdate = {
   }
 };
 
-// ../parser-sparql-1-1/lib/expressionParser.ts
+// ../parser-sparql-1-1/lib/expressionParser.js
 var rulesNoBuiltIn = [
   grammar_exports.expression,
   grammar_exports.conditionalOrExpression,
@@ -14943,56 +14497,9 @@ var builtInPatch = {
   name: "builtInCall",
   impl: ({ OR, SUBRULE }) => () => OR(grammar_exports.builtInCallList(SUBRULE).slice(0, -2))
 };
-var expressionParserBuilder = ParserBuilder.create(rulesNoBuiltIn).addMany(
-  grammar_exports.builtInContains,
-  grammar_exports.builtInStrstarts,
-  grammar_exports.builtInStrends,
-  grammar_exports.builtInStrbefore,
-  grammar_exports.builtInStrafter,
-  grammar_exports.builtInYear,
-  grammar_exports.builtInMonth,
-  grammar_exports.builtInDay,
-  grammar_exports.builtInHours,
-  grammar_exports.builtInMinutes,
-  grammar_exports.builtInSeconds,
-  grammar_exports.builtInTimezone,
-  grammar_exports.builtInTz,
-  grammar_exports.builtInNow,
-  grammar_exports.builtInUuid,
-  grammar_exports.builtInStruuid,
-  grammar_exports.builtInMd5,
-  grammar_exports.builtInSha1,
-  grammar_exports.builtInSha256,
-  grammar_exports.builtInSha384,
-  grammar_exports.builtInSha512,
-  grammar_exports.builtInCoalesce,
-  grammar_exports.builtInIf,
-  grammar_exports.builtInStrlang,
-  grammar_exports.builtInStrdt,
-  grammar_exports.builtInSameterm,
-  grammar_exports.builtInIsiri,
-  grammar_exports.builtInIsuri,
-  grammar_exports.builtInIsblank,
-  grammar_exports.builtInIsliteral,
-  grammar_exports.builtInIsnumeric,
-  grammar_exports.regexExpression,
-  grammar_exports.substringExpression,
-  grammar_exports.strReplaceExpression,
-  grammar_exports.aggregateCount,
-  grammar_exports.aggregateSum,
-  grammar_exports.aggregateMin,
-  grammar_exports.aggregateMax,
-  grammar_exports.aggregateAvg,
-  grammar_exports.aggregateSample,
-  grammar_exports.aggregateGroup_concat,
-  grammar_exports.aggregate,
-  grammar_exports.iri,
-  grammar_exports.prefixedName,
-  grammar_exports.argList,
-  grammar_exports.string
-).addRule(builtInPatch);
+var expressionParserBuilder = ParserBuilder.create(rulesNoBuiltIn).addMany(grammar_exports.builtInContains, grammar_exports.builtInStrstarts, grammar_exports.builtInStrends, grammar_exports.builtInStrbefore, grammar_exports.builtInStrafter, grammar_exports.builtInYear, grammar_exports.builtInMonth, grammar_exports.builtInDay, grammar_exports.builtInHours, grammar_exports.builtInMinutes, grammar_exports.builtInSeconds, grammar_exports.builtInTimezone, grammar_exports.builtInTz, grammar_exports.builtInNow, grammar_exports.builtInUuid, grammar_exports.builtInStruuid, grammar_exports.builtInMd5, grammar_exports.builtInSha1, grammar_exports.builtInSha256, grammar_exports.builtInSha384, grammar_exports.builtInSha512, grammar_exports.builtInCoalesce, grammar_exports.builtInIf, grammar_exports.builtInStrlang, grammar_exports.builtInStrdt, grammar_exports.builtInSameterm, grammar_exports.builtInIsiri, grammar_exports.builtInIsuri, grammar_exports.builtInIsblank, grammar_exports.builtInIsliteral, grammar_exports.builtInIsnumeric, grammar_exports.regexExpression, grammar_exports.substringExpression, grammar_exports.strReplaceExpression, grammar_exports.aggregateCount, grammar_exports.aggregateSum, grammar_exports.aggregateMin, grammar_exports.aggregateMax, grammar_exports.aggregateAvg, grammar_exports.aggregateSample, grammar_exports.aggregateGroup_concat, grammar_exports.aggregate, grammar_exports.iri, grammar_exports.prefixedName, grammar_exports.argList, grammar_exports.string).addRule(builtInPatch);
 
-// ../parser-sparql-1-1/lib/objectListParser.ts
+// ../parser-sparql-1-1/lib/objectListParser.js
 var rules = [
   grammar_exports.objectList,
   grammar_exports.object,
@@ -15022,7 +14529,7 @@ var rules = [
 ];
 var objectListParserBuilder = ParserBuilder.create(rules);
 
-// ../parser-sparql-1-1/lib/triplesBlockParser.ts
+// ../parser-sparql-1-1/lib/triplesBlockParser.js
 var triplesBlockParserBuilder = ParserBuilder.create([
   grammar_exports.triplesBlock,
   grammar_exports.triplesSameSubjectPath,
@@ -15051,7 +14558,7 @@ var triplesBlockParserBuilder = ParserBuilder.create([
   grammar_exports.blankNodePropertyListPath
 );
 
-// ../parser-sparql-1-1/lib/subSelectParser.ts
+// ../parser-sparql-1-1/lib/subSelectParser.js
 var rules2 = [
   grammar_exports.subSelect,
   grammar_exports.selectClause,
@@ -15059,12 +14566,7 @@ var rules2 = [
   grammar_exports.solutionModifier,
   grammar_exports.valuesClause
 ];
-var subSelectParserBuilder = ParserBuilder.create(rules2).merge(expressionParserBuilder, []).patchRule(grammar_exports.builtInCall).addMany(
-  grammar_exports.existsFunc,
-  grammar_exports.notExistsFunc,
-  grammar_exports.groupGraphPattern,
-  grammar_exports.groupGraphPatternSub
-).merge(triplesBlockParserBuilder, []).addMany(
+var subSelectParserBuilder = ParserBuilder.create(rules2).merge(expressionParserBuilder, []).patchRule(grammar_exports.builtInCall).addMany(grammar_exports.existsFunc, grammar_exports.notExistsFunc, grammar_exports.groupGraphPattern, grammar_exports.groupGraphPatternSub).merge(triplesBlockParserBuilder, []).addMany(
   grammar_exports.graphPatternNotTriples,
   grammar_exports.groupOrUnionGraphPattern,
   grammar_exports.optionalGraphPattern,
@@ -15092,7 +14594,7 @@ var subSelectParserBuilder = ParserBuilder.create(rules2).merge(expressionParser
   grammar_exports.offsetClause
 );
 
-// ../parser-sparql-1-1/lib/triplesTemplateParserBuilder.ts
+// ../parser-sparql-1-1/lib/triplesTemplateParserBuilder.js
 var rules3 = [
   grammar_exports.triplesTemplate,
   grammar_exports.triplesSameSubject,
@@ -15124,7 +14626,7 @@ var rules3 = [
 ];
 var triplesTemplateParserBuilder = ParserBuilder.create(rules3);
 
-// ../parser-sparql-1-1/lib/queryUnitParser.ts
+// ../parser-sparql-1-1/lib/queryUnitParser.js
 var rules4 = [
   grammar_exports.queryUnit,
   grammar_exports.query,
@@ -15139,7 +14641,7 @@ var rules4 = [
 ];
 var queryUnitParserBuilder = ParserBuilder.create(rules4).merge(subSelectParserBuilder, []).addRule(grammar_exports.datasetClause).addRule(grammar_exports.datasetClauseStar).addRule(grammar_exports.defaultGraphClause).addRule(grammar_exports.namedGraphClause).addRule(grammar_exports.sourceSelector).addRule(grammar_exports.constructTemplate).merge(triplesTemplateParserBuilder, []).addRule(grammar_exports.constructTriples);
 
-// ../parser-sparql-1-1/lib/updateNoModifyParser.ts
+// ../parser-sparql-1-1/lib/updateNoModifyParser.js
 var update1Patch = {
   name: "update1",
   impl: ({ SUBRULE, OR }) => () => OR([
@@ -15183,23 +14685,13 @@ var rulesNoUpdate1 = [
 ];
 var updateNoModifyParserBuilder = ParserBuilder.create(rulesNoUpdate1).addRule(update1Patch).merge(triplesTemplateParserBuilder, []).addRule(grammar_exports.quadPattern).addRule(grammar_exports.quadsNotTriples);
 
-// ../parser-sparql-1-1/lib/updateUnitParser.ts
-var updateParserBuilder = ParserBuilder.create(updateNoModifyParserBuilder).patchRule(grammar_exports.update1).addMany(
-  grammar_exports.modify,
-  grammar_exports.deleteClause,
-  grammar_exports.insertClause,
-  grammar_exports.usingClause,
-  grammar_exports.defaultGraphClause,
-  grammar_exports.namedGraphClause,
-  grammar_exports.sourceSelector,
-  grammar_exports.usingClauseStar,
-  grammar_exports.groupGraphPattern
-).merge(objectListParserBuilder, []).merge(subSelectParserBuilder, []);
-
-// ../parser-sparql-1-1/lib/Parser.ts
+// ../parser-sparql-1-1/lib/updateUnitParser.js
+var updateParserBuilder = ParserBuilder.create(updateNoModifyParserBuilder).patchRule(grammar_exports.update1).addMany(grammar_exports.modify, grammar_exports.deleteClause, grammar_exports.insertClause, grammar_exports.usingClause, grammar_exports.defaultGraphClause, grammar_exports.namedGraphClause, grammar_exports.sourceSelector, grammar_exports.usingClauseStar, grammar_exports.groupGraphPattern).merge(objectListParserBuilder, []).merge(subSelectParserBuilder, []);
+
+// ../parser-sparql-1-1/lib/Parser.js
 var sparql11ParserBuilder = ParserBuilder.create(queryUnitParserBuilder).merge(updateParserBuilder, []).addRule(grammar_exports.queryOrUpdate);
 
-// ../../packages/rules-sparql-1-2/lib/grammar.ts
+// ../../packages/rules-sparql-1-2/lib/grammar.js
 var grammar_exports2 = {};
 __export(grammar_exports2, {
   annotation: () => annotation,
@@ -15243,13 +14735,14 @@ __export(grammar_exports2, {
   tripleTermSubject: () => tripleTermSubject,
   triplesSameSubject: () => triplesSameSubject2,
   triplesSameSubjectPath: () => triplesSameSubjectPath2,
+  unaryExpression: () => unaryExpression2,
   varOrReifierId: () => varOrReifierId,
   varOrTerm: () => varOrTerm2,
   versionDecl: () => versionDecl,
   versionSpecifier: () => versionSpecifier
 });
 
-// ../../packages/rules-sparql-1-2/lib/lexer.ts
+// ../../packages/rules-sparql-1-2/lib/lexer.js
 var lexer_exports2 = {};
 __export(lexer_exports2, {
   LANG_DIR: () => LANG_DIR,
@@ -15302,30 +14795,9 @@ var LANG_DIR = createToken2({
   pattern: /@[a-z]+(?:-[\da-z]+)*(?:--[a-z]+)?/i,
   label: "LANG_DIR"
 });
-var sparql12LexerBuilder = LexerBuilder.create(lexer_exports.sparql11LexerBuilder).addBefore(
-  lexer_exports.symbols.logicAnd,
-  tilde,
-  annotationOpen,
-  annotationClose,
-  tripleTermOpen,
-  tripleTermClose,
-  reificationOpen,
-  reificationClose,
-  version
-).addBefore(
-  lexer_exports.builtIn.langmatches,
-  buildInLangDir,
-  buildInStrLangDir,
-  buildInHasLangDir,
-  buildInHasLang,
-  buildInIsTRIPLE,
-  buildInTRIPLE,
-  buildInSUBJECT,
-  buildInPREDICATE,
-  buildInOBJECT
-).addBefore(lexer_exports.terminals.langTag, LANG_DIR).delete(lexer_exports.terminals.langTag);
-
-// ../../packages/rules-sparql-1-2/lib/validators.ts
+var sparql12LexerBuilder = LexerBuilder.create(lexer_exports.sparql11LexerBuilder).addBefore(lexer_exports.symbols.logicAnd, tilde, annotationOpen, annotationClose, tripleTermOpen, tripleTermClose, reificationOpen, reificationClose, version).addBefore(lexer_exports.builtIn.langmatches, buildInLangDir, buildInStrLangDir, buildInHasLangDir, buildInHasLang, buildInIsTRIPLE, buildInTRIPLE, buildInSUBJECT, buildInPREDICATE, buildInOBJECT).addBefore(lexer_exports.terminals.langTag, LANG_DIR).delete(lexer_exports.terminals.langTag);
+
+// ../../packages/rules-sparql-1-2/lib/validators.js
 var F2 = new Factory();
 function isLangDir(dir) {
   return dir === "ltr" || dir === "rtl";
@@ -15342,7 +14814,7 @@ function langTagHasCorrectRange(literal) {
   }
 }
 
-// ../../packages/rules-sparql-1-2/lib/grammar.ts
+// ../../packages/rules-sparql-1-2/lib/grammar.js
 var versionDecl = {
   name: "versionDecl",
   impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
@@ -15396,10 +14868,7 @@ function reifiedTripleBlockImpl(name, allowPath) {
     name,
     impl: ({ ACTION, SUBRULE }) => (C) => {
       const triple = SUBRULE(reifiedTriple);
-      const properties = SUBRULE(
-        allowPath ? grammar_exports.propertyListPath : grammar_exports.propertyList,
-        ACTION(() => C.factory.dematerialized(triple.identifier))
-      );
+      const properties = SUBRULE(allowPath ? grammar_exports.propertyListPath : grammar_exports.propertyList, ACTION(() => C.factory.dematerialized(triple.identifier)));
       return ACTION(() => [triple, ...properties]);
     }
   };
@@ -15422,10 +14891,7 @@ var reifier = {
       if (reifier2 === void 0 && !C.parseMode.has("canCreateBlankNodes")) {
         throw new Error("Cannot create blanknodes in current parse mode");
       }
-      return C.factory.wrap(
-        reifier2 ?? C.factory.blankNode(void 0, C.factory.sourceLocation()),
-        C.factory.sourceLocation(tildeToken, reifier2)
-      );
+      return C.factory.wrap(reifier2 ?? C.factory.blankNode(void 0, C.factory.sourceLocation()), C.factory.sourceLocation(tildeToken, reifier2));
     });
   }
 };
@@ -15459,12 +14925,7 @@ function objectImpl2(name, allowPaths) {
         if (F3.isPathPure(predicate) && annotationVal.length > 0) {
           throw new Error("Note 17 violation");
         }
-        return F3.annotatedTriple(
-          subject,
-          predicate,
-          objectVal,
-          annotationVal
-        );
+        return F3.annotatedTriple(subject, predicate, objectVal, annotationVal);
       });
     }
   };
@@ -15491,10 +14952,7 @@ function annotationImpl(name, allowPaths) {
               }
               currentReifier = currentReifier ?? C.factory.blankNode(void 0, C.factory.sourceLocation());
             });
-            const block = SUBRULE(
-              allowPaths ? annotationBlockPath : annotationBlock,
-              currentReifier
-            );
+            const block = SUBRULE(allowPaths ? annotationBlockPath : annotationBlock, currentReifier);
             ACTION(() => {
               annotations.push(block);
               currentReifier = void 0;
@@ -15523,16 +14981,9 @@ function annotationBlockImpl(name, allowPaths) {
     name,
     impl: ({ ACTION, SUBRULE, CONSUME }) => (C, arg) => {
       const open = CONSUME(annotationOpen);
-      const res = SUBRULE(
-        allowPaths ? grammar_exports.propertyListPathNotEmpty : grammar_exports.propertyListNotEmpty,
-        arg
-      );
+      const res = SUBRULE(allowPaths ? grammar_exports.propertyListPathNotEmpty : grammar_exports.propertyListNotEmpty, arg);
       const close = CONSUME(annotationClose);
-      return ACTION(() => C.factory.tripleCollectionBlankNodeProperties(
-        arg,
-        res,
-        C.factory.sourceLocation(open, close)
-      ));
+      return ACTION(() => C.factory.tripleCollectionBlankNodeProperties(arg, res, C.factory.sourceLocation(open, close)));
     },
     gImpl: ({ SUBRULE, PRINT_WORD, HANDLE_LOC }) => (ast, { factory: F3 }) => {
       F3.printFilter(ast, () => PRINT_WORD("{|"));
@@ -15585,7 +15036,7 @@ var varOrTerm2 = {
     { ALT: () => SUBRULE(grammar_exports.blankNode) },
     { ALT: () => {
       const token = CONSUME(lexer_exports.terminals.nil);
-      return ACTION(() => C.factory.namedNode(C.factory.sourceLocation(token), "http://www.w3.org/1999/02/22-rdf-syntax-ns#nil" /* NIL */));
+      return ACTION(() => C.factory.namedNode(C.factory.sourceLocation(token), CommonIRIs.NIL));
     } },
     { ALT: () => SUBRULE(tripleTerm) }
   ])
@@ -15604,13 +15055,7 @@ var reifiedTriple = {
       if (reifierVal === void 0 && !C.parseMode.has("canCreateBlankNodes")) {
         throw new Error("Cannot create blanknodes in current parse mode");
       }
-      return C.factory.tripleCollectionReifiedTriple(
-        C.factory.sourceLocation(open, close),
-        subject,
-        predicate,
-        object3,
-        reifierVal?.val
-      );
+      return C.factory.tripleCollectionReifiedTriple(C.factory.sourceLocation(open, close), subject, predicate, object3, reifierVal?.val);
     });
   },
   gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { factory: F3 }) => {
@@ -15687,7 +15132,7 @@ var tripleTermData = {
       { ALT: () => SUBRULE(grammar_exports.iri) },
       { ALT: () => {
         const token = CONSUME(lexer_exports.a);
-        return ACTION(() => C.factory.namedNode(C.factory.sourceLocation(token), "http://www.w3.org/1999/02/22-rdf-syntax-ns#type" /* TYPE */));
+        return ACTION(() => C.factory.namedNode(C.factory.sourceLocation(token), CommonIRIs.TYPE));
       } }
     ]);
     const object3 = SUBRULE(tripleTermDataObject);
@@ -15724,12 +15169,7 @@ var exprTripleTerm = {
     const predicate = SUBRULE(grammar_exports.verb);
     const object3 = SUBRULE(exprTripleTermObject);
     const close = CONSUME(tripleTermClose);
-    return ACTION(() => C.factory.termTriple(
-      subject,
-      predicate,
-      object3,
-      C.factory.sourceLocation(open, close)
-    ));
+    return ACTION(() => C.factory.termTriple(subject, predicate, object3, C.factory.sourceLocation(open, close)));
   }
 };
 var exprTripleTermSubject = {
@@ -15779,11 +15219,7 @@ var rdfLiteral2 = {
       { ALT: () => {
         const langTag2 = CONSUME(LANG_DIR);
         return ACTION(() => {
-          const literal = C.factory.literalTerm(
-            C.factory.sourceLocation(value, langTag2),
-            value.value,
-            langTag2.image.slice(1).toLowerCase()
-          );
+          const literal = C.factory.literalTerm(C.factory.sourceLocation(value, langTag2), value.value, langTag2.image.slice(1).toLowerCase());
           langTagHasCorrectRange(literal);
           return literal;
         });
@@ -15791,15 +15227,30 @@ var rdfLiteral2 = {
       { ALT: () => {
         CONSUME(lexer_exports.symbols.hathat);
         const iriVal = SUBRULE(grammar_exports.iri);
-        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;
   }
 };
+var unaryExpression2 = {
+  name: "unaryExpression",
+  impl: ({ ACTION, CONSUME, SUBRULE1, SUBRULE2, OR1, OR2 }) => (C) => OR1([
+    { ALT: () => SUBRULE1(primaryExpression2) },
+    { ALT: () => {
+      const operator = CONSUME(lexer_exports.symbols.exclamation);
+      const expr = SUBRULE1(unaryExpression2);
+      return ACTION(() => C.factory.expressionOperation("!", [expr], C.factory.sourceLocation(operator, expr)));
+    } },
+    { ALT: () => {
+      const operator = OR2([
+        { ALT: () => CONSUME(lexer_exports.symbols.opPlus) },
+        { ALT: () => CONSUME(lexer_exports.symbols.opMinus) }
+      ]);
+      const expr = SUBRULE2(primaryExpression2);
+      return ACTION(() => C.factory.expressionOperation(operator.image === "!" ? "!" : operator.image === "+" ? "UPLUS" : "UMINUS", [expr], C.factory.sourceLocation(operator, expr)));
+    } }
+  ])
+};
 var generateTriplesBlock = {
   name: "triplesBlock",
   gImpl: ({ SUBRULE, PRINT_WORD, HANDLE_LOC }) => (ast, { factory: F3 }) => {
@@ -15841,7 +15292,7 @@ var generateGraphTerm = {
   }
 };
 
-// ../../packages/rules-sparql-1-2/lib/Factory.ts
+// ../../packages/rules-sparql-1-2/lib/Factory.js
 var Factory2 = class extends Factory {
   termTriple(subject, predicate, object3, loc) {
     return {
@@ -15911,7 +15362,7 @@ var Factory2 = class extends Factory {
   }
 };
 
-// ../../packages/rules-sparql-1-2/lib/parserUtils.ts
+// ../../packages/rules-sparql-1-2/lib/parserUtils.js
 function completeParseContext(context) {
   return {
     factory: context.factory ?? new Factory2(),
@@ -15924,42 +15375,8 @@ function completeParseContext(context) {
   };
 }
 
-// lib/Parser.ts
-var sparql12ParserBuilder = ParserBuilder.create(sparql11ParserBuilder).widenContext().typePatch().addMany(
-  grammar_exports2.reifiedTripleBlock,
-  grammar_exports2.reifiedTripleBlockPath,
-  grammar_exports2.reifier,
-  grammar_exports2.varOrReifierId,
-  grammar_exports2.annotation,
-  grammar_exports2.annotationPath,
-  grammar_exports2.annotationBlockPath,
-  grammar_exports2.annotationBlock,
-  grammar_exports2.reifiedTriple,
-  grammar_exports2.reifiedTripleSubject,
-  grammar_exports2.reifiedTripleObject,
-  grammar_exports2.tripleTerm,
-  grammar_exports2.tripleTermSubject,
-  grammar_exports2.tripleTermObject,
-  grammar_exports2.tripleTermData,
-  grammar_exports2.tripleTermDataSubject,
-  grammar_exports2.tripleTermDataObject,
-  grammar_exports2.exprTripleTerm,
-  grammar_exports2.exprTripleTermSubject,
-  grammar_exports2.exprTripleTermObject
-).addMany(
-  grammar_exports2.versionDecl,
-  grammar_exports2.versionSpecifier
-).addMany(
-  grammar_exports2.buildInLangDir,
-  grammar_exports2.buildInLangStrDir,
-  grammar_exports2.buildInHasLang,
-  grammar_exports2.buildInHasLangDir,
-  grammar_exports2.buildInIsTriple,
-  grammar_exports2.buildInTriple,
-  grammar_exports2.buildInSubject,
-  grammar_exports2.buildInPredicate,
-  grammar_exports2.buildInObject
-).patchRule(grammar_exports2.dataBlockValue).patchRule(grammar_exports2.triplesSameSubject).patchRule(grammar_exports2.triplesSameSubjectPath).patchRule(grammar_exports2.object).patchRule(grammar_exports2.objectPath).patchRule(grammar_exports2.graphNode).patchRule(grammar_exports2.graphNodePath).patchRule(grammar_exports2.varOrTerm).deleteRule(grammar_exports.graphTerm.name).patchRule(grammar_exports2.primaryExpression).patchRule(grammar_exports2.builtInCall).patchRule(grammar_exports2.rdfLiteral).patchRule(grammar_exports2.prologue);
+// lib/Parser.js
+var sparql12ParserBuilder = ParserBuilder.create(sparql11ParserBuilder).widenContext().typePatch().addMany(grammar_exports2.reifiedTripleBlock, grammar_exports2.reifiedTripleBlockPath, grammar_exports2.reifier, grammar_exports2.varOrReifierId, grammar_exports2.annotation, grammar_exports2.annotationPath, grammar_exports2.annotationBlockPath, grammar_exports2.annotationBlock, grammar_exports2.reifiedTriple, grammar_exports2.reifiedTripleSubject, grammar_exports2.reifiedTripleObject, grammar_exports2.tripleTerm, grammar_exports2.tripleTermSubject, grammar_exports2.tripleTermObject, grammar_exports2.tripleTermData, grammar_exports2.tripleTermDataSubject, grammar_exports2.tripleTermDataObject, grammar_exports2.exprTripleTerm, grammar_exports2.exprTripleTermSubject, grammar_exports2.exprTripleTermObject).addMany(grammar_exports2.versionDecl, grammar_exports2.versionSpecifier).addMany(grammar_exports2.buildInLangDir, grammar_exports2.buildInLangStrDir, grammar_exports2.buildInHasLang, grammar_exports2.buildInHasLangDir, grammar_exports2.buildInIsTriple, grammar_exports2.buildInTriple, grammar_exports2.buildInSubject, grammar_exports2.buildInPredicate, grammar_exports2.buildInObject).patchRule(grammar_exports2.dataBlockValue).patchRule(grammar_exports2.triplesSameSubject).patchRule(grammar_exports2.triplesSameSubjectPath).patchRule(grammar_exports2.object).patchRule(grammar_exports2.objectPath).patchRule(grammar_exports2.graphNode).patchRule(grammar_exports2.graphNodePath).patchRule(grammar_exports2.varOrTerm).deleteRule(grammar_exports.graphTerm.name).patchRule(grammar_exports2.primaryExpression).patchRule(grammar_exports2.builtInCall).patchRule(grammar_exports2.rdfLiteral).patchRule(grammar_exports2.unaryExpression).patchRule(grammar_exports2.prologue);
 var Parser2 = class {
   parser;
   F = new Factory2();