@traqula/test-utils 0.0.20 → 0.0.22

package/dist/cjs/lib/Sparql11NotesTest.js

@@ -0,0 +1,278 @@
+"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 Sparql11NotesTest_exports = {};
+__export(Sparql11NotesTest_exports, {
+  importSparql11NoteTests: () => importSparql11NoteTests
+});
+module.exports = __toCommonJS(Sparql11NotesTest_exports);
+var import_vitest = require("vitest");
+function importSparql11NoteTests(parser, dataFactory) {
+  function testErroneousQuery(query, _errorMsg) {
+    return ({ expect }) => {
+      let error;
+      try {
+        parser.parse(query);
+      } catch (e) {
+        error = e;
+      }
+      expect(error).not.toBeUndefined();
+      expect(error).toBeInstanceOf(Error);
+    };
+  }
+  (0, import_vitest.it)("should throw an error on an invalid query", testErroneousQuery("invalid", "Parse error on line 1"));
+  import_vitest.it.skip("should throw an error on a projection of ungrouped variable", testErroneousQuery("PREFIX : <http://www.example.org/> SELECT ?o WHERE { ?s ?p ?o } GROUP BY ?s", "Projection of ungrouped variable (?o)"));
+  (0, import_vitest.it)("should throw an error on a values class with LESS variables than value", testErroneousQuery("SELECT * WHERE { } VALUES ( ?S ) { ( true  false ) }", "Number of dataBlockValues does not match number of variables. Too much values."));
+  (0, import_vitest.it)("should throw an error on a values class with MORE variables than value", testErroneousQuery("SELECT * WHERE { } VALUES ( ?S ?O ) { ( true ) }", "Number of dataBlockValues does not match number of variables. Too few values."));
+  (0, import_vitest.it)("should NOT throw on a values class with correct amount of values", ({ expect }) => {
+    const query = "SELECT * WHERE { } VALUES ( ?S ) { ( true ) }";
+    expect(parser.parse(query)).toMatchObject({});
+  });
+  import_vitest.it.skip("should throw an error on an invalid selectscope", testErroneousQuery("SELECT (1 AS ?X ) { SELECT (2 AS ?X ) {} }", "Target id of 'AS' (?X) already used in subquery"));
+  import_vitest.it.skip("should throw an error on bind to variable in scope", testErroneousQuery("SELECT * { ?s ?p ?o BIND(?o AS ?o) }", "Target id of 'AS' (?X) already used in subquery"));
+  (0, import_vitest.it)("should parse when not ending in newline", ({ expect }) => {
+    const query = "select?s{?s?p?o}#wow, what a query";
+    expect(parser.parse(query)).toMatchObject({});
+  });
+  (0, import_vitest.it)("should preserve BGP and filter pattern order", ({ expect }) => {
+    const query = 'SELECT * { ?s ?p "1" . FILTER(true) . ?s ?p "2"  }';
+    expect(parser.parse(query)).toMatchObject({
+      where: {
+        patterns: [
+          { subType: "bgp" },
+          { subType: "filter" },
+          { subType: "bgp" }
+        ]
+      }
+    });
+  });
+  (0, import_vitest.it)("should throw an error on an aggregate function within an aggregate function", testErroneousQuery("SELECT (SUM(COUNT(?lprice)) AS ?totalPrice) { }", "An aggregate function is not allowed within an aggregate function"));
+  (0, import_vitest.describe)("with pre-defined prefixes", () => {
+    const prefixes = { a: "ex:abc#", b: "ex:def#" };
+    import_vitest.it.skip("should use those prefixes", ({ expect }) => {
+      const query = 'SELECT * { a:a b:b "" }';
+      expect(parser.parse(query, { prefixes })).toMatchObject({
+        where: [
+          {
+            triples: [
+              {
+                subject: dataFactory.namedNode("ex:abc#a"),
+                predicate: dataFactory.namedNode("ex:def#b"),
+                object: dataFactory.literal("")
+              }
+            ]
+          }
+        ]
+      });
+    });
+    import_vitest.it.skip("should allow temporarily overriding prefixes", ({ expect }) => {
+      const query = 'PREFIX a: <ex:xyz#> SELECT * { a:a b:b "" }';
+      expect(parser.parse(query, { prefixes })).toMatchObject({
+        where: [
+          {
+            triples: [{
+              subject: dataFactory.namedNode("ex:xyz#a"),
+              predicate: dataFactory.namedNode("ex:def#b"),
+              object: dataFactory.literal("")
+            }]
+          }
+        ]
+      });
+      const query2 = 'SELECT * { a:a b:b "" }';
+      expect(parser.parse(query2, { prefixes })).toMatchObject({
+        where: [
+          {
+            triples: [{
+              subject: dataFactory.namedNode("ex:abc#a"),
+              predicate: dataFactory.namedNode("ex:def#b"),
+              object: dataFactory.literal("")
+            }]
+          }
+        ]
+      });
+    });
+    (0, import_vitest.it)("should not change the original prefixes", ({ expect }) => {
+      expect(prefixes).toEqual({ a: "ex:abc#", b: "ex:def#" });
+    });
+  });
+  (0, import_vitest.describe)("with pre-defined base IRI", () => {
+    const context = { baseIRI: "http://ex.org/" };
+    import_vitest.it.skip("contains the base", ({ expect }) => {
+      const query = "SELECT * { ?s ?p ?o }";
+      expect(parser.parse(query, context)).toMatchObject({
+        base: "http://ex.org/"
+      });
+    });
+    import_vitest.it.skip("using prefixed as relative iri", ({ expect }) => {
+      const context2 = { baseIRI: "http://ex.org/apl" };
+      const query = `
+CONSTRUCT
+FROM <data.ttl>
+WHERE { ?s ?p ?o }
+`;
+      expect(parser.parse(query, context2)).toMatchObject({
+        from: {
+          default: [
+            dataFactory.namedNode("http://ex.org/data.ttl")
+          ]
+        }
+      });
+    });
+    import_vitest.it.skip("should use the base IRI", ({ expect }) => {
+      const query = 'SELECT * { <> <#b> "" }';
+      const result = {
+        subject: dataFactory.namedNode("http://ex.org/"),
+        predicate: dataFactory.namedNode("http://ex.org/#b"),
+        object: dataFactory.literal("")
+      };
+      expect(parser.parse(query, context)).toMatchObject({
+        where: [{ triples: [result] }]
+      });
+    });
+    import_vitest.it.skip("should work after a previous query failed", ({ expect }) => {
+      const badQuery = 'SELECT * { <> <#b> "" } invalid!';
+      expect(() => parser.parse(badQuery, context2)).toThrow(Error);
+      const goodQuery = 'SELECT * { <> <#b> "" }';
+      const context2 = { baseIRI: "http://ex2.org/" };
+      const result = {
+        subject: dataFactory.namedNode("http://ex2.org/"),
+        predicate: dataFactory.namedNode("http://ex2.org/#b"),
+        object: dataFactory.literal("")
+      };
+      const data = parser.parse(goodQuery, context2);
+      expect(data).toMatchObject({
+        where: [{ triples: [result] }]
+      });
+    });
+  });
+  import_vitest.it.skip("should throw an error on relative IRIs if no base IRI is specified", testErroneousQuery("SELECT * { <a> <b> <c> }", "Cannot resolve relative IRI a because no base IRI was set."));
+  (0, import_vitest.describe)("with group collapsing disabled", () => {
+    import_vitest.it.skip("should keep explicit pattern group", ({ expect }) => {
+      const query = "SELECT * WHERE { { ?s ?p ?o } ?a ?b ?c }";
+      const result = [
+        {
+          type: "group",
+          patterns: [
+            {
+              type: "bgp",
+              triples: [
+                {
+                  subject: dataFactory.variable("s"),
+                  predicate: dataFactory.variable("p"),
+                  object: dataFactory.variable("o")
+                }
+              ]
+            }
+          ]
+        },
+        {
+          type: "bgp",
+          triples: [
+            {
+              subject: dataFactory.variable("a"),
+              predicate: dataFactory.variable("b"),
+              object: dataFactory.variable("c")
+            }
+          ]
+        }
+      ];
+      expect(parser.parse(query)).toMatchObject({ where: result });
+    });
+    import_vitest.it.skip("should still collapse immediate union groups", ({ expect }) => {
+      const query = "SELECT * WHERE { { ?s ?p ?o } UNION { ?a ?b ?c } }";
+      const result = [
+        {
+          type: "union",
+          patterns: [{
+            type: "bgp",
+            triples: [{
+              subject: {
+                termType: "Variable",
+                value: "s"
+              },
+              predicate: {
+                termType: "Variable",
+                value: "p"
+              },
+              object: {
+                termType: "Variable",
+                value: "o"
+              }
+            }]
+          }, {
+            type: "bgp",
+            triples: [{
+              subject: {
+                termType: "Variable",
+                value: "a"
+              },
+              predicate: {
+                termType: "Variable",
+                value: "b"
+              },
+              object: {
+                termType: "Variable",
+                value: "c"
+              }
+            }]
+          }]
+        }
+      ];
+      expect(parser.parse(query)).toMatchObject({ where: result });
+    });
+  });
+  (0, import_vitest.describe)("for update queries", () => {
+    (0, import_vitest.it)("should throw an error on blank nodes in DELETE clause", testErroneousQuery('DELETE { ?a <ex:knows> [] . } WHERE { ?a <ex:knows> "Alan" . }', "Detected illegal blank node in BGP"));
+    (0, import_vitest.it)("should not throw on blank nodes in INSERT clause", ({ expect }) => {
+      const query = 'INSERT { ?a <ex:knows> [] . } WHERE { ?a <ex:knows> "Alan" . }';
+      expect(parser.parse(query)).toMatchObject({});
+    });
+    (0, import_vitest.it)("should throw an error on blank nodes in compact DELETE clause", testErroneousQuery("DELETE WHERE { _:a <ex:p> <ex:o> }", "Detected illegal blank node in BGP"));
+    (0, import_vitest.it)("should throw an error on variables in DELETE DATA clause", testErroneousQuery("DELETE DATA { ?a <ex:p> <ex:o> }", "Detected illegal variable in BGP"));
+    (0, import_vitest.it)("should throw an error on blank nodes in DELETE DATA clause", testErroneousQuery("DELETE DATA { _:a <ex:p> <ex:o> }", "Detected illegal blank node in BGP"));
+    (0, import_vitest.it)("should throw an error on variables in DELETE DATA clause with GRAPH", testErroneousQuery("DELETE DATA { GRAPH ?a { <ex:s> <ex:p> <ex:o> } }", "Detected illegal variable in GRAPH"));
+    (0, import_vitest.it)("should throw an error on variables in INSERT DATA clause", testErroneousQuery("INSERT DATA { ?a <ex:p> <ex:o> }", "Detected illegal variable in BGP"));
+    (0, import_vitest.it)("should not throw on reused blank nodes in one INSERT DATA clause", ({ expect }) => {
+      const query = "INSERT DATA { _:a <ex:p> <ex:o> . _:a <ex:p> <ex:o> . }";
+      expect(parser.parse(query)).toMatchObject({});
+    });
+    import_vitest.it.skip("should throw an error on reused blank nodes across INSERT DATA clauses", testErroneousQuery("INSERT DATA { _:a <ex:p> <ex:o> }; INSERT DATA { _:a <ex:p> <ex:o> }", "Detected reuse blank node across different INSERT DATA clauses"));
+    import_vitest.it.skip("should throw an error on reused blank nodes across INSERT DATA clauses with GRAPH", testErroneousQuery("INSERT DATA { _:a <ex:p> <ex:o> }; INSERT DATA { GRAPH <ex:g> { _:a <ex:p> <ex:o> } }", "Detected reuse blank node across different INSERT DATA clauses"));
+    (0, import_vitest.it)("should not throw on comment between INSERT and DATA", ({ expect }) => {
+      const query = `INSERT
+# Comment
+DATA { GRAPH <ex:G> { <ex:s> <ex:p> 'o1', 'o2', 'o3' } }`;
+      expect(parser.parse(query)).toMatchObject({});
+    });
+    (0, import_vitest.it)("should not throw on comment after INSERT that could be confused with DATA", ({ expect }) => {
+      const query = `INSERT # DATA
+DATA { GRAPH <ex:G> { <ex:s> <ex:p> 'o1', 'o2', 'o3' } }`;
+      expect(parser.parse(query)).toMatchObject({});
+    });
+    (0, import_vitest.it)("should throw an error on commented DATA after INSERT", testErroneousQuery("INSERT # DATA { GRAPH <ex:G> { <ex:s> <ex:p> 'o1', 'o2', 'o3' } }", "Parse error"));
+  });
+  (0, import_vitest.it)("should throw an error on unicode codepoint escaping in literal with partial surrogate pair", testErroneousQuery("SELECT * WHERE { ?s <ex:p> '\uD800' }", "Invalid unicode codepoint of surrogate pair without corresponding codepoint"));
+  (0, import_vitest.it)("should not throw an error on unicode codepoint escaping in literal with complete surrogate pair", ({ expect }) => {
+    const query = "SELECT * WHERE { ?s <ex:p> '\u{103FF}' }";
+    expect(parser.parse(query)).toMatchObject({});
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  importSparql11NoteTests
+});

package/dist/cjs/lib/fileUtils.js

@@ -0,0 +1,49 @@
+"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 fileUtils_exports = {};
+__export(fileUtils_exports, {
+  readFile: () => readFile,
+  readFileSync: () => readFileSync
+});
+module.exports = __toCommonJS(fileUtils_exports);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_promises = __toESM(require("node:fs/promises"), 1);
+async function readFile(path, encoding = "utf-8") {
+  const content = await import_promises.default.readFile(path, encoding);
+  return content.replaceAll(/\r?\n/gu, "\n");
+}
+function readFileSync(path, encoding = "utf-8") {
+  const content = import_node_fs.default.readFileSync(path, encoding);
+  return content.replaceAll(/\r?\n/gu, "\n");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  readFile,
+  readFileSync
+});

