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

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

@@ -0,0 +1,133 @@
+"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 lexerPatterns_exports = {};
+__export(lexerPatterns_exports, {
+  anonPattern: () => anonPattern,
+  atLeastOneBlankPattern: () => atLeastOneBlankPattern,
+  blankNodeLabelPattern: () => blankNodeLabelPattern,
+  commentPattern: () => commentPattern,
+  decimalNegativePattern: () => decimalNegativePattern,
+  decimalPattern: () => decimalPattern,
+  decimalPositivePattern: () => decimalPositivePattern,
+  doubleNegativePattern: () => doubleNegativePattern,
+  doublePattern: () => doublePattern,
+  doublePositivePattern: () => doublePositivePattern,
+  echarPattern: () => echarPattern,
+  exponentPattern: () => exponentPattern,
+  integerNegativePattern: () => integerNegativePattern,
+  integerPattern: () => integerPattern,
+  interferePositivePattern: () => interferePositivePattern,
+  iriRefPattern: () => iriRefPattern,
+  langTagPattern: () => langTagPattern,
+  nilPattern: () => nilPattern,
+  pNameLnPattern: () => pNameLnPattern,
+  pNameNsPattern: () => pNameNsPattern,
+  percentPattern: () => percentPattern,
+  plxPattern: () => plxPattern,
+  pnCharsBasePattern: () => pnCharsBasePattern,
+  pnCharsPattern: () => pnCharsPattern,
+  pnCharsUPattern: () => pnCharsUPattern,
+  pnLocalEscPattern: () => pnLocalEscPattern,
+  pnLocalPattern: () => pnLocalPattern,
+  pnPrefixPattern: () => pnPrefixPattern,
+  stringLiteral1Pattern: () => stringLiteral1Pattern,
+  stringLiteral2Pattern: () => stringLiteral2Pattern,
+  stringLiteralLong1Pattern: () => stringLiteralLong1Pattern,
+  stringLiteralLong2Pattern: () => stringLiteralLong2Pattern,
+  var1Pattern: () => var1Pattern,
+  var2Pattern: () => var2Pattern,
+  varNamePattern: () => varNamePattern,
+  wsPattern: () => wsPattern
+});
+module.exports = __toCommonJS(lexerPatterns_exports);
+const pnCharsBasePattern = /[A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]|[\uD800-\uDB7F][\uDC00-\uDFFF]/;
+const pnCharsUPattern = new RegExp(`${pnCharsBasePattern.source}|_`);
+const varNamePattern = new RegExp(`((${pnCharsUPattern.source})|[0-9])((${pnCharsUPattern.source})|[0-9]|[\xB7\u0300-\u036F\u203F-\u2040])*`);
+const iriRefPattern = /<([^\u0000-\u0020"<>\\^`{|}])*>/;
+const pnCharsPattern = new RegExp(`(${pnCharsUPattern.source})|[\\-0-9\xB7\u0300-\u036F\u203F-\u2040]`);
+const pnPrefixPattern = new RegExp(`(${pnCharsBasePattern.source})(((${pnCharsPattern.source})|\\.)*(${pnCharsPattern.source}))?`);
+const pNameNsPattern = new RegExp(`(${pnPrefixPattern.source})?:`);
+const percentPattern = /%[\dA-Fa-f]{2}/;
+const pnLocalEscPattern = /\\[!#$%&'()*+,./;=?@\\_~-]/;
+const plxPattern = new RegExp(`(${percentPattern.source})|(${pnLocalEscPattern.source})`);
+const pnLocalPattern = new RegExp(`((${pnCharsUPattern.source})|:|[0-9]|(${plxPattern.source}))(((${pnCharsPattern.source})|\\.|:|(${plxPattern.source}))*((${pnCharsPattern.source})|:|(${plxPattern.source})))?`);
+const pNameLnPattern = new RegExp(`(${pNameNsPattern.source})(${pnLocalPattern.source})`);
+const blankNodeLabelPattern = new RegExp(`_:((${pnCharsUPattern.source})|[0-9])(((${pnCharsPattern.source})|\\.)*(${pnCharsPattern.source}))?`);
+const var1Pattern = new RegExp(`\\?(${varNamePattern.source})`);
+const var2Pattern = new RegExp(`\\$(${varNamePattern.source})`);
+const langTagPattern = /@[A-Za-z]+(-[\dA-Za-z]+)*/;
+const integerPattern = /\d+/;
+const decimalPattern = /\d+\.\d+/;
+const exponentPattern = /[Ee][+-]?\d+/;
+const doublePattern = new RegExp(`([0-9]+\\.[0-9]*(${exponentPattern.source}))|(\\.[0-9]+(${exponentPattern.source}))|([0-9]+(${exponentPattern.source}))`);
+const interferePositivePattern = new RegExp(`\\+${integerPattern.source}`);
+const decimalPositivePattern = new RegExp(`\\+${decimalPattern.source}`);
+const doublePositivePattern = new RegExp(`\\+${doublePattern.source}`);
+const integerNegativePattern = new RegExp(`-${integerPattern.source}`);
+const decimalNegativePattern = new RegExp(`-${decimalPattern.source}`);
+const doubleNegativePattern = new RegExp(`-${doublePattern.source}`);
+const echarPattern = /\\[\\"'bfnrt]/u;
+const stringLiteral1Pattern = new RegExp(`'(([^\\u0027\\u005C\\u000A\r])|(${echarPattern.source}))*'`);
+const stringLiteral2Pattern = new RegExp(`"(([^\\u0022\\u005C\\u000A\\u000D])|(${echarPattern.source}))*"`);
+const stringLiteralLong1Pattern = new RegExp(`'''(('|(''))?([^'\\\\]|(${echarPattern.source})))*'''`);
+const stringLiteralLong2Pattern = new RegExp(`"""(("|(""))?([^"\\\\]|(${echarPattern.source})))*"""`);
+const wsPattern = /[\u0009\u000A\u000D ]/;
+const nilPattern = new RegExp(`\\((${wsPattern.source})*\\)`);
+const anonPattern = new RegExp(`\\[(${wsPattern.source})*\\]`);
+const commentPattern = /#[^\n]*\n/;
+const atLeastOneBlankPattern = new RegExp(`((${wsPattern.source}+)|(${commentPattern.source}))+`);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  anonPattern,
+  atLeastOneBlankPattern,
+  blankNodeLabelPattern,
+  commentPattern,
+  decimalNegativePattern,
+  decimalPattern,
+  decimalPositivePattern,
+  doubleNegativePattern,
+  doublePattern,
+  doublePositivePattern,
+  echarPattern,
+  exponentPattern,
+  integerNegativePattern,
+  integerPattern,
+  interferePositivePattern,
+  iriRefPattern,
+  langTagPattern,
+  nilPattern,
+  pNameLnPattern,
+  pNameNsPattern,
+  percentPattern,
+  plxPattern,
+  pnCharsBasePattern,
+  pnCharsPattern,
+  pnCharsUPattern,
+  pnLocalEscPattern,
+  pnLocalPattern,
+  pnPrefixPattern,
+  stringLiteral1Pattern,
+  stringLiteral2Pattern,
+  stringLiteralLong1Pattern,
+  stringLiteralLong2Pattern,
+  var1Pattern,
+  var2Pattern,
+  varNamePattern,
+  wsPattern
+});

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

@@ -0,0 +1,107 @@
+"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 symbols_exports = {};
+__export(symbols_exports, {
+  LCurly: () => LCurly,
+  LParen: () => LParen,
+  LSquare: () => LSquare,
+  RCurly: () => RCurly,
+  RParen: () => RParen,
+  RSquare: () => RSquare,
+  allSymbols: () => allSymbols,
+  comma: () => comma,
+  dot: () => dot,
+  equal: () => equal,
+  exclamation: () => exclamation,
+  greaterThan: () => greaterThan,
+  greaterThanEqual: () => greaterThanEqual,
+  hat: () => hat,
+  hathat: () => hathat,
+  lessThan: () => lessThan,
+  lessThanEqual: () => lessThanEqual,
+  logicAnd: () => logicAnd,
+  logicOr: () => logicOr,
+  notEqual: () => notEqual,
+  opMinus: () => opMinus,
+  opPlus: () => opPlus,
+  pipe: () => pipe,
+  question: () => question,
+  semi: () => semi,
+  slash: () => slash,
+  star: () => star
+});
+module.exports = __toCommonJS(symbols_exports);
+var import_core = require("@traqula/core");
+const LCurly = (0, import_core.createToken)({ name: "LCurly", pattern: "{", label: "{" });
+const RCurly = (0, import_core.createToken)({ name: "RCurly", pattern: "}", label: "}" });
+const dot = (0, import_core.createToken)({ name: "Dot", pattern: ".", label: "." });
+const comma = (0, import_core.createToken)({ name: "Comma", pattern: ",", label: "," });
+const semi = (0, import_core.createToken)({ name: "Semi", pattern: ";", label: ";" });
+const LParen = (0, import_core.createToken)({ name: "LParen", pattern: "(", label: "(" });
+const RParen = (0, import_core.createToken)({ name: "RParen", pattern: ")", label: ")" });
+const LSquare = (0, import_core.createToken)({ name: "LSquare", pattern: "[", label: "[" });
+const RSquare = (0, import_core.createToken)({ name: "RSquare", pattern: "]", label: "]" });
+const pipe = (0, import_core.createToken)({ name: "Pipe", pattern: "|", label: "|" });
+const slash = (0, import_core.createToken)({ name: "Slash", pattern: "/", label: "/" });
+const hat = (0, import_core.createToken)({ name: "Hat", pattern: "^", label: "^" });
+const question = (0, import_core.createToken)({ name: "Question", pattern: "?", label: "?" });
+const star = (0, import_core.createToken)({ name: "Star", pattern: "*", label: "*" });
+const opPlus = (0, import_core.createToken)({ name: "OpPlus", pattern: "+", label: "+" });
+const opMinus = (0, import_core.createToken)({ name: "OpMinus", pattern: "-", label: "-" });
+const exclamation = (0, import_core.createToken)({ name: "Exclamation", pattern: "!", label: "!" });
+const logicAnd = (0, import_core.createToken)({ name: "LogicAnd", pattern: "&&", label: "&&" });
+const logicOr = (0, import_core.createToken)({ name: "LogicOr", pattern: "||", label: "||" });
+const equal = (0, import_core.createToken)({ name: "Equal", pattern: "=", label: "=" });
+const notEqual = (0, import_core.createToken)({ name: "NotEqual", pattern: "!=", label: "!=" });
+const lessThan = (0, import_core.createToken)({ name: "LessThan", pattern: "<", label: "<" });
+const greaterThan = (0, import_core.createToken)({ name: "GreaterThan", pattern: ">", label: ">" });
+const lessThanEqual = (0, import_core.createToken)({ name: "LessThanEqual", pattern: "<=", label: "<=" });
+const greaterThanEqual = (0, import_core.createToken)({ name: "GreaterThanEqual", pattern: ">=", label: ">=" });
+const hathat = (0, import_core.createToken)({ name: "Hathat", pattern: "^^", label: "^^" });
+const allSymbols = import_core.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);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LCurly,
+  LParen,
+  LSquare,
+  RCurly,
+  RParen,
+  RSquare,
+  allSymbols,
+  comma,
+  dot,
+  equal,
+  exclamation,
+  greaterThan,
+  greaterThanEqual,
+  hat,
+  hathat,
+  lessThan,
+  lessThanEqual,
+  logicAnd,
+  logicOr,
+  notEqual,
+  opMinus,
+  opPlus,
+  pipe,
+  question,
+  semi,
+  slash,
+  star
+});

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

