@traqula/rules-sparql-1-1 0.0.21 → 0.0.23

package/dist/cjs/lib/lexer/BuiltInCalls.js

@@ -0,0 +1,337 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var BuiltInCalls_exports = {};
+__export(BuiltInCalls_exports, {
+  BuiltInCalls: () => BuiltInCalls,
+  abs: () => abs,
+  allBuiltInCalls: () => allBuiltInCalls,
+  avg: () => avg,
+  bnode: () => bnode,
+  bound: () => bound,
+  ceil: () => ceil,
+  coalesce: () => coalesce,
+  concat: () => concat,
+  contains: () => contains,
+  count: () => count,
+  datatype: () => datatype,
+  day: () => day,
+  encode_for_uri: () => encode_for_uri,
+  exists: () => exists,
+  floor: () => floor,
+  groupConcat: () => groupConcat,
+  hours: () => hours,
+  if_: () => if_,
+  iri: () => iri,
+  isblank: () => isblank,
+  isiri: () => isiri,
+  isliteral: () => isliteral,
+  isnumeric: () => isnumeric,
+  isuri: () => isuri,
+  lang: () => lang,
+  langmatches: () => langmatches,
+  lcase: () => lcase,
+  max: () => max,
+  md5: () => md5,
+  min: () => min,
+  minutes: () => minutes,
+  month: () => month,
+  notexists: () => notexists,
+  now: () => now,
+  rand: () => rand,
+  regex: () => regex,
+  replace: () => replace,
+  round: () => round,
+  sameterm: () => sameterm,
+  sample: () => sample,
+  seconds: () => seconds,
+  sha1: () => sha1,
+  sha256: () => sha256,
+  sha384: () => sha384,
+  sha512: () => sha512,
+  str: () => str,
+  strafter: () => strafter,
+  strbefore: () => strbefore,
+  strdt: () => strdt,
+  strends: () => strends,
+  strlang: () => strlang,
+  strlen: () => strlen,
+  strstarts: () => strstarts,
+  struuid: () => struuid,
+  substr: () => substr,
+  sum: () => sum,
+  timezone: () => timezone,
+  tz: () => tz,
+  ucase: () => ucase,
+  uri: () => uri,
+  uuid: () => uuid,
+  year: () => year
+});
+module.exports = __toCommonJS(BuiltInCalls_exports);
+var import_core = require("@traqula/core");
+var BuiltInCalls;
+(function(BuiltInCalls2) {
+  BuiltInCalls2["Str"] = "builtInStr";
+  BuiltInCalls2["Lang"] = "builtInLang";
+  BuiltInCalls2["Langmatches"] = "builtInLangmatches";
+  BuiltInCalls2["Datatype"] = "builtInDatatype";
+  BuiltInCalls2["Bound"] = "builtInBound";
+  BuiltInCalls2["Iri"] = "builtInIri";
+  BuiltInCalls2["Uri"] = "builtInUri";
+  BuiltInCalls2["Bnode"] = "builtInBnode";
+  BuiltInCalls2["Rand"] = "builtInRand";
+  BuiltInCalls2["Abs"] = "builtInAbs";
+  BuiltInCalls2["Ceil"] = "builtInCeil";
+  BuiltInCalls2["Floor"] = "builtInFloor";
+  BuiltInCalls2["Round"] = "builtInRound";
+  BuiltInCalls2["Concat"] = "builtInConcat";
+  BuiltInCalls2["Strlen"] = "builtInStrlen";
+  BuiltInCalls2["Ucase"] = "builtInUcase";
+  BuiltInCalls2["Lcase"] = "builtInLcase";
+  BuiltInCalls2["Encode_for_uri"] = "builtInEncode_for_uri";
+  BuiltInCalls2["Contains"] = "builtInContains";
+  BuiltInCalls2["Strstarts"] = "builtInStrstarts";
+  BuiltInCalls2["Strends"] = "builtInStrends";
+  BuiltInCalls2["Strbefore"] = "builtInStrbefore";
+  BuiltInCalls2["Strafter"] = "builtInStrafter";
+  BuiltInCalls2["Year"] = "builtInYear";
+  BuiltInCalls2["Month"] = "builtInMonth";
+  BuiltInCalls2["Day"] = "builtInDay";
+  BuiltInCalls2["Hours"] = "builtInHours";
+  BuiltInCalls2["Minutes"] = "builtInMinutes";
+  BuiltInCalls2["Seconds"] = "builtInSeconds";
+  BuiltInCalls2["Timezone"] = "builtInTimezone";
+  BuiltInCalls2["Tz"] = "builtInTz";
+  BuiltInCalls2["Now"] = "builtInNow";
+  BuiltInCalls2["Uuid"] = "builtInUuid";
+  BuiltInCalls2["Struuid"] = "builtInStruuid";
+  BuiltInCalls2["Md5"] = "builtInMd5";
+  BuiltInCalls2["Sha1"] = "builtInSha1";
+  BuiltInCalls2["Sha256"] = "builtInSha256";
+  BuiltInCalls2["Sha384"] = "builtInSha384";
+  BuiltInCalls2["Sha512"] = "builtInSha512";
+  BuiltInCalls2["Coalesce"] = "builtInCoalesce";
+  BuiltInCalls2["If"] = "builtInIf";
+  BuiltInCalls2["Strlang"] = "builtInStrlang";
+  BuiltInCalls2["Strdt"] = "builtInStrdt";
+  BuiltInCalls2["Sameterm"] = "builtInSameterm";
+  BuiltInCalls2["Isiri"] = "builtInIsiri";
+  BuiltInCalls2["Isuri"] = "builtInIsuri";
+  BuiltInCalls2["Isblank"] = "builtInIsblank";
+  BuiltInCalls2["Isliteral"] = "builtInIsliteral";
+  BuiltInCalls2["Isnumeric"] = "builtInIsnumeric";
+  BuiltInCalls2["Regex"] = "builtInRegex";
+  BuiltInCalls2["Substr"] = "builtInSubstr";
+  BuiltInCalls2["Replace"] = "builtInReplace";
+  BuiltInCalls2["Exists"] = "builtInExists";
+  BuiltInCalls2["Notexists"] = "builtInNotexists";
+  BuiltInCalls2["Count"] = "builtInCount";
+  BuiltInCalls2["Sum"] = "builtInSum";
+  BuiltInCalls2["Min"] = "builtInMin";
+  BuiltInCalls2["Max"] = "builtInMax";
+  BuiltInCalls2["Avg"] = "builtInAvg";
+  BuiltInCalls2["Sample"] = "builtInSample";
+  BuiltInCalls2["Group_concat"] = "builtInGroup_concat";
+})(BuiltInCalls || (BuiltInCalls = {}));
+function capitalize(string) {
+  return string.charAt(0).toUpperCase() + string.slice(1);
+}
+const str = (0, import_core.createToken)({ name: capitalize(BuiltInCalls.Str), pattern: /str/i, label: "STR" });
+const lang = (0, import_core.createToken)({ name: capitalize(BuiltInCalls.Lang), pattern: /lang/i, label: "LANG" });
+const langmatches = (0, import_core.createToken)({
+  name: capitalize(BuiltInCalls.Langmatches),
+  pattern: /langmatches/i,
+  label: "LANGMATCHES"
+});
+const datatype = (0, import_core.createToken)({
+  name: capitalize(BuiltInCalls.Datatype),
+  pattern: /datatype/i,
+  label: "DATATYPE"
+});
+const bound = (0, import_core.createToken)({ name: capitalize(BuiltInCalls.Bound), pattern: /bound/i, label: "BOUND" });
+const iri = (0, import_core.createToken)({ name: capitalize(BuiltInCalls.Iri), pattern: /iri/i, label: "IRI" });
+const uri = (0, import_core.createToken)({ name: capitalize(BuiltInCalls.Uri), pattern: /uri/i, label: "URI" });
+const bnode = (0, import_core.createToken)({ name: capitalize(BuiltInCalls.Bnode), pattern: /bnode/i, label: "BNODE" });
+const rand = (0, import_core.createToken)({ name: capitalize(BuiltInCalls.Rand), pattern: /rand/i, label: "RAND" });
+const abs = (0, import_core.createToken)({ name: capitalize(BuiltInCalls.Abs), pattern: /abs/i, label: "ABS" });
+const ceil = (0, import_core.createToken)({ name: capitalize(BuiltInCalls.Ceil), pattern: /ceil/i, label: "CEIL" });
+const floor = (0, import_core.createToken)({ name: capitalize(BuiltInCalls.Floor), pattern: /floor/i, label: "FLOOR" });
+const round = (0, import_core.createToken)({ name: capitalize(BuiltInCalls.Round), pattern: /round/i, label: "ROUND" });
+const concat = (0, import_core.createToken)({ name: capitalize(BuiltInCalls.Concat), pattern: /concat/i, label: "CONCAT" });
+const strlen = (0, import_core.createToken)({ name: capitalize(BuiltInCalls.Strlen), pattern: /strlen/i, label: "STRLEN" });
+const ucase = (0, import_core.createToken)({ name: capitalize(BuiltInCalls.Ucase), pattern: /ucase/i, label: "UCASE" });
+const lcase = (0, import_core.createToken)({ name: capitalize(BuiltInCalls.Lcase), pattern: /lcase/i, label: "LCASE" });
+const encode_for_uri = (0, import_core.createToken)({
+  name: capitalize(BuiltInCalls.Encode_for_uri),
+  pattern: /encode_for_uri/i,
+  label: "ENCODE_FOR_URI"
+});
+const contains = (0, import_core.createToken)({
+  name: capitalize(BuiltInCalls.Contains),
+  pattern: /contains/i,
+  label: "CONTAINS"
+});
+const strstarts = (0, import_core.createToken)({
+  name: capitalize(BuiltInCalls.Strstarts),
+  pattern: /strstarts/i,
+  label: "STRSTARTS"
+});
+const strends = (0, import_core.createToken)({ name: capitalize(BuiltInCalls.Strends), pattern: /strends/i, label: "STRENDS" });
+const strbefore = (0, import_core.createToken)({
+  name: capitalize(BuiltInCalls.Strbefore),
+  pattern: /strbefore/i,
+  label: "STRBEFORE"
+});
+const strafter = (0, import_core.createToken)({
+  name: capitalize(BuiltInCalls.Strafter),
+  pattern: /strafter/i,
+  label: "STRAFTER"
+});
+const year = (0, import_core.createToken)({ name: capitalize(BuiltInCalls.Year), pattern: /year/i, label: "YEAR" });
+const month = (0, import_core.createToken)({ name: capitalize(BuiltInCalls.Month), pattern: /month/i, label: "MONTH" });
+const day = (0, import_core.createToken)({ name: capitalize(BuiltInCalls.Day), pattern: /day/i, label: "DAY" });
+const hours = (0, import_core.createToken)({ name: capitalize(BuiltInCalls.Hours), pattern: /hours/i, label: "HOURS" });
+const minutes = (0, import_core.createToken)({ name: capitalize(BuiltInCalls.Minutes), pattern: /minutes/i, label: "MINUTES" });
+const seconds = (0, import_core.createToken)({ name: capitalize(BuiltInCalls.Seconds), pattern: /seconds/i, label: "SECONDS" });
+const timezone = (0, import_core.createToken)({
+  name: capitalize(BuiltInCalls.Timezone),
+  pattern: /timezone/i,
+  label: "TIMEZONE"
+});
+const tz = (0, import_core.createToken)({ name: capitalize(BuiltInCalls.Tz), pattern: /tz/i, label: "TZ" });
+const now = (0, import_core.createToken)({ name: capitalize(BuiltInCalls.Now), pattern: /now/i, label: "NOW" });
+const uuid = (0, import_core.createToken)({ name: capitalize(BuiltInCalls.Uuid), pattern: /uuid/i, label: "UUID" });
+const struuid = (0, import_core.createToken)({ name: capitalize(BuiltInCalls.Struuid), pattern: /struuid/i, label: "STRUUID" });
+const md5 = (0, import_core.createToken)({ name: capitalize(BuiltInCalls.Md5), pattern: /md5/i, label: "MD5" });
+const sha1 = (0, import_core.createToken)({ name: capitalize(BuiltInCalls.Sha1), pattern: /sha1/i, label: "SHA1" });
+const sha256 = (0, import_core.createToken)({ name: capitalize(BuiltInCalls.Sha256), pattern: /sha256/i, label: "SHA256" });
+const sha384 = (0, import_core.createToken)({ name: capitalize(BuiltInCalls.Sha384), pattern: /sha384/i, label: "SHA384" });
+const sha512 = (0, import_core.createToken)({ name: capitalize(BuiltInCalls.Sha512), pattern: /sha512/i, label: "SHA512" });
+const coalesce = (0, import_core.createToken)({
+  name: capitalize(BuiltInCalls.Coalesce),
+  pattern: /coalesce/i,
+  label: "COALESCE"
+});
+const if_ = (0, import_core.createToken)({ name: capitalize(BuiltInCalls.If), pattern: /if/i, label: "IF" });
+const strlang = (0, import_core.createToken)({ name: capitalize(BuiltInCalls.Strlang), pattern: /strlang/i, label: "STRLANG" });
+const strdt = (0, import_core.createToken)({ name: capitalize(BuiltInCalls.Strdt), pattern: /strdt/i, label: "STRDT" });
+const sameterm = (0, import_core.createToken)({
+  name: capitalize(BuiltInCalls.Sameterm),
+  pattern: /sameterm/i,
+  label: "SAMETERM"
+});
+const isiri = (0, import_core.createToken)({ name: capitalize(BuiltInCalls.Isiri), pattern: /isiri/i, label: "ISIRI" });
+const isuri = (0, import_core.createToken)({ name: capitalize(BuiltInCalls.Isuri), pattern: /isuri/i, label: "ISURI" });
+const isblank = (0, import_core.createToken)({ name: capitalize(BuiltInCalls.Isblank), pattern: /isblank/i, label: "ISBLANK" });
+const isliteral = (0, import_core.createToken)({
+  name: capitalize(BuiltInCalls.Isliteral),
+  pattern: /isliteral/i,
+  label: "ISLITERAL"
+});
+const isnumeric = (0, import_core.createToken)({
+  name: capitalize(BuiltInCalls.Isnumeric),
+  pattern: /isnumeric/i,
+  label: "ISNUMERIC"
+});
+const regex = (0, import_core.createToken)({ name: capitalize(BuiltInCalls.Regex), pattern: /regex/i, label: "REGEX" });
+const substr = (0, import_core.createToken)({ name: capitalize(BuiltInCalls.Substr), pattern: /substr/i, label: "SUBSTR" });
+const replace = (0, import_core.createToken)({ name: capitalize(BuiltInCalls.Replace), pattern: /replace/i, label: "REPLACE" });
+const exists = (0, import_core.createToken)({ name: capitalize(BuiltInCalls.Exists), pattern: /exists/i, label: "EXISTS" });
+const notexists = (0, import_core.createToken)({
+  name: capitalize(BuiltInCalls.Notexists),
+  pattern: /not exists/i,
+  label: "NOT EXISTS"
+});
+const count = (0, import_core.createToken)({ name: capitalize(BuiltInCalls.Count), pattern: /count/i, label: "COUNT" });
+const sum = (0, import_core.createToken)({ name: capitalize(BuiltInCalls.Sum), pattern: /sum/i, label: "SUM" });
+const min = (0, import_core.createToken)({ name: capitalize(BuiltInCalls.Min), pattern: /min/i, label: "MIN" });
+const max = (0, import_core.createToken)({ name: capitalize(BuiltInCalls.Max), pattern: /max/i, label: "MAX" });
+const avg = (0, import_core.createToken)({ name: capitalize(BuiltInCalls.Avg), pattern: /avg/i, label: "AVG" });
+const sample = (0, import_core.createToken)({ name: capitalize(BuiltInCalls.Sample), pattern: /sample/i, label: "SAMPLE" });
+const groupConcat = (0, import_core.createToken)({
+  name: capitalize(BuiltInCalls.Group_concat),
+  pattern: /group_concat/i,
+  label: "GROUP_CONCAT"
+});
+const allBuiltInCalls = import_core.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);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BuiltInCalls,
+  abs,
+  allBuiltInCalls,
+  avg,
+  bnode,
+  bound,
+  ceil,
+  coalesce,
+  concat,
+  contains,
+  count,
+  datatype,
+  day,
+  encode_for_uri,
+  exists,
+  floor,
+  groupConcat,
+  hours,
+  if_,
+  iri,
+  isblank,
+  isiri,
+  isliteral,
+  isnumeric,
+  isuri,
+  lang,
+  langmatches,
+  lcase,
+  max,
+  md5,
+  min,
+  minutes,
+  month,
+  notexists,
+  now,
+  rand,
+  regex,
+  replace,
+  round,
+  sameterm,
+  sample,
+  seconds,
+  sha1,
+  sha256,
+  sha384,
+  sha512,
+  str,
+  strafter,
+  strbefore,
+  strdt,
+  strends,
+  strlang,
+  strlen,
+  strstarts,
+  struuid,
+  substr,
+  sum,
+  timezone,
+  tz,
+  ucase,
+  uri,
+  uuid,
+  year
+});