package/dist/cjs/lib/generators/algebraGenerators.js

@@ -0,0 +1,91 @@
+"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 algebraGenerators_exports = {};
+__export(algebraGenerators_exports, {
+  sparqlAlgebraTests: () => sparqlAlgebraTests,
+  sparqlQueries: () => sparqlQueries
+});
+module.exports = __toCommonJS(algebraGenerators_exports);
+var fs = __toESM(require("node:fs"), 1);
+var path = __toESM(require("node:path"), 1);
+var import_fileUtils = require("../fileUtils.js");
+var import_utils = require("./utils.js");
+const rootDir = (0, import_utils.getStaticFilePath)("algebra");
+const rootSparql = path.join(rootDir, "sparql");
+const rootJson = path.join(rootDir, "algebra");
+const rootJsonBlankToVariable = path.join(rootDir, "algebra-blank-to-var");
+function* sparqlAlgebraTests(suite, blankToVariable, getSPARQL) {
+  function* subGen(relativePath) {
+    const absolutePath = path.join(blankToVariable ? rootJsonBlankToVariable : rootJson, relativePath);
+    if (fs.lstatSync(absolutePath).isDirectory()) {
+      for (const sub of fs.readdirSync(absolutePath)) {
+        yield* subGen(path.join(relativePath, sub));
+      }
+    } else {
+      const name = relativePath.replace(/\.json$/u, "");
+      const sparqlPath = path.join(rootSparql, relativePath.replace(/\.json/u, ".sparql"));
+      yield {
+        name,
+        json: JSON.parse((0, import_fileUtils.readFileSync)(absolutePath)),
+        sparql: getSPARQL ? (0, import_fileUtils.readFileSync)(sparqlPath, "utf8") : void 0,
+        quads: name.endsWith("-quads")
+      };
+    }
+  }
+  const subfolders = fs.readdirSync(blankToVariable ? rootJsonBlankToVariable : rootJson);
+  if (subfolders.includes(suite)) {
+    yield* subGen(suite);
+  }
+}
+function* sparqlQueries(suite) {
+  function* subGen(relativePath) {
+    const absolutePath = path.join(rootSparql, relativePath);
+    if (fs.lstatSync(absolutePath).isDirectory()) {
+      for (const sub of fs.readdirSync(absolutePath)) {
+        yield* subGen(path.join(relativePath, sub));
+      }
+    } else {
+      const name = relativePath.replace(/\.sparql$/u, "");
+      const content = fs.readFileSync(absolutePath, "utf-8");
+      yield {
+        name,
+        query: content.replaceAll(/\r?\n/gu, "\n")
+      };
+    }
+  }
+  const subfolders = fs.readdirSync(rootSparql);
+  if (subfolders.includes(suite)) {
+    yield* subGen(suite);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  sparqlAlgebraTests,
+  sparqlQueries
+});

