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

package/lib/index.cjs

@@ -24,7 +24,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 };
@@ -151,8 +151,15 @@ var CoreFactory = class {
   }
 };
 
-// ../../packages/core/lib/generator-builder/dynamicGenerator.ts
+// ../../packages/core/lib/generator-builder/dynamicGenerator.js
 var DynamicGenerator = class {
+  rules;
+  factory = new CoreFactory();
+  __context = void 0;
+  origSource = "";
+  generatedUntil = 0;
+  expectsSpace;
+  stringBuilder = [];
   constructor(rules) {
     this.rules = rules;
     for (const rule of Object.values(rules)) {
@@ -168,12 +175,6 @@ var DynamicGenerator = class {
       });
     }
   }
-  factory = new CoreFactory();
-  __context = void 0;
-  origSource = "";
-  generatedUntil = 0;
-  expectsSpace;
-  stringBuilder = [];
   setContext(context) {
     this.__context = context;
   }
@@ -261,7 +262,7 @@ var DynamicGenerator = class {
   };
 };
 
-// ../../packages/core/lib/generator-builder/generatorBuilder.ts
+// ../../packages/core/lib/generator-builder/generatorBuilder.js
 function listToRuleDefMap(rules) {
   const newRules = {};
   for (const rule of rules) {
@@ -9569,7 +9570,7 @@ applyMixins(Parser, [
   PerformanceTracer
 ]);
 
-// ../../packages/core/lib/lexer-builder/LexerBuilder.ts
+// ../../packages/core/lib/lexer-builder/LexerBuilder.js
 var LexerBuilder = class _LexerBuilder {
   tokens;
   static create(starter) {
@@ -9666,7 +9667,7 @@ var LexerBuilder = class _LexerBuilder {
   }
 };
 
-// ../../packages/core/lib/utils.ts
+// ../../packages/core/lib/utils.js
 function unCapitalize(str2) {
   return str2.charAt(0).toLowerCase() + str2.slice(1);
 }
@@ -9674,7 +9675,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") {
@@ -9786,7 +9787,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,
@@ -10008,7 +10009,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,
@@ -10067,7 +10068,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,
@@ -10134,7 +10135,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";
@@ -10196,193 +10198,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,
@@ -10395,14 +10334,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,
@@ -10459,36 +10393,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,
@@ -10575,34 +10482,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" });
@@ -10651,59 +10533,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 {
@@ -10733,7 +10566,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 {
@@ -10813,7 +10646,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 {
@@ -10864,11 +10697,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;
   }
@@ -10881,7 +10715,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 {
@@ -10946,7 +10780,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 {
@@ -11044,7 +10878,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 {
@@ -11087,7 +10921,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 {
@@ -11142,7 +10976,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 {
@@ -11222,7 +11056,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 {
@@ -11347,7 +11181,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;
@@ -11432,11 +11266,23 @@ var Factory = class extends asArg(CoreFactory).call(ContextFactoryMixin).call(Ex
   }
 };
 
-// ../../packages/rules-sparql-1-1/lib/utils.ts
+// ../../packages/rules-sparql-1-1/lib/utils.js
+var CommonIRIs;
+(function(CommonIRIs2) {
+  CommonIRIs2["BOOLEAN"] = "http://www.w3.org/2001/XMLSchema#boolean";
+  CommonIRIs2["INTEGER"] = "http://www.w3.org/2001/XMLSchema#integer";
+  CommonIRIs2["DECIMAL"] = "http://www.w3.org/2001/XMLSchema#decimal";
+  CommonIRIs2["DOUBLE"] = "http://www.w3.org/2001/XMLSchema#double";
+  CommonIRIs2["STRING"] = "http://www.w3.org/2001/XMLSchema#string";
+  CommonIRIs2["FIRST"] = "http://www.w3.org/1999/02/22-rdf-syntax-ns#first";
+  CommonIRIs2["REST"] = "http://www.w3.org/1999/02/22-rdf-syntax-ns#rest";
+  CommonIRIs2["NIL"] = "http://www.w3.org/1999/02/22-rdf-syntax-ns#nil";
+  CommonIRIs2["TYPE"] = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type";
+})(CommonIRIs || (CommonIRIs = {}));
 var TransformerSparql11 = class extends TransformerSubType {
 };
 
-// ../../packages/rules-sparql-1-1/lib/validation/validators.ts
+// ../../packages/rules-sparql-1-1/lib/validation/validators.js
 var F = new Factory();
 var transformer = new TransformerSparql11();
 function getAggregatesOfExpression(expression2) {
@@ -11481,9 +11327,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) {
@@ -11628,7 +11472,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) {
@@ -11659,20 +11503,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;
   },
@@ -11700,45 +11536,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 = {
@@ -11748,11 +11572,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 = {
@@ -11864,11 +11684,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 }) => () => {
@@ -11968,7 +11788,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 }) => {
@@ -11982,7 +11802,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,
@@ -12019,10 +11839,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) {
@@ -12050,7 +11867,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),
@@ -12159,29 +11976,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);
@@ -12194,11 +11996,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)));
     }
   };
 }
@@ -12208,11 +12006,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)));
     }
   };
 }
@@ -12225,18 +12019,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);
@@ -12379,21 +12167,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));
     });
   }
 };
@@ -12418,13 +12194,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));
     });
   }
 };
@@ -12473,7 +12243,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)
@@ -12600,11 +12370,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));
         });
       } }
     ]);
