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

package/dist/cjs/lib/grammar/literals.js

@@ -0,0 +1,282 @@
+"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 __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 literals_exports = {};
+__export(literals_exports, {
+  blankNode: () => blankNode,
+  booleanLiteral: () => booleanLiteral,
+  canCreateBlankNodes: () => canCreateBlankNodes,
+  iri: () => iri,
+  iriFull: () => iriFull,
+  numericLiteral: () => numericLiteral,
+  numericLiteralNegative: () => numericLiteralNegative,
+  numericLiteralPositive: () => numericLiteralPositive,
+  numericLiteralUnsigned: () => numericLiteralUnsigned,
+  prefixedName: () => prefixedName,
+  rdfLiteral: () => rdfLiteral,
+  string: () => string,
+  stringEscapedLexical: () => stringEscapedLexical,
+  verbA: () => verbA
+});
+module.exports = __toCommonJS(literals_exports);
+var l = __toESM(require("../lexer/index.js"), 1);
+var import_utils = require("../utils.js");
+function stringEscapedLexical(str) {
+  const lexical = str.replaceAll(/["\\\t\n\r\b\f]/gu, (char) => {
+    switch (char) {
+      case "	":
+        return "\\t";
+      case "\n":
+        return "\\n";
+      case "\r":
+        return "\\r";
+      case "\b":
+        return "\\b";
+      case "\f":
+        return "\\f";
+      case '"':
+        return '\\"';
+      case "\\":
+        return "\\\\";
+      default:
+        return char;
+    }
+  });
+  return `"${lexical}"`;
+}
+const rdfLiteral = {
+  name: "rdfLiteral",
+  impl: ({ ACTION, SUBRULE1, CONSUME, OPTION, OR }) => (C) => {
+    const value = SUBRULE1(string);
+    return OPTION(() => OR([
+      { ALT: () => {
+        const lang = CONSUME(l.terminals.langTag);
+        return ACTION(() => C.astFactory.termLiteral(C.astFactory.sourceLocation(value, lang), value.value, lang.image.slice(1).toLowerCase()));
+      } },
+      { ALT: () => {
+        CONSUME(l.symbols.hathat);
+        const iriVal = SUBRULE1(iri);
+        return ACTION(() => C.astFactory.termLiteral(C.astFactory.sourceLocation(value, iriVal), value.value, iriVal));
+      } }
+    ])) ?? value;
+  },
+  gImpl: ({ SUBRULE, PRINT, PRINT_WORD }) => (ast, { astFactory }) => {
+    astFactory.printFilter(ast, () => {
+      PRINT_WORD("");
+      PRINT(stringEscapedLexical(ast.value));
+    });
+    if (ast.langOrIri) {
+      if (typeof ast.langOrIri === "string") {
+        astFactory.printFilter(ast, () => PRINT("@", ast.langOrIri));
+      } else {
+        astFactory.printFilter(ast, () => PRINT("^^"));
+        SUBRULE(iri, ast.langOrIri);
+      }
+    }
+  }
+};
+const numericLiteral = {
+  name: "numericLiteral",
+  impl: ({ SUBRULE, OR }) => () => OR([
+    { ALT: () => SUBRULE(numericLiteralUnsigned) },
+    { ALT: () => SUBRULE(numericLiteralPositive) },
+    { ALT: () => SUBRULE(numericLiteralNegative) }
+  ])
+};
+const numericLiteralUnsigned = {
+  name: "numericLiteralUnsigned",
+  impl: ({ ACTION, CONSUME, OR }) => (C) => {
+    const parsed = OR([
+      { ALT: () => [CONSUME(l.terminals.integer), import_utils.CommonIRIs.INTEGER] },
+      { ALT: () => [CONSUME(l.terminals.decimal), import_utils.CommonIRIs.DECIMAL] },
+      { ALT: () => [CONSUME(l.terminals.double), import_utils.CommonIRIs.DOUBLE] }
+    ]);
+    return ACTION(() => C.astFactory.termLiteral(C.astFactory.sourceLocation(parsed[0]), parsed[0].image, C.astFactory.termNamed(C.astFactory.sourceLocationNoMaterialize(), parsed[1])));
+  }
+};
+const numericLiteralPositive = {
+  name: "numericLiteralPositive",
+  impl: ({ ACTION, CONSUME, OR }) => (C) => {
+    const parsed = OR([
+      { ALT: () => [CONSUME(l.terminals.integerPositive), import_utils.CommonIRIs.INTEGER] },
+      { ALT: () => [CONSUME(l.terminals.decimalPositive), import_utils.CommonIRIs.DECIMAL] },
+      { ALT: () => [CONSUME(l.terminals.doublePositive), import_utils.CommonIRIs.DOUBLE] }
+    ]);
+    return ACTION(() => C.astFactory.termLiteral(C.astFactory.sourceLocation(parsed[0]), parsed[0].image, C.astFactory.termNamed(C.astFactory.sourceLocationNoMaterialize(), parsed[1])));
+  }
+};
+const numericLiteralNegative = {
+  name: "numericLiteralNegative",
+  impl: ({ ACTION, CONSUME, OR }) => (C) => {
+    const parsed = OR([
+      { ALT: () => [CONSUME(l.terminals.integerNegative), import_utils.CommonIRIs.INTEGER] },
+      { ALT: () => [CONSUME(l.terminals.decimalNegative), import_utils.CommonIRIs.DECIMAL] },
+      { ALT: () => [CONSUME(l.terminals.doubleNegative), import_utils.CommonIRIs.DOUBLE] }
+    ]);
+    return ACTION(() => C.astFactory.termLiteral(C.astFactory.sourceLocation(parsed[0]), parsed[0].image, C.astFactory.termNamed(C.astFactory.sourceLocationNoMaterialize(), parsed[1])));
+  }
+};
+const booleanLiteral = {
+  name: "booleanLiteral",
+  impl: ({ ACTION, CONSUME, OR }) => (C) => {
+    const token = OR([
+      { ALT: () => CONSUME(l.true_) },
+      { ALT: () => CONSUME(l.false_) }
+    ]);
+    return ACTION(() => C.astFactory.termLiteral(C.astFactory.sourceLocation(token), token.image.toLowerCase(), C.astFactory.termNamed(C.astFactory.sourceLocationNoMaterialize(), import_utils.CommonIRIs.BOOLEAN)));
+  }
+};
+const string = {
+  name: "string",
+  impl: ({ ACTION, CONSUME, OR }) => (C) => {
+    const x = OR([
+      { ALT: () => {
+        const token = CONSUME(l.terminals.stringLiteral1);
+        return [token, token.image.slice(1, -1)];
+      } },
+      { ALT: () => {
+        const token = CONSUME(l.terminals.stringLiteral2);
+        return [token, token.image.slice(1, -1)];
+      } },
+      { ALT: () => {
+        const token = CONSUME(l.terminals.stringLiteralLong1);
+        return [token, token.image.slice(3, -3)];
+      } },
+      { ALT: () => {
+        const token = CONSUME(l.terminals.stringLiteralLong2);
+        return [token, token.image.slice(3, -3)];
+      } }
+    ]);
+    return ACTION(() => {
+      const F = C.astFactory;
+      const value = x[1].replaceAll(/\\([tnrbf"'\\])/gu, (_, char) => {
+        switch (char) {
+          case "t":
+            return "	";
+          case "n":
+            return "\n";
+          case "r":
+            return "\r";
+          case "b":
+            return "\b";
+          case "f":
+            return "\f";
+          default:
+            return char;
+        }
+      });
+      return F.termLiteral(F.sourceLocation(x[0]), value);
+    });
+  }
+};
+const iri = {
+  name: "iri",
+  impl: ({ SUBRULE, OR }) => () => OR([
+    { ALT: () => SUBRULE(iriFull) },
+    { ALT: () => SUBRULE(prefixedName) }
+  ]),
+  gImpl: ({ SUBRULE }) => (ast, { astFactory: F }) => F.isTermNamedPrefixed(ast) ? SUBRULE(prefixedName, ast) : SUBRULE(iriFull, ast)
+};
+const iriFull = {
+  name: "iriFull",
+  impl: ({ ACTION, CONSUME }) => (C) => {
+    const iriToken = CONSUME(l.terminals.iriRef);
+    return ACTION(() => C.astFactory.termNamed(C.astFactory.sourceLocation(iriToken), iriToken.image.slice(1, -1)));
+  },
+  gImpl: ({ PRINT }) => (ast, { astFactory: F }) => {
+    F.printFilter(ast, () => PRINT("<", ast.value, ">"));
+  }
+};
+const prefixedName = {
+  name: "prefixedName",
+  impl: ({ ACTION, CONSUME, OR }) => (C) => OR([
+    { ALT: () => {
+      const longName = CONSUME(l.terminals.pNameLn);
+      return ACTION(() => {
+        const [prefix, localName] = longName.image.split(":");
+        return C.astFactory.termNamed(C.astFactory.sourceLocation(longName), localName, prefix);
+      });
+    } },
+    { ALT: () => {
+      const shortName = CONSUME(l.terminals.pNameNs);
+      return ACTION(() => C.astFactory.termNamed(C.astFactory.sourceLocation(shortName), "", shortName.image.slice(0, -1)));
+    } }
+  ]),
+  gImpl: ({ PRINT }) => (ast, { astFactory: F }) => {
+    F.printFilter(ast, () => PRINT(ast.prefix, ":", ast.value));
+  }
+};
+const canCreateBlankNodes = Symbol("canCreateBlankNodes");
+const blankNode = {
+  name: "blankNode",
+  impl: ({ ACTION, CONSUME, OR }) => (C) => {
+    const result = OR([
+      { ALT: () => {
+        const labelToken = CONSUME(l.terminals.blankNodeLabel);
+        return ACTION(() => C.astFactory.termBlank(labelToken.image.slice(2), C.astFactory.sourceLocation(labelToken)));
+      } },
+      { ALT: () => {
+        const anonToken = CONSUME(l.terminals.anon);
+        return ACTION(() => C.astFactory.termBlank(void 0, C.astFactory.sourceLocation(anonToken)));
+      } }
+    ]);
+    ACTION(() => {
+      if (!C.parseMode.has("canCreateBlankNodes")) {
+        throw new Error("Blank nodes are not allowed in this context");
+      }
+    });
+    return result;
+  },
+  gImpl: ({ PRINT }) => (ast, { astFactory }) => {
+    astFactory.printFilter(ast, () => PRINT("_:", ast.label.replace(/^e_/u, "")));
+  }
+};
+const verbA = {
+  name: "VerbA",
+  impl: ({ ACTION, CONSUME }) => (C) => {
+    const token = CONSUME(l.a);
+    return ACTION(() => C.astFactory.termNamed(C.astFactory.sourceLocation(token), import_utils.CommonIRIs.TYPE, void 0));
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  blankNode,
+  booleanLiteral,
+  canCreateBlankNodes,
+  iri,
+  iriFull,
+  numericLiteral,
+  numericLiteralNegative,
+  numericLiteralPositive,
+  numericLiteralUnsigned,
+  prefixedName,
+  rdfLiteral,
+  string,
+  stringEscapedLexical,
+  verbA
+});

package/dist/cjs/lib/grammar/propertyPaths.js

@@ -0,0 +1,206 @@
+"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 __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 propertyPaths_exports = {};
+__export(propertyPaths_exports, {
+  path: () => path,
+  pathAlternative: () => pathAlternative,
+  pathChainHelper: () => pathChainHelper,
+  pathElt: () => pathElt,
+  pathEltOrInverse: () => pathEltOrInverse,
+  pathGenerator: () => pathGenerator,
+  pathMod: () => pathMod,
+  pathNegatedPropertySet: () => pathNegatedPropertySet,
+  pathOneInPropertySet: () => pathOneInPropertySet,
+  pathPrimary: () => pathPrimary,
+  pathSequence: () => pathSequence
+});
+module.exports = __toCommonJS(propertyPaths_exports);
+var l = __toESM(require("../lexer/index.js"), 1);
+var import_literals = require("./literals.js");
+const path = {
+  name: "path",
+  impl: ({ SUBRULE }) => () => SUBRULE(pathAlternative)
+};
+const pathGenerator = {
+  name: "path",
+  gImpl: ({ PRINT, SUBRULE }) => (ast, { astFactory: F }, braces = true) => {
+    if (F.isTerm(ast) && F.isTermNamed(ast)) {
+      SUBRULE(import_literals.iri, ast);
+    } else {
+      F.printFilter(ast, () => braces && PRINT("("));
+      switch (ast.subType) {
+        case "|":
+        case "/": {
+          const [head, ...tail] = ast.items;
+          SUBRULE(pathGenerator, head, braces);
+          for (const val of tail) {
+            F.printFilter(ast, () => PRINT(ast.subType));
+            SUBRULE(pathGenerator, val, braces);
+          }
+          break;
+        }
+        case "^":
+          F.printFilter(ast, () => PRINT("^"));
+          SUBRULE(pathGenerator, ast.items[0], braces);
+          break;
+        case "?":
+        case "*":
+        case "+":
+          SUBRULE(pathGenerator, ast.items[0], braces);
+          F.printFilter(ast, () => PRINT(ast.subType));
+          break;
+        case "!":
+          F.printFilter(ast, () => PRINT("!"));
+          F.printFilter(ast, () => PRINT("("));
+          SUBRULE(pathGenerator, ast.items[0], false);
+          F.printFilter(ast, () => PRINT(")"));
+          break;
+      }
+      F.printFilter(ast, () => braces && PRINT(")"));
+    }
+  }
+};
+function pathChainHelper(name, SEP, subType, subRule) {
+  return {
+    name,
+    impl: ({ ACTION, CONSUME, SUBRULE1, SUBRULE2, MANY }) => (C) => {
+      const head = SUBRULE1(subRule);
+      let tailEnd = head;
+      const tail = [];
+      MANY(() => {
+        CONSUME(SEP);
+        tailEnd = SUBRULE2(subRule);
+        tail.push(tailEnd);
+      });
+      return ACTION(() => tail.length === 0 ? head : C.astFactory.path(subType, [head, ...tail], C.astFactory.sourceLocation(head, tailEnd)));
+    }
+  };
+}
+const pathEltOrInverse = {
+  name: "pathEltOrInverse",
+  impl: ({ ACTION, CONSUME, SUBRULE1, SUBRULE2, OR }) => (C) => OR([
+    { ALT: () => SUBRULE1(pathElt) },
+    { ALT: () => {
+      const hat = CONSUME(l.symbols.hat);
+      const item = SUBRULE2(pathElt);
+      return ACTION(() => C.astFactory.path("^", [item], C.astFactory.sourceLocation(hat, item)));
+    } }
+  ])
+};
+const pathSequence = pathChainHelper("pathSequence", l.symbols.slash, "/", pathEltOrInverse);
+const pathAlternative = pathChainHelper("pathAlternative", l.symbols.pipe, "|", pathSequence);
+const pathElt = {
+  name: "pathElt",
+  impl: ({ ACTION, SUBRULE, OPTION }) => (C) => {
+    const item = SUBRULE(pathPrimary);
+    const modification = OPTION(() => SUBRULE(pathMod));
+    return ACTION(() => modification === void 0 ? item : C.astFactory.path(modification.image, [item], C.astFactory.sourceLocation(item, modification)));
+  }
+};
+const pathMod = {
+  name: "pathMod",
+  impl: ({ CONSUME, OR }) => () => OR([
+    { ALT: () => CONSUME(l.symbols.question) },
+    { ALT: () => CONSUME(l.symbols.star) },
+    { ALT: () => CONSUME(l.symbols.opPlus) }
+  ])
+};
+const pathPrimary = {
+  name: "pathPrimary",
+  impl: ({ SUBRULE, CONSUME, OR }) => () => OR([
+    { ALT: () => SUBRULE(import_literals.iri) },
+    { ALT: () => SUBRULE(import_literals.verbA) },
+    { ALT: () => SUBRULE(pathNegatedPropertySet) },
+    { ALT: () => {
+      CONSUME(l.symbols.LParen);
+      const resRecursive = SUBRULE(path);
+      CONSUME(l.symbols.RParen);
+      return resRecursive;
+    } }
+  ])
+};
+const pathNegatedPropertySet = {
+  name: "pathNegatedPropertySet",
+  impl: ({ ACTION, CONSUME, SUBRULE1, SUBRULE2, SUBRULE3, OR, MANY }) => (C) => {
+    const exclamation = CONSUME(l.symbols.exclamation);
+    return OR([
+      { ALT: () => {
+        const noAlternative = SUBRULE1(pathOneInPropertySet);
+        return ACTION(() => C.astFactory.path("!", [noAlternative], C.astFactory.sourceLocation(exclamation, noAlternative)));
+      } },
+      { ALT: () => {
+        const open = CONSUME(l.symbols.LParen);
+        const head = SUBRULE2(pathOneInPropertySet);
+        const tail = [];
+        MANY(() => {
+          CONSUME(l.symbols.pipe);
+          const item = SUBRULE3(pathOneInPropertySet);
+          tail.push(item);
+        });
+        const close = CONSUME(l.symbols.RParen);
+        return ACTION(() => {
+          const F = C.astFactory;
+          if (tail.length === 0) {
+            return F.path("!", [head], F.sourceLocation(exclamation, close));
+          }
+          return F.path("!", [F.path("|", [head, ...tail], F.sourceLocation(open, close))], F.sourceLocation(exclamation, close));
+        });
+      } }
+    ]);
+  }
+};
+const pathOneInPropertySet = {
+  name: "pathOneInPropertySet",
+  impl: ({ ACTION, CONSUME, SUBRULE1, SUBRULE2, OR1, OR2 }) => (C) => OR1([
+    { ALT: () => SUBRULE1(import_literals.iri) },
+    { ALT: () => SUBRULE1(import_literals.verbA) },
+    { ALT: () => {
+      const hat = CONSUME(l.symbols.hat);
+      const item = OR2([
+        { ALT: () => SUBRULE2(import_literals.iri) },
+        { ALT: () => SUBRULE2(import_literals.verbA) }
+      ]);
+      return ACTION(() => C.astFactory.path("^", [item], C.astFactory.sourceLocation(hat, item)));
+    } }
+  ])
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  path,
+  pathAlternative,
+  pathChainHelper,
+  pathElt,
+  pathEltOrInverse,
+  pathGenerator,
+  pathMod,
+  pathNegatedPropertySet,
+  pathOneInPropertySet,
+  pathPrimary,
+  pathSequence
+});