package/dist/cjs/lib/generators/generators.js

@@ -0,0 +1,92 @@
+"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 generators_exports = {};
+__export(generators_exports, {
+  negativeTest: () => negativeTest,
+  positiveTest: () => positiveTest
+});
+module.exports = __toCommonJS(generators_exports);
+var fs = __toESM(require("node:fs"), 1);
+var import_fileUtils = require("../fileUtils.js");
+var import_utils = require("./utils.js");
+function* positiveTest(type, filter) {
+  const dir = (0, import_utils.getStaticFilePath)(type);
+  const statics = fs.readdirSync(dir);
+  for (const file of statics) {
+    if (file.endsWith(".json")) {
+      if (filter && !filter(file.replace(".json", ""))) {
+        continue;
+      }
+      yield {
+        name: file.replace(/\.json$/u, ""),
+        statics: async () => {
+          const query = await (0, import_fileUtils.readFile)(`${dir}/${file.replace(".json", ".sparql")}`);
+          const result = await (0, import_fileUtils.readFile)(`${dir}/${file}`);
+          let autoGen;
+          try {
+            autoGen = await (0, import_fileUtils.readFile)(`${dir}/${file.replace(".json", "-generated.sparql")}`);
+          } catch {
+            autoGen = query;
+          }
+          const json = JSON.parse(result);
+          return {
+            query,
+            ast: json,
+            autoGen
+          };
+        }
+      };
+    }
+  }
+}
+function* negativeTest(type, filter) {
+  const dir = (0, import_utils.getStaticFilePath)(type);
+  const statics = fs.readdirSync(dir);
+  for (const file of statics) {
+    if (file.endsWith(".sparql")) {
+      if (filter && !filter(file.replace(".sparql", ""))) {
+        continue;
+      }
+      yield {
+        name: file.replace(/\.sparql$/u, ""),
+        statics: async () => {
+          const query = await (0, import_fileUtils.readFile)(`${dir}/${file}`);
+          return {
+            query
+          };
+        }
+      };
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  negativeTest,
+  positiveTest
+});

package/dist/cjs/lib/generators/utils.js

@@ -0,0 +1,42 @@
+"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 utils_exports = {};
+__export(utils_exports, {
+  getStaticFilePath: () => getStaticFilePath
+});
+module.exports = __toCommonJS(utils_exports);
+var import_node_path = __toESM(require("node:path"), 1);
+const staticsPath = import_node_path.default.join(__dirname, "..", "..", "..", "..", "statics");
+function getStaticFilePath(...paths) {
+  return import_node_path.default.join(staticsPath, ...paths);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getStaticFilePath
+});