@@ -0,0 +1,103 @@
+"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 terminals_exports = {};
+__export(terminals_exports, {
+  allTerminals: () => allTerminals,
+  anon: () => anon,
+  blankNodeLabel: () => blankNodeLabel,
+  comment: () => comment,
+  decimal: () => decimal,
+  decimalNegative: () => decimalNegative,
+  decimalPositive: () => decimalPositive,
+  double: () => double,
+  doubleNegative: () => doubleNegative,
+  doublePositive: () => doublePositive,
+  integer: () => integer,
+  integerNegative: () => integerNegative,
+  integerPositive: () => integerPositive,
+  iriRef: () => iriRef,
+  langTag: () => langTag,
+  nil: () => nil,
+  pNameLn: () => pNameLn,
+  pNameNs: () => pNameNs,
+  stringLiteral1: () => stringLiteral1,
+  stringLiteral2: () => stringLiteral2,
+  stringLiteralLong1: () => stringLiteralLong1,
+  stringLiteralLong2: () => stringLiteralLong2,
+  var1: () => var1,
+  var2: () => var2,
+  ws: () => ws
+});
+module.exports = __toCommonJS(terminals_exports);
+var import_chevrotain = require("@traqula/chevrotain");
+var import_core = require("@traqula/core");
+var import_lexerPatterns = require("./lexerPatterns.js");
+const iriRef = (0, import_core.createToken)({ name: "IriRef", pattern: import_lexerPatterns.iriRefPattern });
+const pNameLn = (0, import_core.createToken)({ name: "PNameLn", pattern: import_lexerPatterns.pNameLnPattern });
+const pNameNs = (0, import_core.createToken)({ name: "PNameNs", pattern: import_lexerPatterns.pNameNsPattern, longer_alt: [pNameLn] });
+const blankNodeLabel = (0, import_core.createToken)({ name: "BlankNodeLabel", pattern: import_lexerPatterns.blankNodeLabelPattern });
+const var1 = (0, import_core.createToken)({ name: "Var1", pattern: import_lexerPatterns.var1Pattern });
+const var2 = (0, import_core.createToken)({ name: "Var2", pattern: import_lexerPatterns.var2Pattern });
+const langTag = (0, import_core.createToken)({ name: "LangTag", pattern: import_lexerPatterns.langTagPattern });
+const integer = (0, import_core.createToken)({ name: "Integer", pattern: import_lexerPatterns.integerPattern });
+const decimal = (0, import_core.createToken)({ name: "Decimal", pattern: import_lexerPatterns.decimalPattern });
+const double = (0, import_core.createToken)({ name: "Double", pattern: import_lexerPatterns.doublePattern });
+const integerPositive = (0, import_core.createToken)({ name: "InterferePositive", pattern: import_lexerPatterns.interferePositivePattern });
+const decimalPositive = (0, import_core.createToken)({ name: "DecimalPositive", pattern: import_lexerPatterns.decimalPositivePattern });
+const doublePositive = (0, import_core.createToken)({ name: "DoublePositive", pattern: import_lexerPatterns.doublePositivePattern });
+const integerNegative = (0, import_core.createToken)({ name: "IntegerNegative", pattern: import_lexerPatterns.integerNegativePattern });
+const decimalNegative = (0, import_core.createToken)({ name: "DecimalNegative", pattern: import_lexerPatterns.decimalNegativePattern });
+const doubleNegative = (0, import_core.createToken)({ name: "DoubleNegative", pattern: import_lexerPatterns.doubleNegativePattern });
+const stringLiteral1 = (0, import_core.createToken)({ name: "StringLiteral1", pattern: import_lexerPatterns.stringLiteral1Pattern });
+const stringLiteral2 = (0, import_core.createToken)({ name: "StringLiteral2", pattern: import_lexerPatterns.stringLiteral2Pattern });
+const stringLiteralLong1 = (0, import_core.createToken)({ name: "StringLiteralLong1", pattern: import_lexerPatterns.stringLiteralLong1Pattern });
+const stringLiteralLong2 = (0, import_core.createToken)({ name: "StringLiteralLong2", pattern: import_lexerPatterns.stringLiteralLong2Pattern });
+const ws = (0, import_core.createToken)({ name: "Ws", pattern: import_lexerPatterns.wsPattern, group: import_chevrotain.Lexer.SKIPPED });
+const comment = (0, import_core.createToken)({ name: "Comment", pattern: import_lexerPatterns.commentPattern, group: import_chevrotain.Lexer.SKIPPED });
+const nil = (0, import_core.createToken)({ name: "Nil", pattern: import_lexerPatterns.nilPattern });
+const anon = (0, import_core.createToken)({ name: "Anon", pattern: import_lexerPatterns.anonPattern });
+const allTerminals = import_core.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);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  allTerminals,
+  anon,
+  blankNodeLabel,
+  comment,
+  decimal,
+  decimalNegative,
+  decimalPositive,
+  double,
+  doubleNegative,
+  doublePositive,
+  integer,
+  integerNegative,
+  integerPositive,
+  iriRef,
+  langTag,
+  nil,
+  pNameLn,
+  pNameNs,
+  stringLiteral1,
+  stringLiteral2,
+  stringLiteralLong1,
+  stringLiteralLong2,
+  var1,
+  var2,
+  ws
+});