package/dist/cjs/lib/lexer/graph.js

@@ -0,0 +1,41 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var graph_exports = {};
+__export(graph_exports, {
+  allGraphTokens: () => allGraphTokens,
+  default_: () => default_,
+  graph: () => graph,
+  graphAll: () => graphAll,
+  named: () => named
+});
+module.exports = __toCommonJS(graph_exports);
+var import_core = require("@traqula/core");
+const named = (0, import_core.createToken)({ name: "NamedGraph", pattern: /named/i, label: "NAMED" });
+const default_ = (0, import_core.createToken)({ name: "DefaultGraph", pattern: /default/i, label: "DEFAULT" });
+const graph = (0, import_core.createToken)({ name: "Graph", pattern: /graph/i, label: "GRAPH" });
+const graphAll = (0, import_core.createToken)({ name: "GraphAll", pattern: /all/i, label: "ALL" });
+const allGraphTokens = import_core.LexerBuilder.create().add(named, default_, graph, graphAll);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  allGraphTokens,
+  default_,
+  graph,
+  graphAll,
+  named
+});

package/dist/cjs/lib/lexer/index.js

@@ -0,0 +1,50 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var lexer_exports = {};
+__export(lexer_exports, {
+  builtIn: () => builtIn,
+  graph: () => graph,
+  symbols: () => symbols,
+  terminals: () => terminals
+});
+module.exports = __toCommonJS(lexer_exports);
+var builtIn = __toESM(require("./BuiltInCalls.js"), 1);
+var graph = __toESM(require("./graph.js"), 1);
+__reExport(lexer_exports, require("./lexer.js"), module.exports);
+var symbols = __toESM(require("./symbols.js"), 1);
+var terminals = __toESM(require("./terminals.js"), 1);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  builtIn,
+  graph,
+  symbols,
+  terminals,
+  ...require("./lexer.js")
+});