package/dist/cjs/lib/index.js

@@ -0,0 +1,34 @@
+"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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var index_exports = {};
+module.exports = __toCommonJS(index_exports);
+__reExport(index_exports, require("./matchers/toEqualParsedQuery.js"), module.exports);
+__reExport(index_exports, require("./matchers/vitest.js"), module.exports);
+__reExport(index_exports, require("./generators/generators.js"), module.exports);
+__reExport(index_exports, require("./generators/algebraGenerators.js"), module.exports);
+__reExport(index_exports, require("./generators/utils.js"), module.exports);
+__reExport(index_exports, require("./Sparql11NotesTest.js"), module.exports);
+__reExport(index_exports, require("./fileUtils.js"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./matchers/toEqualParsedQuery.js"),
+  ...require("./matchers/vitest.js"),
+  ...require("./generators/generators.js"),
+  ...require("./generators/algebraGenerators.js"),
+  ...require("./generators/utils.js"),
+  ...require("./Sparql11NotesTest.js"),
+  ...require("./fileUtils.js")
+});

package/dist/cjs/lib/matchers/toEqualParsedQuery.js

@@ -0,0 +1,91 @@
+"use strict";
+var import_vitest = require("vitest");
+import_vitest.expect.extend({
+  toEqualParsedQuery(received, expected) {
+    const pass = objectsEqual(received, expected, () => false, []);
+    const message = pass ? () => `${this.utils.matcherHint("toEqualParsedQuery")}
+
+Expected: ${this.utils.printExpected(expected)}
+Received: ${this.utils.printReceived(received)}` : () => {
+      const diffString = this.utils.diff(expected, received, {
+        expand: this.expand
+      });
+      return `${this.utils.matcherHint("toEqualParsedQuery")}
+
+${diffString && diffString.includes("- Expect") ? `Difference:
+
+${diffString}` : `Expected: ${this.utils.printExpected(expected)}
+Received: ${this.utils.printReceived(received)}`}`;
+    };
+    return { pass, message };
+  },
+  toEqualParsedQueryIgnoring(received, selector, ignoreKeys, expected) {
+    const pass = objectsEqual(received, expected, selector, ignoreKeys);
+    const message = pass ? () => `${this.utils.matcherHint("toEqualParsedQuery")}
+
+Expected: ${this.utils.printExpected(expected)}
+Received: ${this.utils.printReceived(received)}` : () => {
+      const diffString = this.utils.diff(expected, received, {
+        expand: this.expand
+      });
+      return `${this.utils.matcherHint("toEqualParsedQuery")}
+
+${diffString && diffString.includes("- Expect") ? `Difference:
+
+${diffString}` : `Expected: ${this.utils.printExpected(expected)}
+Received: ${this.utils.printReceived(received)}`}`;
+    };
+    return { pass, message };
+  }
+});
+function objectsEqual(received, expected, selector, ignoreKeys) {
+  if (received === void 0 || received === null || isPrimitive(received)) {
+    return received === expected;
+  }
+  if (isTerm(received)) {
+    return received.equals(expected);
+  }
+  if (isTerm(expected)) {
+    return expected.equals(received);
+  }
+  if (Array.isArray(received)) {
+    if (!Array.isArray(expected)) {
+      return false;
+    }
+    if (received.length !== expected.length) {
+      return false;
+    }
+    for (const [i, element] of received.entries()) {
+      if (!objectsEqual(element, expected[i], selector, ignoreKeys)) {
+        return false;
+      }
+    }
+  } else {
+    if (expected === void 0 || expected === null || isPrimitive(expected) || Array.isArray(expected)) {
+      return false;
+    }
+    const keys_first = Object.keys(received);
+    const receivedMatches = selector(received);
+    for (const key of keys_first) {
+      if (receivedMatches && ignoreKeys.includes(key)) {
+        continue;
+      }
+      if (!objectsEqual(received[key], expected[key], selector, ignoreKeys)) {
+        return false;
+      }
+    }
+    const keys_second = Object.keys(expected);
+    for (const key of keys_second) {
+      if (!objectsEqual(received[key], expected[key], selector, ignoreKeys)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function isTerm(value) {
+  return false;
+}
+function isPrimitive(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}