package/dist/cjs/lib/sparql11HelperTypes.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 sparql11HelperTypes_exports = {};
+module.exports = __toCommonJS(sparql11HelperTypes_exports);

package/dist/cjs/lib/utils.js

@@ -0,0 +1,64 @@
+"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 utils_exports = {};
+__export(utils_exports, {
+  AstTransformer: () => AstTransformer,
+  CommonIRIs: () => CommonIRIs,
+  sparqlCodepointEscape: () => sparqlCodepointEscape
+});
+module.exports = __toCommonJS(utils_exports);
+var import_core = require("@traqula/core");
+function sparqlCodepointEscape(input) {
+  const sanitizedInput = input.replaceAll(/\\u([0-9a-fA-F]{4})|\\U([0-9a-fA-F]{8})/gu, (_, unicode4, unicode8) => {
+    if (unicode4) {
+      const charCode2 = Number.parseInt(unicode4, 16);
+      return String.fromCodePoint(charCode2);
+    }
+    const charCode = Number.parseInt(unicode8, 16);
+    if (charCode < 65535) {
+      return String.fromCodePoint(charCode);
+    }
+    const substractedCharCode = charCode - 65536;
+    return String.fromCodePoint(55296 + (substractedCharCode >> 10), 56320 + (substractedCharCode & 1023));
+  });
+  if (/[\uD800-\uDBFF](?:[^\uDC00-\uDFFF]|$)/u.test(sanitizedInput)) {
+    throw new Error(`Invalid unicode codepoint of surrogate pair without corresponding codepoint`);
+  }
+  return sanitizedInput;
+}
+var CommonIRIs;
+(function(CommonIRIs2) {
+  CommonIRIs2["BOOLEAN"] = "http://www.w3.org/2001/XMLSchema#boolean";
+  CommonIRIs2["INTEGER"] = "http://www.w3.org/2001/XMLSchema#integer";
+  CommonIRIs2["DECIMAL"] = "http://www.w3.org/2001/XMLSchema#decimal";
+  CommonIRIs2["DOUBLE"] = "http://www.w3.org/2001/XMLSchema#double";
+  CommonIRIs2["STRING"] = "http://www.w3.org/2001/XMLSchema#string";
+  CommonIRIs2["FIRST"] = "http://www.w3.org/1999/02/22-rdf-syntax-ns#first";
+  CommonIRIs2["REST"] = "http://www.w3.org/1999/02/22-rdf-syntax-ns#rest";
+  CommonIRIs2["NIL"] = "http://www.w3.org/1999/02/22-rdf-syntax-ns#nil";
+  CommonIRIs2["TYPE"] = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type";
+})(CommonIRIs || (CommonIRIs = {}));
+class AstTransformer extends import_core.TransformerSubTyped {
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AstTransformer,
+  CommonIRIs,
+  sparqlCodepointEscape
+});