@@ -12626,7 +12392,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 = [];
@@ -12685,10 +12451,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;
@@ -12699,10 +12462,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];
@@ -12743,11 +12503,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;
@@ -12815,18 +12571,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);
@@ -12875,11 +12627,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("["));
@@ -12923,7 +12671,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) => {
@@ -13164,17 +12912,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([
@@ -13259,10 +12997,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)) {
@@ -13303,16 +13038,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([
@@ -13444,29 +13174,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",
@@ -13487,11 +13207,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([
@@ -13499,11 +13215,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;
@@ -13515,89 +13227,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",
@@ -13610,13 +13299,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)));
     } }
   ])
 };
@@ -13677,7 +13360,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 }) => () => {
@@ -13854,20 +13537,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 }) => {
@@ -13900,7 +13575,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)
@@ -13921,11 +13596,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 }) => {
@@ -13958,14 +13629,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;
@@ -13996,30 +13660,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([
@@ -14125,14 +13771,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: () => {
@@ -14146,14 +13785,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)
         }));
       } }
     ]);
@@ -14200,16 +13832,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 }) => {
@@ -14240,15 +13863,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 }) => {
@@ -14268,10 +13883,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 = {
@@ -14279,7 +13891,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)
@@ -14308,12 +13920,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;
@@ -14399,12 +14006,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, () => {
@@ -14427,12 +14029,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, () => {
@@ -14453,11 +14050,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, () => {
@@ -14478,13 +14071,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, () => {
@@ -14539,10 +14126,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("}"));
     }
@@ -14573,14 +14157,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) {
@@ -14720,11 +14297,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"));
@@ -14735,7 +14308,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) => {
@@ -14754,11 +14327,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: () => {
@@ -14782,12 +14351,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;
@@ -14815,7 +14379,7 @@ var sparql11GeneratorBuilder = GeneratorBuilder.create([
   grammar_exports.selectClause
 ]).addMany(grammar_exports.update, grammar_exports.update1, grammar_exports.load, grammar_exports.clear, grammar_exports.drop, grammar_exports.create, grammar_exports.copy, grammar_exports.move, grammar_exports.add, grammar_exports.insertData, grammar_exports.deleteData, grammar_exports.deleteWhere, grammar_exports.modify, grammar_exports.graphRef, grammar_exports.graphRefAll, grammar_exports.quads, grammar_exports.quadsNotTriples).addRule(grammar_exports.aggregate).addMany(grammar_exports.datasetClauseStar, grammar_exports.usingClauseStar).addMany(grammar_exports.argList, grammar_exports.expression, grammar_exports.iriOrFunction).addMany(grammar_exports.prologue, grammar_exports.prefixDecl, grammar_exports.baseDecl, grammar_exports.varOrTerm, grammar_exports.var_, grammar_exports.graphTerm).addMany(grammar_exports.rdfLiteral, grammar_exports.iri, grammar_exports.iriFull, grammar_exports.prefixedName, grammar_exports.blankNode).addRule(grammar_exports.pathGenerator).addMany(grammar_exports.solutionModifier, grammar_exports.groupClause, grammar_exports.havingClause, grammar_exports.orderClause, grammar_exports.limitOffsetClauses).addMany(grammar_exports.triplesBlock, grammar_exports.collectionPath, grammar_exports.blankNodePropertyListPath, grammar_exports.triplesNodePath, grammar_exports.graphNodePath).addMany(grammar_exports.whereClause, grammar_exports.generatePattern, grammar_exports.groupGraphPattern, grammar_exports.graphPatternNotTriples, grammar_exports.optionalGraphPattern, grammar_exports.graphGraphPattern, grammar_exports.serviceGraphPattern, grammar_exports.bind, grammar_exports.inlineData, grammar_exports.minusGraphPattern, grammar_exports.groupOrUnionGraphPattern, grammar_exports.filter);
 
-// ../../packages/rules-sparql-1-2/lib/grammar.ts
+// ../../packages/rules-sparql-1-2/lib/grammar.js
 var grammar_exports2 = {};
 __export(grammar_exports2, {
   annotation: () => annotation,
@@ -14859,13 +14423,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 version = createToken2({ name: "Version", pattern: /version/i, label: "version identifier" });
 var tilde = createToken2({ name: "Tilde", pattern: "~", label: "~" });
 var annotationOpen = createToken2({ name: "AnnotationOpen", pattern: "{|", label: `Annotation Open: {|` });
@@ -14896,30 +14461,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";
@@ -14936,7 +14480,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) => {
@@ -14990,10 +14534,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]);
     }
   };
@@ -15016,10 +14557,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));
     });
   }
 };
@@ -15053,12 +14591,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);
       });
     }
   };
@@ -15085,10 +14618,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;
@@ -15117,16 +14647,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("{|"));
@@ -15179,7 +14702,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) }
   ])
@@ -15198,13 +14721,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 }) => {
@@ -15281,7 +14798,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);
@@ -15318,12 +14835,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 = {
@@ -15373,11 +14885,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;
         });
@@ -15385,15 +14893,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 }) => {
@@ -15435,7 +14958,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 {
@@ -15505,7 +15028,7 @@ var Factory2 = class extends Factory {
   }
 };
 
-// ../../packages/rules-sparql-1-2/lib/parserUtils.ts
+// ../../packages/rules-sparql-1-2/lib/parserUtils.js
 function completeParseContext2(context) {
   return {
     factory: context.factory ?? new Factory2(),