package/dist/cjs/lib/lexer/lexer.js

@@ -0,0 +1,199 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to2, from2, except, desc) => {
+  if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+    for (let key of __getOwnPropNames(from2))
+      if (!__hasOwnProp.call(to2, key) && key !== except)
+        __defProp(to2, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
+  }
+  return to2;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var lexer_exports = {};
+__export(lexer_exports, {
+  a: () => a,
+  add: () => add,
+  allBaseTokens: () => allBaseTokens,
+  as: () => as,
+  ask: () => ask,
+  baseDecl: () => baseDecl,
+  bind: () => bind,
+  by: () => by,
+  clear: () => clear,
+  construct: () => construct,
+  copy: () => copy,
+  create: () => create,
+  deleteClause: () => deleteClause,
+  deleteDataClause: () => deleteDataClause,
+  deleteWhereClause: () => deleteWhereClause,
+  describe: () => describe,
+  distinct: () => distinct,
+  drop: () => drop,
+  false_: () => false_,
+  filter: () => filter,
+  from: () => from,
+  groupByGroup: () => groupByGroup,
+  having: () => having,
+  in_: () => in_,
+  insertClause: () => insertClause,
+  insertDataClause: () => insertDataClause,
+  limit: () => limit,
+  load: () => load,
+  loadInto: () => loadInto,
+  minus: () => minus,
+  modifyWith: () => modifyWith,
+  move: () => move,
+  notIn: () => notIn,
+  offset: () => offset,
+  optional: () => optional,
+  order: () => order,
+  orderAsc: () => orderAsc,
+  orderDesc: () => orderDesc,
+  prefixDecl: () => prefixDecl,
+  reduced: () => reduced,
+  select: () => select,
+  separator: () => separator,
+  service: () => service,
+  silent: () => silent,
+  sparql11LexerBuilder: () => sparql11LexerBuilder,
+  to: () => to,
+  true_: () => true_,
+  undef: () => undef,
+  union: () => union,
+  usingClause: () => usingClause,
+  values: () => values,
+  where: () => where
+});
+module.exports = __toCommonJS(lexer_exports);
+var import_core = require("@traqula/core");
+var import_BuiltInCalls = require("./BuiltInCalls.js");
+var import_graph = require("./graph.js");
+var import_lexerPatterns = require("./lexerPatterns.js");
+var import_symbols = require("./symbols.js");
+var import_terminals = require("./terminals.js");
+const baseDecl = (0, import_core.createToken)({ name: "BaseDecl", pattern: /base/i, label: "BASE" });
+const prefixDecl = (0, import_core.createToken)({ name: "PrefixDecl", pattern: /prefix/i, label: "PREFIX" });
+const select = (0, import_core.createToken)({ name: "Select", pattern: /select/i, label: "SELECT" });
+const distinct = (0, import_core.createToken)({ name: "Distinct", pattern: /distinct/i, label: "DISTINCT" });
+const reduced = (0, import_core.createToken)({ name: "Reduced", pattern: /reduced/i, label: "REDUCED" });
+const as = (0, import_core.createToken)({ name: "As", pattern: /as/i, label: "AS" });
+const construct = (0, import_core.createToken)({ name: "Construct", pattern: /construct/i, label: "CONSTRUCT" });
+const describe = (0, import_core.createToken)({ name: "Describe", pattern: /describe/i, label: "DESCRIBE" });
+const ask = (0, import_core.createToken)({ name: "Ask", pattern: /ask/i, label: "ASK" });
+const from = (0, import_core.createToken)({ name: "From", pattern: /from/i, label: "FROM" });
+const where = (0, import_core.createToken)({ name: "Where", pattern: /where/i, label: "WHERE" });
+const groupByGroup = (0, import_core.createToken)({ name: "GroupByGroup", pattern: /group/i, label: "_GROUP_ BY" });
+const by = (0, import_core.createToken)({ name: "By", pattern: /by/i, label: "BY" });
+const having = (0, import_core.createToken)({ name: "Having", pattern: /having/i, label: "HAVING" });
+const order = (0, import_core.createToken)({ name: "Order", pattern: /order/i, label: "_ORDER_ BY" });
+const orderAsc = (0, import_core.createToken)({ name: "OrderAsc", pattern: /asc/i, label: "ASC" });
+const orderDesc = (0, import_core.createToken)({ name: "OrderDesc", pattern: /desc/i, label: "DESC" });
+const limit = (0, import_core.createToken)({ name: "Limit", pattern: /limit/i, label: "LIMIT" });
+const offset = (0, import_core.createToken)({ name: "Offset", pattern: /offset/i, label: "OFFSET" });
+const values = (0, import_core.createToken)({ name: "Values", pattern: /values/i, label: "VALUES" });
+const load = (0, import_core.createToken)({ name: "Load", pattern: /load/i, label: "LOAD" });
+const silent = (0, import_core.createToken)({ name: "Silent", pattern: /silent/i, label: "SILENT" });
+const loadInto = (0, import_core.createToken)({ name: "LoadInto", pattern: /into/i, label: "INTO" });
+const clear = (0, import_core.createToken)({ name: "Clear", pattern: /clear/i, label: "CLEAR" });
+const drop = (0, import_core.createToken)({ name: "Drop", pattern: /drop/i, label: "DROP" });
+const create = (0, import_core.createToken)({ name: "Create", pattern: /create/i, label: "CREATE" });
+const add = (0, import_core.createToken)({ name: "Add", pattern: /add/i, label: "ADD" });
+const to = (0, import_core.createToken)({ name: "To", pattern: /to/i, label: "TO" });
+const move = (0, import_core.createToken)({ name: "Move", pattern: /move/i, label: "MOVE" });
+const copy = (0, import_core.createToken)({ name: "Copy", pattern: /copy/i, label: "COPY" });
+const modifyWith = (0, import_core.createToken)({ name: "ModifyWith", pattern: /with/i, label: "WITH" });
+const deleteDataClause = (0, import_core.createToken)({
+  name: "DeleteDataClause",
+  pattern: new RegExp(`delete(${import_lexerPatterns.atLeastOneBlankPattern.source})data`, "i"),
+  label: "DELETE DATA"
+});
+const deleteWhereClause = (0, import_core.createToken)({
+  name: "DeleteWhereClause",
+  pattern: new RegExp(`delete(${import_lexerPatterns.atLeastOneBlankPattern.source})where`, "i"),
+  label: "DELETE WHERE"
+});
+const deleteClause = (0, import_core.createToken)({ name: "DeleteClause", pattern: /delete/i, label: "DELETE" });
+const insertDataClause = (0, import_core.createToken)({
+  name: "InsertDataClause",
+  pattern: new RegExp(`insert(${import_lexerPatterns.atLeastOneBlankPattern.source})data`, "i"),
+  label: "INSERT DATA"
+});
+const insertClause = (0, import_core.createToken)({ name: "InsertClause", pattern: /insert/i, label: "insert" });
+const usingClause = (0, import_core.createToken)({ name: "UsingClause", pattern: /using/i, label: "USING" });
+const optional = (0, import_core.createToken)({ name: "Optional", pattern: /optional/i, label: "OPTIONAL" });
+const service = (0, import_core.createToken)({ name: "Service", pattern: /service/i, label: "SERVICE" });
+const bind = (0, import_core.createToken)({ name: "Bind", pattern: /bind/i, label: "BIND" });
+const undef = (0, import_core.createToken)({ name: "Undef", pattern: /undef/i, label: "UNDEF" });
+const minus = (0, import_core.createToken)({ name: "Minus", pattern: /minus/i, label: "MINUS" });
+const union = (0, import_core.createToken)({ name: "Union", pattern: /union/i, label: "UNION" });
+const filter = (0, import_core.createToken)({ name: "Filter", pattern: /filter/i, label: "FILTER" });
+const a = (0, import_core.createToken)({ name: "a", pattern: "a", label: "type declaration 'a'" });
+const true_ = (0, import_core.createToken)({ name: "True", pattern: /true/i, label: "true" });
+const false_ = (0, import_core.createToken)({ name: "False", pattern: /false/i, label: "false" });
+const in_ = (0, import_core.createToken)({ name: "In", pattern: /in/i, label: "IN" });
+const notIn = (0, import_core.createToken)({ name: "NotIn", pattern: /not[\u0020\u0009\u000D\u000A]+in/i, label: "NOT IN" });
+const separator = (0, import_core.createToken)({ name: "Separator", pattern: /separator/i, label: "SEPARATOR" });
+const allBaseTokens = import_core.LexerBuilder.create().add(baseDecl, prefixDecl, select, distinct, reduced, construct, describe, ask, from, where, having, groupByGroup, by, order, orderAsc, orderDesc, limit, offset, values, load, silent, loadInto, clear, drop, create, add, to, move, copy, modifyWith, deleteWhereClause, deleteDataClause, deleteClause, insertDataClause, insertClause, usingClause, optional, service, bind, undef, minus, union, filter, as, a, true_, false_, in_, notIn, separator);
+const sparql11LexerBuilder = import_core.LexerBuilder.create(import_terminals.allTerminals).merge(allBaseTokens).merge(import_BuiltInCalls.allBuiltInCalls).merge(import_graph.allGraphTokens).merge(import_symbols.allSymbols).moveAfter(import_BuiltInCalls.avg, a).moveBefore(a, import_graph.graphAll).moveAfter(import_BuiltInCalls.groupConcat, groupByGroup);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  a,
+  add,
+  allBaseTokens,
+  as,
+  ask,
+  baseDecl,
+  bind,
+  by,
+  clear,
+  construct,
+  copy,
+  create,
+  deleteClause,
+  deleteDataClause,
+  deleteWhereClause,
+  describe,
+  distinct,
+  drop,
+  false_,
+  filter,
+  from,
+  groupByGroup,
+  having,
+  in_,
+  insertClause,
+  insertDataClause,
+  limit,
+  load,
+  loadInto,
+  minus,
+  modifyWith,
+  move,
+  notIn,
+  offset,
+  optional,
+  order,
+  orderAsc,
+  orderDesc,
+  prefixDecl,
+  reduced,
+  select,
+  separator,
+  service,
+  silent,
+  sparql11LexerBuilder,
+  to,
+  true_,
+  undef,
+  union,
+  usingClause,
+  values,
+  where
+});