package/dist/cjs/lib/validation/validators.js

@@ -0,0 +1,214 @@
+"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 validators_exports = {};
+__export(validators_exports, {
+  checkNote13: () => checkNote13,
+  findPatternBoundedVars: () => findPatternBoundedVars,
+  queryIsGood: () => queryIsGood,
+  updateNoReuseBlankNodeLabels: () => updateNoReuseBlankNodeLabels
+});
+module.exports = __toCommonJS(validators_exports);
+var import_astFactory = require("../astFactory.js");
+var import_utils = require("../utils.js");
+const F = new import_astFactory.AstFactory();
+const transformer = new import_utils.AstTransformer();
+function getAggregatesOfExpression(expression) {
+  if (F.isExpressionAggregate(expression)) {
+    return [expression];
+  }
+  if (F.isExpressionOperator(expression)) {
+    const aggregates = [];
+    for (const arg of expression.args) {
+      aggregates.push(...getAggregatesOfExpression(arg));
+    }
+    return aggregates;
+  }
+  return [];
+}
+function getExpressionId(expression) {
+  if (F.isTerm(expression) && F.isTermVariable(expression)) {
+    return expression.value;
+  }
+  if (F.isExpression(expression)) {
+    if (F.isExpressionAggregate(expression) && F.isTermVariable(expression.expression[0])) {
+      return expression.expression[0].value;
+    }
+    return void 0;
+  }
+  return expression.variable.value;
+}
+function getVariablesFromExpression(expression, variables) {
+  if (F.isExpressionOperator(expression)) {
+    for (const expr of expression.args) {
+      getVariablesFromExpression(expr, variables);
+    }
+  } else if (F.isTerm(expression) && F.isTermVariable(expression)) {
+    variables.add(expression.value);
+  }
+}
+function queryIsGood(query) {
+  if (query.variables.length === 1 && F.isWildcard(query.variables[0])) {
+    if (query.solutionModifiers.group !== void 0) {
+      throw new Error("GROUP BY not allowed with wildcard");
+    }
+    return;
+  }
+  const variables = query.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 groupBy = query.solutionModifiers.group;
+  if (hasCountAggregate || groupBy) {
+    for (const selectVar of variables) {
+      if (F.isTerm(selectVar)) {
+        if (!groupBy || !groupBy.groupings.map((groupvar) => getExpressionId(groupvar)).includes(getExpressionId(selectVar))) {
+          throw new Error("Variable not allowed in projection");
+        }
+      } else if (getAggregatesOfExpression(selectVar.expression).length === 0) {
+        const usedvars = /* @__PURE__ */ new Set();
+        getVariablesFromExpression(selectVar.expression, usedvars);
+        for (const usedvar of usedvars) {
+          if (!groupBy || !groupBy.groupings.map((groupVar) => getExpressionId(groupVar)).includes(usedvar)) {
+            throw new Error(`Use of ungrouped variable in projection of operation (?${usedvar})`);
+          }
+        }
+      }
+    }
+  }
+  const subqueries = query.where.patterns.filter((pattern) => pattern.type === "query");
+  if (subqueries.length > 0) {
+    const selectBoundedVars = /* @__PURE__ */ new Set();
+    for (const variable of variables) {
+      if ("variable" in variable) {
+        selectBoundedVars.add(variable.variable.value);
+      }
+    }
+    const vars = subqueries.flatMap((sub) => sub.variables).map((v) => F.isTerm(v) ? v.value : F.isWildcard(v) ? "*" : v.variable.value);
+    const subqueryIds = new Set(vars);
+    for (const selectedVarId of selectBoundedVars) {
+      if (subqueryIds.has(selectedVarId)) {
+        throw new Error(`Target id of 'AS' (?${selectedVarId}) already used in subquery`);
+      }
+    }
+  }
+}
+function notUndefined(some) {
+  return some !== void 0;
+}
+function findPatternBoundedVars(iter, boundedVars) {
+  transformer.traverseSubNodes(iter, {
+    query: (op) => ({ next: [
+      op.solutionModifiers.group
+    ].filter(notUndefined) }),
+    triple: (op) => ({ next: [op.subject, op.predicate, op.object] }),
+    path: (op) => ({ next: op.items }),
+    tripleCollection: (op) => ({ next: [op.identifier, ...op.triples] })
+  }, {
+    query: {
+      select: (op) => ({ next: [
+        ...op.variables.some((x) => F.isWildcard(x)) ? [op.where] : op.variables,
+        op.solutionModifiers.group,
+        op.values
+      ].filter(notUndefined) }),
+      describe: (op) => ({ next: [
+        ...op.variables.some((x) => F.isWildcard(x)) ? [op.where] : op.variables,
+        op.solutionModifiers.group,
+        op.values
+      ].filter(notUndefined) })
+    },
+    solutionModifier: {
+      group: (op) => ({
+        next: op.groupings.filter((g) => "variable" in g).map((x) => x.variable)
+      }),
+      having: (op) => ({ next: op.having }),
+      order: (op) => ({ next: op.orderDefs.map((x) => x.expression) })
+    },
+    pattern: {
+      values: (op) => {
+        for (const v of Object.keys(op.values.at(0) ?? {})) {
+          boundedVars.add(v);
+        }
+        return {};
+      },
+      bgp: (op) => ({ next: op.triples }),
+      group: (op) => ({ next: op.patterns }),
+      union: (op) => ({ next: op.patterns }),
+      optional: (op) => ({ next: op.patterns }),
+      service: (op) => ({ next: [op.name, ...op.patterns] }),
+      bind: (op) => ({ next: [op.variable] }),
+      graph: (op) => ({ next: [op.name, ...op.patterns] })
+    },
+    term: {
+      variable: (op) => {
+        boundedVars.add(op.value);
+        return {};
+      }
+    }
+  });
+}
+function checkNote13(patterns) {
+  for (const [index, pattern] of patterns.entries()) {
+    if (F.isPatternBind(pattern) && index > 0 && F.isPatternBgp(patterns[index - 1])) {
+      const bgp = patterns[index - 1];
+      const variables = [];
+      transformer.visitNodeSpecific(bgp, {}, { term: { variable: { visitor: (var_) => {
+        variables.push(var_);
+      } } } });
+      if (variables.some((var_) => var_.value === pattern.variable.value)) {
+        throw new Error(`Variable used to bind is already bound (?${pattern.variable.value})`);
+      }
+    }
+  }
+  const boundedVars = /* @__PURE__ */ new Set();
+  for (const pattern of patterns) {
+    if (F.isPatternBind(pattern)) {
+      if (boundedVars.has(pattern.variable.value)) {
+        throw new Error(`Variable used to bind is already bound (?${pattern.variable.value})`);
+      }
+    } else {
+      findPatternBoundedVars(pattern, boundedVars);
+    }
+  }
+}
+function updateNoReuseBlankNodeLabels(updateQuery) {
+  const blankLabelsUsedInInsertData = /* @__PURE__ */ new Set();
+  for (const update of updateQuery.updates) {
+    if (!update.operation) {
+      continue;
+    }
+    const operation = update.operation;
+    if (operation.subType === "insertdata") {
+      const blankNodesHere = /* @__PURE__ */ new Set();
+      transformer.visitNodeSpecific(operation, {}, { term: { blankNode: { visitor: (blankNode) => {
+        blankNodesHere.add(blankNode.label);
+        if (blankLabelsUsedInInsertData.has(blankNode.label)) {
+          throw new Error("Detected reuse blank node across different INSERT DATA clauses");
+        }
+      } } } });
+      for (const blankNode of blankNodesHere) {
+        blankLabelsUsedInInsertData.add(blankNode);
+      }
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkNote13,
+  findPatternBoundedVars,
+  queryIsGood,
+  updateNoReuseBlankNodeLabels
+});

package/dist/esm/lib/MinimalSparqlParser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MinimalSparqlParser.js","sourceRoot":"","sources":["../../../lib/MinimalSparqlParser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAS7C,MAAM,UAAU,oBAAoB,CAClC,OAAkG;IAElG,OAAO;QACL,UAAU,EAAE,OAAO,CAAC,UAAU,IAAI,IAAI,UAAU,EAAE;QAClD,OAAO,EAAE,OAAO,CAAC,OAAO;QACxB,QAAQ,EAAE,EAAE,GAAG,OAAO,CAAC,QAAQ,EAAE;QACjC,UAAU,EAAE,OAAO,CAAC,UAAU,IAAI,EAAE;QACpC,MAAM,EAAE,OAAO,CAAC,MAAM;QACtB,SAAS,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,CAAE,cAAc,EAAE,qBAAqB,CAAE,CAAC;QAC9G,cAAc,EAAE,OAAO,CAAC,cAAc,IAAI,KAAK;QAC/C,CAAC,kBAAkB,CAAC,EAAE,OAAO,CAAC,kBAAkB,CAAC,IAAI,CAAC;QACtD,SAAS,EAAE,OAAO,CAAC,SAAS,IAAI,CAAC;KAClC,CAAC;AACJ,CAAC;AAED,MAAM,OAAO,mBAAmB;IACM;IAApC,YAAoC,MAAwB;QAAxB,WAAM,GAAN,MAAM,CAAkB;IAAG,CAAC;IAC/C,CAAC,GAAG,IAAI,UAAU,EAAE,CAAC;IAE/B,KAAK,CAAC,KAAa,EAAE,UAAkC,EAAE;QAC9D,OAAO,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,KAAK,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC,CAAC;IACzE,CAAC;IAEM,SAAS,CAAC,KAAa,EAAE,UAAkC,EAAE;QAElE,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC,CAAC;QACtE,IAAI,IAAI,CAAC,CAAC,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC;YAC9B,OAAO;gBACL,GAAG,MAAM;gBACT,QAAQ,EAAE,EAAE;aACb,CAAC;QACJ,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;CACF","sourcesContent":["import { traqulaIndentation } from '@traqula/core';\nimport { AstFactory } from './astFactory.js';\nimport type { SparqlContext, SparqlGeneratorContext } from './sparql11HelperTypes.js';\nimport type { Path, TermIri } from './Sparql11types.js';\n\ninterface Parser<ParseRet> {\n  queryOrUpdate: (input: string, context: SparqlContext) => ParseRet;\n  path: (input: string, context: SparqlContext) => TermIri | Path;\n}\n\nexport function completeParseContext(\n  context: Partial<SparqlContext & SparqlGeneratorContext & { origSource: string; offset?: number }>,\n): SparqlContext & SparqlGeneratorContext & { origSource: string; offset?: number } {\n  return {\n    astFactory: context.astFactory ?? new AstFactory(),\n    baseIRI: context.baseIRI,\n    prefixes: { ...context.prefixes },\n    origSource: context.origSource ?? '',\n    offset: context.offset,\n    parseMode: context.parseMode ? new Set(context.parseMode) : new Set([ 'canParseVars', 'canCreateBlankNodes' ]),\n    skipValidation: context.skipValidation ?? false,\n    [traqulaIndentation]: context[traqulaIndentation] ?? 0,\n    indentInc: context.indentInc ?? 2,\n  };\n}\n\nexport class MinimalSparqlParser<ParseRet> {\n  public constructor(private readonly parser: Parser<ParseRet>) {}\n  private readonly F = new AstFactory();\n\n  public parse(query: string, context: Partial<SparqlContext> = {}): ParseRet {\n    return this.parser.queryOrUpdate(query, completeParseContext(context));\n  }\n\n  public parsePath(query: string, context: Partial<SparqlContext> = {}):\n    (Path & { prefixes: object }) | TermIri {\n    const result = this.parser.path(query, completeParseContext(context));\n    if (this.F.isPathPure(result)) {\n      return {\n        ...result,\n        prefixes: {},\n      };\n    }\n    return result;\n  }\n}\n"]}