@shaclmate/validator 4.0.60

package/dist/JenaValidator.d.ts

@@ -0,0 +1,17 @@
+import type PrefixMap from "@rdfjs/prefix-map/PrefixMap.js";
+import type { DatasetCore } from "@rdfjs/types";
+import { ValidationReport } from "@shaclmate/shacl-ast";
+import { type Either, Maybe } from "purify-ts";
+import { type Logger } from "ts-log";
+import { Validator } from "./Validator.js";
+export declare class JenaValidator extends Validator {
+    private jenaShaclFilePath;
+    private constructor();
+    static create({ logger, prefixMap, shapesGraph, }: {
+        logger?: Logger;
+        prefixMap?: PrefixMap;
+        shapesGraph: DatasetCore;
+    }): Promise<Either<Error, Maybe<JenaValidator>>>;
+    validate(dataGraph: DatasetCore): Promise<Either<Error, ValidationReport>>;
+}
+//# sourceMappingURL=JenaValidator.d.ts.map

package/dist/JenaValidator.js

@@ -0,0 +1,73 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { Readable } from "node:stream";
+import datasetFactory from "@rdfjs/dataset";
+import dataFactory from "@rdfx/data-factory";
+import parsers from "@rdfx/parsers";
+import { ResourceSet } from "@rdfx/resource";
+import { TurtleSerializer } from "@rdfx/serializers";
+import { ValidationReport } from "@shaclmate/shacl-ast";
+import { getStreamAsArray } from "get-stream";
+import { EitherAsync, Maybe } from "purify-ts";
+import tmp from "tmp-promise";
+import { dummyLogger } from "ts-log";
+import which from "which";
+import { execPromisified } from "./execPromisified.js";
+import { Validator } from "./Validator.js";
+export class JenaValidator extends Validator {
+    jenaShaclFilePath;
+    constructor({ jenaShaclFilePath, ...superParameters }) {
+        super(superParameters);
+        this.jenaShaclFilePath = jenaShaclFilePath;
+    }
+    static async create({ logger = dummyLogger, prefixMap, shapesGraph, }) {
+        return EitherAsync(async () => {
+            const jenaShaclFilePath = await which("shacl", { nothrow: true });
+            if (jenaShaclFilePath === null) {
+                return Maybe.empty();
+            }
+            return Maybe.of(new JenaValidator({
+                jenaShaclFilePath,
+                logger,
+                prefixMap,
+                shapesGraph,
+            }));
+        });
+    }
+    async validate(dataGraph) {
+        return EitherAsync(async ({ liftEither }) => await tmp.withDir(async ({ path: tmpDirectoryPath }) => {
+            const dataGraphFilePath = path.join(tmpDirectoryPath, "data.ttl");
+            const serializer = new TurtleSerializer({
+                prefixes: this.prefixMap,
+            });
+            this.logger.debug("writing data graph to %s", dataGraphFilePath);
+            await fs.writeFile(dataGraphFilePath, serializer.transform(dataGraph));
+            this.logger.debug("wrote data graph to %s", dataGraphFilePath);
+            const shapesGraphFilePath = path.join(tmpDirectoryPath, "shapes.ttl");
+            this.logger.debug("writing shapes graph to %s", shapesGraphFilePath);
+            await fs.writeFile(shapesGraphFilePath, serializer.transform(this.shapesGraph));
+            this.logger.debug("wrote shapes graph to %s", shapesGraphFilePath);
+            const args = [
+                "validate",
+                "--data",
+                dataGraphFilePath,
+                "--shapes",
+                shapesGraphFilePath,
+            ];
+            this.logger.debug("validating with Jena (args=%s)", args);
+            const { code, stdout } = await execPromisified(this.jenaShaclFilePath, args);
+            this.logger.debug("validated with Jena: %s", code === 0 ? "conforms" : "does not conform");
+            const validationReportDataset = datasetFactory.dataset(await getStreamAsArray(parsers({ dataFactory }).import("text/turtle", Readable.from(stdout))));
+            for (const rdfTypeQuad of validationReportDataset.match(null, null, ValidationReport.schema.fromRdfType)) {
+                return await liftEither(ValidationReport.fromRdfResource(new ResourceSet({
+                    dataFactory,
+                    dataset: validationReportDataset,
+                }).resource(rdfTypeQuad.subject)));
+            }
+            throw new Error("unable to parse validation report from Jena shacl output");
+        }, {
+            unsafeCleanup: true,
+        }));
+    }
+}
+//# sourceMappingURL=JenaValidator.js.map

package/dist/PyShaclValidator.d.ts

@@ -0,0 +1,17 @@
+import type PrefixMap from "@rdfjs/prefix-map/PrefixMap.js";
+import type { DatasetCore } from "@rdfjs/types";
+import { ValidationReport } from "@shaclmate/shacl-ast";
+import { type Either, Maybe } from "purify-ts";
+import { type Logger } from "ts-log";
+import { Validator } from "./Validator.js";
+export declare class PyShaclValidator extends Validator {
+    private pyShaclFilePath;
+    private constructor();
+    static create({ logger, prefixMap, shapesGraph, }: {
+        logger?: Logger;
+        prefixMap?: PrefixMap;
+        shapesGraph: DatasetCore;
+    }): Promise<Either<Error, Maybe<PyShaclValidator>>>;
+    validate(dataGraph: DatasetCore): Promise<Either<Error, ValidationReport>>;
+}
+//# sourceMappingURL=PyShaclValidator.d.ts.map

package/dist/PyShaclValidator.js

@@ -0,0 +1,73 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { Readable } from "node:stream";
+import datasetFactory from "@rdfjs/dataset";
+import dataFactory from "@rdfx/data-factory";
+import parsers from "@rdfx/parsers";
+import { ResourceSet } from "@rdfx/resource";
+import { TurtleSerializer } from "@rdfx/serializers";
+import { ValidationReport } from "@shaclmate/shacl-ast";
+import { getStreamAsArray } from "get-stream";
+import { EitherAsync, Maybe } from "purify-ts";
+import tmp from "tmp-promise";
+import { dummyLogger } from "ts-log";
+import which from "which";
+import { execPromisified } from "./execPromisified.js";
+import { Validator } from "./Validator.js";
+export class PyShaclValidator extends Validator {
+    pyShaclFilePath;
+    constructor({ pyShaclFilePath, ...superParameters }) {
+        super(superParameters);
+        this.pyShaclFilePath = pyShaclFilePath;
+    }
+    static async create({ logger = dummyLogger, prefixMap, shapesGraph, }) {
+        return EitherAsync(async () => {
+            const pyShaclFilePath = await which("pyshacl", { nothrow: true });
+            if (pyShaclFilePath === null) {
+                return Maybe.empty();
+            }
+            return Maybe.of(new PyShaclValidator({
+                prefixMap,
+                pyShaclFilePath,
+                logger,
+                shapesGraph,
+            }));
+        });
+    }
+    async validate(dataGraph) {
+        return EitherAsync(async ({ liftEither }) => await tmp.withDir(async ({ path: tmpDirectoryPath }) => {
+            const dataGraphFilePath = path.join(tmpDirectoryPath, "data.ttl");
+            const serializer = new TurtleSerializer({
+                prefixes: this.prefixMap,
+            });
+            this.logger.debug("writing data graph to %s", dataGraphFilePath);
+            await fs.writeFile(dataGraphFilePath, serializer.transform(dataGraph));
+            this.logger.debug("wrote data graph to %s", dataGraphFilePath);
+            const shapesGraphFilePath = path.join(tmpDirectoryPath, "shapes.ttl");
+            this.logger.debug("writing shapes graph to %s", shapesGraphFilePath);
+            await fs.writeFile(shapesGraphFilePath, serializer.transform(this.shapesGraph));
+            this.logger.debug("wrote shapes graph to %s", shapesGraphFilePath);
+            const args = [
+                "-f",
+                "turtle",
+                "-s",
+                shapesGraphFilePath,
+                dataGraphFilePath,
+            ];
+            this.logger.debug("validating with pyshacl (args=%s)", args);
+            const { code, stdout } = await execPromisified(this.pyShaclFilePath, args);
+            this.logger.debug("validated with pyshacl: %s", code === 0 ? "conforms" : "does not conform");
+            const validationReportDataset = datasetFactory.dataset(await getStreamAsArray(parsers({ dataFactory }).import("text/turtle", Readable.from(stdout))));
+            for (const rdfTypeQuad of validationReportDataset.match(null, null, ValidationReport.schema.fromRdfType)) {
+                return await liftEither(ValidationReport.fromRdfResource(new ResourceSet({
+                    dataFactory,
+                    dataset: validationReportDataset,
+                }).resource(rdfTypeQuad.subject)));
+            }
+            throw new Error("unable to parse validation report from pySHACL shacl output");
+        }, {
+            unsafeCleanup: true,
+        }));
+    }
+}
+//# sourceMappingURL=PyShaclValidator.js.map

package/dist/Validator.d.ts

@@ -0,0 +1,20 @@
+import PrefixMap from "@rdfjs/prefix-map/PrefixMap.js";
+import type { DatasetCore } from "@rdfjs/types";
+import type { ValidationReport } from "@shaclmate/shacl-ast";
+import type { Either } from "purify-ts";
+import { type Logger } from "ts-log";
+/**
+ * Abstract base class for SHACL validator implementations.
+ */
+export declare abstract class Validator {
+    protected readonly logger: Logger;
+    protected readonly prefixMap: PrefixMap;
+    protected readonly shapesGraph: DatasetCore;
+    constructor({ logger, prefixMap, shapesGraph, }: {
+        logger?: Logger;
+        prefixMap?: PrefixMap;
+        shapesGraph: DatasetCore;
+    });
+    abstract validate(dataGraph: DatasetCore): Promise<Either<Error, ValidationReport>>;
+}
+//# sourceMappingURL=Validator.d.ts.map

package/dist/Validator.js

@@ -0,0 +1,18 @@
+import PrefixMap from "@rdfjs/prefix-map/PrefixMap.js";
+import dataFactory from "@rdfx/data-factory";
+import { dummyLogger } from "ts-log";
+/**
+ * Abstract base class for SHACL validator implementations.
+ */
+export class Validator {
+    logger;
+    prefixMap;
+    shapesGraph;
+    constructor({ logger = dummyLogger, prefixMap, shapesGraph, }) {
+        this.logger = logger;
+        this.prefixMap =
+            prefixMap ?? new PrefixMap(undefined, { factory: dataFactory });
+        this.shapesGraph = shapesGraph;
+    }
+}
+//# sourceMappingURL=Validator.js.map

package/dist/ZazukoValidator.d.ts

@@ -0,0 +1,8 @@
+import type { DatasetCore } from "@rdfjs/types";
+import { ValidationReport } from "@shaclmate/shacl-ast";
+import { type Either } from "purify-ts";
+import { Validator } from "./Validator.js";
+export declare class ZazukoValidator extends Validator {
+    validate(dataGraph: DatasetCore): Promise<Either<Error, ValidationReport>>;
+}
+//# sourceMappingURL=ZazukoValidator.d.ts.map

package/dist/ZazukoValidator.js

@@ -0,0 +1,25 @@
+import dataFactory from "@rdfx/data-factory";
+import { ResourceSet } from "@rdfx/resource";
+import { ValidationReport } from "@shaclmate/shacl-ast";
+import { EitherAsync } from "purify-ts";
+import SHACLValidator from "rdf-validate-shacl";
+import { Validator } from "./Validator.js";
+export class ZazukoValidator extends Validator {
+    async validate(dataGraph) {
+        return EitherAsync(async ({ liftEither }) => {
+            const validationReport = await new SHACLValidator(this.shapesGraph, {}).validate(dataGraph);
+            switch (validationReport.term.termType) {
+                case "BlankNode":
+                case "NamedNode":
+                    break;
+                default:
+                    throw new RangeError(`unexpected sh:ValidationReport term type: ${validationReport.term.termType}`);
+            }
+            return await liftEither(ValidationReport.fromRdfResource(new ResourceSet({
+                dataFactory,
+                dataset: validationReport.dataset,
+            }).resource(validationReport.term)));
+        });
+    }
+}
+//# sourceMappingURL=ZazukoValidator.js.map

package/dist/execPromisified.d.ts

@@ -0,0 +1,6 @@
+export declare function execPromisified(cmd: string, args: string[]): Promise<{
+    code: number | null;
+    stdout: string;
+    stderr: string;
+}>;
+//# sourceMappingURL=execPromisified.d.ts.map

package/dist/execPromisified.js

@@ -0,0 +1,23 @@
+import { spawn } from "node:child_process";
+export function execPromisified(cmd, args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(cmd, args, {
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk.toString();
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.on("error", (err) => {
+            reject(err);
+        });
+        child.on("close", (code) => {
+            resolve({ code, stdout, stderr });
+        });
+    });
+}
+//# sourceMappingURL=execPromisified.js.map

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./shaclShaclDataset.js";
+export * from "./Validator.js";
+export * from "./ZazukoValidator.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from "./shaclShaclDataset.js";
+export * from "./Validator.js";
+export * from "./ZazukoValidator.js";
+//# sourceMappingURL=index.js.map

package/dist/shaclShaclDataset.d.ts

@@ -0,0 +1,2 @@
+export declare const shaclShaclDataset: import("@rdfjs/dataset/DatasetCore.js").default<import("@rdfjs/types").Quad>;
+//# sourceMappingURL=shaclShaclDataset.d.ts.map

package/dist/shaclShaclDataset.js

@@ -0,0 +1,5 @@
+import datasetFactory from "@rdfjs/dataset";
+import dataFactory from "@rdfx/data-factory";
+import shaclShaclQuads from "./shaclShaclQuads.js";
+export const shaclShaclDataset = datasetFactory.dataset(shaclShaclQuads({ factory: dataFactory }));
+//# sourceMappingURL=shaclShaclDataset.js.map

package/dist/shaclShaclQuads.d.ts

@@ -0,0 +1,5 @@
+declare const _default: ({ factory }: {
+    factory: import("@rdfjs/types").DataFactory;
+}) => import("@rdfjs/types").Quad[];
+export default _default;
+//# sourceMappingURL=shaclShaclQuads.d.ts.map

package/dist/shaclShaclQuads.js

@@ -0,0 +1,431 @@
+/* This file was automatically generated. Do not edit by hand. */
+export default ({ factory }) => {
+    const f = factory;
+    const ns1 = 'http://www.w3.org/ns/shacl-shacl#';
+    const ns2 = 'http://www.w3.org/2000/01/rdf-schema#';
+    const ns3 = 'http://www.w3.org/ns/shacl#';
+    const ns4 = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#';
+    const ns5 = 'https://www.w3.org/TR/shacl/#';
+    const ns6 = 'http://www.w3.org/2001/XMLSchema#';
+    const blankNodes = [];
+    for (let i = 0; i < 130; i++) {
+        blankNodes.push(f.blankNode());
+    }
+    return [
+        f.quad(f.namedNode(ns1), f.namedNode(`${ns2}label`), f.literal('SHACL for SHACL', 'en')),
+        f.quad(f.namedNode(ns1), f.namedNode(`${ns2}comment`), f.literal('This shapes graph can be used to validate SHACL shapes graphs against a subset of the SHACL syntax rules.', 'en')),
+        f.quad(f.namedNode(ns1), f.namedNode(`${ns3}declare`), blankNodes[0]),
+        f.quad(blankNodes[0], f.namedNode(`${ns3}prefix`), f.literal('shsh')),
+        f.quad(blankNodes[0], f.namedNode(`${ns3}namespace`), f.literal('http://www.w3.org/ns/shacl-shacl#')),
+        f.quad(f.namedNode(`${ns1}ListShape`), f.namedNode(`${ns2}label`), f.literal('List shape', 'en')),
+        f.quad(f.namedNode(`${ns1}ListShape`), f.namedNode(`${ns2}comment`), f.literal('A shape describing well-formed RDF lists. Currently does not check for non-recursion. This could be expressed using SHACL-SPARQL.', 'en')),
+        f.quad(f.namedNode(`${ns1}ListShape`), f.namedNode(`${ns4}type`), f.namedNode(`${ns3}NodeShape`)),
+        f.quad(f.namedNode(`${ns1}ListShape`), f.namedNode(`${ns2}seeAlso`), f.namedNode(`${ns5}syntax-rule-SHACL-list`)),
+        f.quad(f.namedNode(`${ns1}ListShape`), f.namedNode(`${ns3}property`), blankNodes[1]),
+        f.quad(blankNodes[2], f.namedNode(`${ns3}zeroOrMorePath`), f.namedNode(`${ns4}rest`)),
+        f.quad(blankNodes[1], f.namedNode(`${ns2}comment`), f.literal('Each list member (including this node) must be have the shape shsh:ListNodeShape.', 'en')),
+        f.quad(blankNodes[1], f.namedNode(`${ns3}path`), blankNodes[2]),
+        f.quad(blankNodes[1], f.namedNode(`${ns3}hasValue`), f.namedNode(`${ns4}nil`)),
+        f.quad(blankNodes[1], f.namedNode(`${ns3}node`), f.namedNode(`${ns1}ListNodeShape`)),
+        f.quad(f.namedNode(`${ns1}ListNodeShape`), f.namedNode(`${ns2}label`), f.literal('List node shape', 'en')),
+        f.quad(f.namedNode(`${ns1}ListNodeShape`), f.namedNode(`${ns2}comment`), f.literal('Defines constraints on what it means for a node to be a node within a well-formed RDF list. Note that this does not check whether the rdf:rest items are also well-formed lists as this would lead to unsupported recursion.', 'en')),
+        f.quad(f.namedNode(`${ns1}ListNodeShape`), f.namedNode(`${ns4}type`), f.namedNode(`${ns3}NodeShape`)),
+        f.quad(f.namedNode(`${ns1}ListNodeShape`), f.namedNode(`${ns3}or`), blankNodes[3]),
+        f.quad(blankNodes[3], f.namedNode(`${ns4}rest`), blankNodes[4]),
+        f.quad(blankNodes[3], f.namedNode(`${ns4}first`), blankNodes[5]),
+        f.quad(blankNodes[5], f.namedNode(`${ns3}hasValue`), f.namedNode(`${ns4}nil`)),
+        f.quad(blankNodes[5], f.namedNode(`${ns3}property`), blankNodes[6]),
+        f.quad(blankNodes[5], f.namedNode(`${ns3}property`), blankNodes[7]),
+        f.quad(blankNodes[6], f.namedNode(`${ns3}path`), f.namedNode(`${ns4}first`)),
+        f.quad(blankNodes[6], f.namedNode(`${ns3}maxCount`), f.literal('0', f.namedNode(`${ns6}integer`))),
+        f.quad(blankNodes[7], f.namedNode(`${ns3}path`), f.namedNode(`${ns4}rest`)),
+        f.quad(blankNodes[7], f.namedNode(`${ns3}maxCount`), f.literal('0', f.namedNode(`${ns6}integer`))),
+        f.quad(blankNodes[4], f.namedNode(`${ns4}rest`), f.namedNode(`${ns4}nil`)),
+        f.quad(blankNodes[4], f.namedNode(`${ns4}first`), blankNodes[8]),
+        f.quad(blankNodes[8], f.namedNode(`${ns3}property`), blankNodes[9]),
+        f.quad(blankNodes[8], f.namedNode(`${ns3}property`), blankNodes[10]),
+        f.quad(blankNodes[8], f.namedNode(`${ns3}not`), blankNodes[11]),
+        f.quad(blankNodes[11], f.namedNode(`${ns3}hasValue`), f.namedNode(`${ns4}nil`)),
+        f.quad(blankNodes[9], f.namedNode(`${ns3}path`), f.namedNode(`${ns4}first`)),
+        f.quad(blankNodes[9], f.namedNode(`${ns3}maxCount`), f.literal('1', f.namedNode(`${ns6}integer`))),
+        f.quad(blankNodes[9], f.namedNode(`${ns3}minCount`), f.literal('1', f.namedNode(`${ns6}integer`))),
+        f.quad(blankNodes[10], f.namedNode(`${ns3}path`), f.namedNode(`${ns4}rest`)),
+        f.quad(blankNodes[10], f.namedNode(`${ns3}maxCount`), f.literal('1', f.namedNode(`${ns6}integer`))),
+        f.quad(blankNodes[10], f.namedNode(`${ns3}minCount`), f.literal('1', f.namedNode(`${ns6}integer`))),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns2}label`), f.literal('Shape shape', 'en')),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns2}comment`), f.literal('A shape that can be used to validate syntax rules for other shapes.', 'en')),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns4}type`), f.namedNode(`${ns3}NodeShape`)),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}property`), blankNodes[12]),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}property`), blankNodes[13]),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}property`), blankNodes[14]),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}property`), blankNodes[15]),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}property`), blankNodes[16]),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}property`), blankNodes[17]),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}property`), blankNodes[18]),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}property`), blankNodes[19]),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}property`), blankNodes[20]),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}property`), blankNodes[21]),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}property`), blankNodes[22]),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}property`), blankNodes[23]),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}property`), blankNodes[24]),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}property`), blankNodes[25]),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}property`), blankNodes[26]),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}property`), blankNodes[27]),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}property`), blankNodes[28]),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}property`), blankNodes[29]),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}property`), blankNodes[30]),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}property`), blankNodes[31]),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}property`), blankNodes[32]),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}property`), blankNodes[33]),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}property`), blankNodes[34]),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}property`), blankNodes[35]),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}property`), blankNodes[36]),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}property`), blankNodes[37]),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}property`), blankNodes[38]),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}property`), blankNodes[39]),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}property`), blankNodes[40]),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}property`), blankNodes[41]),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}property`), blankNodes[42]),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}property`), blankNodes[43]),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}property`), blankNodes[44]),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}property`), blankNodes[45]),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}property`), blankNodes[46]),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}property`), blankNodes[47]),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}property`), blankNodes[48]),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}property`), blankNodes[49]),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}or`), blankNodes[50]),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}targetClass`), f.namedNode(`${ns3}NodeShape`)),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}targetClass`), f.namedNode(`${ns3}PropertyShape`)),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}targetSubjectsOf`), f.namedNode(`${ns3}hasValue`)),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}targetSubjectsOf`), f.namedNode(`${ns3}node`)),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}targetSubjectsOf`), f.namedNode(`${ns3}property`)),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}targetSubjectsOf`), f.namedNode(`${ns3}maxCount`)),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}targetSubjectsOf`), f.namedNode(`${ns3}not`)),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}targetSubjectsOf`), f.namedNode(`${ns3}minCount`)),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}targetSubjectsOf`), f.namedNode(`${ns3}or`)),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}targetSubjectsOf`), f.namedNode(`${ns3}targetClass`)),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}targetSubjectsOf`), f.namedNode(`${ns3}targetSubjectsOf`)),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}targetSubjectsOf`), f.namedNode(`${ns3}targetNode`)),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}targetSubjectsOf`), f.namedNode(`${ns3}targetObjectsOf`)),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}targetSubjectsOf`), f.namedNode(`${ns3}and`)),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}targetSubjectsOf`), f.namedNode(`${ns3}class`)),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}targetSubjectsOf`), f.namedNode(`${ns3}closed`)),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}targetSubjectsOf`), f.namedNode(`${ns3}datatype`)),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}targetSubjectsOf`), f.namedNode(`${ns3}disjoint`)),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}targetSubjectsOf`), f.namedNode(`${ns3}equals`)),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}targetSubjectsOf`), f.namedNode(`${ns3}flags`)),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}targetSubjectsOf`), f.namedNode(`${ns3}ignoredProperties`)),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}targetSubjectsOf`), f.namedNode(`${ns3}in`)),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}targetSubjectsOf`), f.namedNode(`${ns3}languageIn`)),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}targetSubjectsOf`), f.namedNode(`${ns3}lessThan`)),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}targetSubjectsOf`), f.namedNode(`${ns3}lessThanOrEquals`)),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}targetSubjectsOf`), f.namedNode(`${ns3}maxExclusive`)),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}targetSubjectsOf`), f.namedNode(`${ns3}maxInclusive`)),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}targetSubjectsOf`), f.namedNode(`${ns3}maxLength`)),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}targetSubjectsOf`), f.namedNode(`${ns3}minExclusive`)),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}targetSubjectsOf`), f.namedNode(`${ns3}minInclusive`)),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}targetSubjectsOf`), f.namedNode(`${ns3}minLength`)),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}targetSubjectsOf`), f.namedNode(`${ns3}nodeKind`)),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}targetSubjectsOf`), f.namedNode(`${ns3}pattern`)),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}targetSubjectsOf`), f.namedNode(`${ns3}qualifiedMaxCount`)),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}targetSubjectsOf`), f.namedNode(`${ns3}qualifiedMinCount`)),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}targetSubjectsOf`), f.namedNode(`${ns3}qualifiedValueShape`)),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}targetSubjectsOf`), f.namedNode(`${ns3}qualifiedValueShapesDisjoint`)),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}targetSubjectsOf`), f.namedNode(`${ns3}uniqueLang`)),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}targetSubjectsOf`), f.namedNode(`${ns3}xone`)),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}targetObjectsOf`), f.namedNode(`${ns3}node`)),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}targetObjectsOf`), f.namedNode(`${ns3}property`)),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}targetObjectsOf`), f.namedNode(`${ns3}not`)),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}targetObjectsOf`), f.namedNode(`${ns3}qualifiedValueShape`)),
+        f.quad(f.namedNode(`${ns1}ShapeShape`), f.namedNode(`${ns3}xone`), blankNodes[51]),
+        f.quad(blankNodes[51], f.namedNode(`${ns4}rest`), blankNodes[52]),
+        f.quad(blankNodes[51], f.namedNode(`${ns4}first`), f.namedNode(`${ns1}NodeShapeShape`)),
+        f.quad(f.namedNode(`${ns1}NodeShapeShape`), f.namedNode(`${ns4}type`), f.namedNode(`${ns3}NodeShape`)),
+        f.quad(f.namedNode(`${ns1}NodeShapeShape`), f.namedNode(`${ns3}property`), blankNodes[53]),
+        f.quad(f.namedNode(`${ns1}NodeShapeShape`), f.namedNode(`${ns3}property`), blankNodes[54]),
+        f.quad(f.namedNode(`${ns1}NodeShapeShape`), f.namedNode(`${ns3}property`), blankNodes[55]),
+        f.quad(f.namedNode(`${ns1}NodeShapeShape`), f.namedNode(`${ns3}property`), blankNodes[56]),
+        f.quad(f.namedNode(`${ns1}NodeShapeShape`), f.namedNode(`${ns3}property`), blankNodes[57]),
+        f.quad(f.namedNode(`${ns1}NodeShapeShape`), f.namedNode(`${ns3}property`), blankNodes[58]),
+        f.quad(f.namedNode(`${ns1}NodeShapeShape`), f.namedNode(`${ns3}property`), blankNodes[59]),
+        f.quad(f.namedNode(`${ns1}NodeShapeShape`), f.namedNode(`${ns3}targetObjectsOf`), f.namedNode(`${ns3}node`)),
+        f.quad(blankNodes[52], f.namedNode(`${ns4}rest`), f.namedNode(`${ns4}nil`)),
+        f.quad(blankNodes[52], f.namedNode(`${ns4}first`), f.namedNode(`${ns1}PropertyShapeShape`)),
+        f.quad(f.namedNode(`${ns1}PropertyShapeShape`), f.namedNode(`${ns4}type`), f.namedNode(`${ns3}NodeShape`)),
+        f.quad(f.namedNode(`${ns1}PropertyShapeShape`), f.namedNode(`${ns3}property`), blankNodes[60]),
+        f.quad(f.namedNode(`${ns1}PropertyShapeShape`), f.namedNode(`${ns3}targetObjectsOf`), f.namedNode(`${ns3}property`)),
+        f.quad(blankNodes[12], f.namedNode(`${ns3}path`), f.namedNode(`${ns3}targetNode`)),
+        f.quad(blankNodes[12], f.namedNode(`${ns3}nodeKind`), f.namedNode(`${ns3}IRIOrLiteral`)),
+        f.quad(blankNodes[13], f.namedNode(`${ns3}path`), f.namedNode(`${ns3}targetClass`)),
+        f.quad(blankNodes[13], f.namedNode(`${ns3}nodeKind`), f.namedNode(`${ns3}IRI`)),
+        f.quad(blankNodes[14], f.namedNode(`${ns3}path`), f.namedNode(`${ns3}targetSubjectsOf`)),
+        f.quad(blankNodes[14], f.namedNode(`${ns3}nodeKind`), f.namedNode(`${ns3}IRI`)),
+        f.quad(blankNodes[15], f.namedNode(`${ns3}path`), f.namedNode(`${ns3}targetObjectsOf`)),
+        f.quad(blankNodes[15], f.namedNode(`${ns3}nodeKind`), f.namedNode(`${ns3}IRI`)),
+        f.quad(blankNodes[50], f.namedNode(`${ns4}rest`), blankNodes[61]),
+        f.quad(blankNodes[50], f.namedNode(`${ns4}first`), blankNodes[62]),
+        f.quad(blankNodes[62], f.namedNode(`${ns3}not`), blankNodes[63]),
+        f.quad(blankNodes[63], f.namedNode(`${ns3}or`), blankNodes[64]),
+        f.quad(blankNodes[63], f.namedNode(`${ns3}class`), f.namedNode(`${ns2}Class`)),
+        f.quad(blankNodes[64], f.namedNode(`${ns4}rest`), blankNodes[65]),
+        f.quad(blankNodes[64], f.namedNode(`${ns4}first`), blankNodes[66]),
+        f.quad(blankNodes[66], f.namedNode(`${ns3}class`), f.namedNode(`${ns3}NodeShape`)),
+        f.quad(blankNodes[65], f.namedNode(`${ns4}rest`), f.namedNode(`${ns4}nil`)),
+        f.quad(blankNodes[65], f.namedNode(`${ns4}first`), blankNodes[67]),
+        f.quad(blankNodes[67], f.namedNode(`${ns3}class`), f.namedNode(`${ns3}PropertyShape`)),
+        f.quad(blankNodes[61], f.namedNode(`${ns4}rest`), f.namedNode(`${ns4}nil`)),
+        f.quad(blankNodes[61], f.namedNode(`${ns4}first`), blankNodes[68]),
+        f.quad(blankNodes[68], f.namedNode(`${ns3}nodeKind`), f.namedNode(`${ns3}IRI`)),
+        f.quad(blankNodes[16], f.namedNode(`${ns3}path`), f.namedNode(`${ns3}severity`)),
+        f.quad(blankNodes[16], f.namedNode(`${ns3}maxCount`), f.literal('1', f.namedNode(`${ns6}integer`))),
+        f.quad(blankNodes[16], f.namedNode(`${ns3}nodeKind`), f.namedNode(`${ns3}IRI`)),
+        f.quad(blankNodes[17], f.namedNode(`${ns3}path`), f.namedNode(`${ns3}message`)),
+        f.quad(blankNodes[17], f.namedNode(`${ns3}or`), blankNodes[69]),
+        f.quad(blankNodes[69], f.namedNode(`${ns4}rest`), blankNodes[70]),
+        f.quad(blankNodes[69], f.namedNode(`${ns4}first`), blankNodes[71]),
+        f.quad(blankNodes[71], f.namedNode(`${ns3}datatype`), f.namedNode(`${ns6}string`)),
+        f.quad(blankNodes[70], f.namedNode(`${ns4}rest`), f.namedNode(`${ns4}nil`)),
+        f.quad(blankNodes[70], f.namedNode(`${ns4}first`), blankNodes[72]),
+        f.quad(blankNodes[72], f.namedNode(`${ns3}datatype`), f.namedNode(`${ns4}langString`)),
+        f.quad(blankNodes[18], f.namedNode(`${ns3}path`), f.namedNode(`${ns3}deactivated`)),
+        f.quad(blankNodes[18], f.namedNode(`${ns3}maxCount`), f.literal('1', f.namedNode(`${ns6}integer`))),
+        f.quad(blankNodes[18], f.namedNode(`${ns3}in`), blankNodes[73]),
+        f.quad(blankNodes[73], f.namedNode(`${ns4}rest`), blankNodes[74]),
+        f.quad(blankNodes[73], f.namedNode(`${ns4}first`), f.literal('true', f.namedNode(`${ns6}boolean`))),
+        f.quad(blankNodes[74], f.namedNode(`${ns4}rest`), f.namedNode(`${ns4}nil`)),
+        f.quad(blankNodes[74], f.namedNode(`${ns4}first`), f.literal('false', f.namedNode(`${ns6}boolean`))),
+        f.quad(blankNodes[19], f.namedNode(`${ns3}path`), f.namedNode(`${ns3}and`)),
+        f.quad(blankNodes[19], f.namedNode(`${ns3}node`), f.namedNode(`${ns1}ListShape`)),
+        f.quad(blankNodes[20], f.namedNode(`${ns3}path`), f.namedNode(`${ns3}class`)),
+        f.quad(blankNodes[20], f.namedNode(`${ns3}nodeKind`), f.namedNode(`${ns3}IRI`)),
+        f.quad(blankNodes[21], f.namedNode(`${ns3}path`), f.namedNode(`${ns3}closed`)),
+        f.quad(blankNodes[21], f.namedNode(`${ns3}maxCount`), f.literal('1', f.namedNode(`${ns6}integer`))),
+        f.quad(blankNodes[21], f.namedNode(`${ns3}datatype`), f.namedNode(`${ns6}boolean`)),
+        f.quad(blankNodes[22], f.namedNode(`${ns3}path`), f.namedNode(`${ns3}ignoredProperties`)),
+        f.quad(blankNodes[22], f.namedNode(`${ns3}node`), f.namedNode(`${ns1}ListShape`)),
+        f.quad(blankNodes[22], f.namedNode(`${ns3}maxCount`), f.literal('1', f.namedNode(`${ns6}integer`))),
+        f.quad(blankNodes[75], f.namedNode(`${ns4}rest`), blankNodes[76]),
+        f.quad(blankNodes[75], f.namedNode(`${ns4}first`), f.namedNode(`${ns3}ignoredProperties`)),
+        f.quad(blankNodes[76], f.namedNode(`${ns4}rest`), blankNodes[77]),
+        f.quad(blankNodes[76], f.namedNode(`${ns4}first`), blankNodes[78]),
+        f.quad(blankNodes[78], f.namedNode(`${ns3}zeroOrMorePath`), f.namedNode(`${ns4}rest`)),
+        f.quad(blankNodes[77], f.namedNode(`${ns4}rest`), f.namedNode(`${ns4}nil`)),
+        f.quad(blankNodes[77], f.namedNode(`${ns4}first`), f.namedNode(`${ns4}first`)),
+        f.quad(blankNodes[23], f.namedNode(`${ns3}path`), blankNodes[75]),
+        f.quad(blankNodes[23], f.namedNode(`${ns3}nodeKind`), f.namedNode(`${ns3}IRI`)),
+        f.quad(blankNodes[24], f.namedNode(`${ns3}path`), f.namedNode(`${ns3}datatype`)),
+        f.quad(blankNodes[24], f.namedNode(`${ns3}maxCount`), f.literal('1', f.namedNode(`${ns6}integer`))),
+        f.quad(blankNodes[24], f.namedNode(`${ns3}nodeKind`), f.namedNode(`${ns3}IRI`)),
+        f.quad(blankNodes[25], f.namedNode(`${ns3}path`), f.namedNode(`${ns3}disjoint`)),
+        f.quad(blankNodes[25], f.namedNode(`${ns3}nodeKind`), f.namedNode(`${ns3}IRI`)),
+        f.quad(blankNodes[26], f.namedNode(`${ns3}path`), f.namedNode(`${ns3}equals`)),
+        f.quad(blankNodes[26], f.namedNode(`${ns3}nodeKind`), f.namedNode(`${ns3}IRI`)),
+        f.quad(blankNodes[27], f.namedNode(`${ns3}path`), f.namedNode(`${ns3}in`)),
+        f.quad(blankNodes[27], f.namedNode(`${ns3}node`), f.namedNode(`${ns1}ListShape`)),
+        f.quad(blankNodes[27], f.namedNode(`${ns3}maxCount`), f.literal('1', f.namedNode(`${ns6}integer`))),
+        f.quad(blankNodes[28], f.namedNode(`${ns3}path`), f.namedNode(`${ns3}languageIn`)),
+        f.quad(blankNodes[28], f.namedNode(`${ns3}node`), f.namedNode(`${ns1}ListShape`)),
+        f.quad(blankNodes[28], f.namedNode(`${ns3}maxCount`), f.literal('1', f.namedNode(`${ns6}integer`))),
+        f.quad(blankNodes[79], f.namedNode(`${ns4}rest`), blankNodes[80]),
+        f.quad(blankNodes[79], f.namedNode(`${ns4}first`), f.namedNode(`${ns3}languageIn`)),
+        f.quad(blankNodes[80], f.namedNode(`${ns4}rest`), blankNodes[81]),
+        f.quad(blankNodes[80], f.namedNode(`${ns4}first`), blankNodes[82]),
+        f.quad(blankNodes[82], f.namedNode(`${ns3}zeroOrMorePath`), f.namedNode(`${ns4}rest`)),
+        f.quad(blankNodes[81], f.namedNode(`${ns4}rest`), f.namedNode(`${ns4}nil`)),
+        f.quad(blankNodes[81], f.namedNode(`${ns4}first`), f.namedNode(`${ns4}first`)),
+        f.quad(blankNodes[29], f.namedNode(`${ns3}path`), blankNodes[79]),
+        f.quad(blankNodes[29], f.namedNode(`${ns3}datatype`), f.namedNode(`${ns6}string`)),
+        f.quad(blankNodes[30], f.namedNode(`${ns3}path`), f.namedNode(`${ns3}lessThan`)),
+        f.quad(blankNodes[30], f.namedNode(`${ns3}nodeKind`), f.namedNode(`${ns3}IRI`)),
+        f.quad(blankNodes[31], f.namedNode(`${ns3}path`), f.namedNode(`${ns3}lessThanOrEquals`)),
+        f.quad(blankNodes[31], f.namedNode(`${ns3}nodeKind`), f.namedNode(`${ns3}IRI`)),
+        f.quad(blankNodes[32], f.namedNode(`${ns3}path`), f.namedNode(`${ns3}maxCount`)),
+        f.quad(blankNodes[32], f.namedNode(`${ns3}maxCount`), f.literal('1', f.namedNode(`${ns6}integer`))),
+        f.quad(blankNodes[32], f.namedNode(`${ns3}datatype`), f.namedNode(`${ns6}integer`)),
+        f.quad(blankNodes[33], f.namedNode(`${ns3}path`), f.namedNode(`${ns3}maxExclusive`)),
+        f.quad(blankNodes[33], f.namedNode(`${ns3}maxCount`), f.literal('1', f.namedNode(`${ns6}integer`))),
+        f.quad(blankNodes[33], f.namedNode(`${ns3}nodeKind`), f.namedNode(`${ns3}Literal`)),
+        f.quad(blankNodes[34], f.namedNode(`${ns3}path`), f.namedNode(`${ns3}maxInclusive`)),
+        f.quad(blankNodes[34], f.namedNode(`${ns3}maxCount`), f.literal('1', f.namedNode(`${ns6}integer`))),
+        f.quad(blankNodes[34], f.namedNode(`${ns3}nodeKind`), f.namedNode(`${ns3}Literal`)),
+        f.quad(blankNodes[35], f.namedNode(`${ns3}path`), f.namedNode(`${ns3}maxLength`)),
+        f.quad(blankNodes[35], f.namedNode(`${ns3}maxCount`), f.literal('1', f.namedNode(`${ns6}integer`))),
+        f.quad(blankNodes[35], f.namedNode(`${ns3}datatype`), f.namedNode(`${ns6}integer`)),
+        f.quad(blankNodes[36], f.namedNode(`${ns3}path`), f.namedNode(`${ns3}minCount`)),
+        f.quad(blankNodes[36], f.namedNode(`${ns3}maxCount`), f.literal('1', f.namedNode(`${ns6}integer`))),
+        f.quad(blankNodes[36], f.namedNode(`${ns3}datatype`), f.namedNode(`${ns6}integer`)),
+        f.quad(blankNodes[37], f.namedNode(`${ns3}path`), f.namedNode(`${ns3}minExclusive`)),
+        f.quad(blankNodes[37], f.namedNode(`${ns3}maxCount`), f.literal('1', f.namedNode(`${ns6}integer`))),
+        f.quad(blankNodes[37], f.namedNode(`${ns3}nodeKind`), f.namedNode(`${ns3}Literal`)),
+        f.quad(blankNodes[38], f.namedNode(`${ns3}path`), f.namedNode(`${ns3}minInclusive`)),
+        f.quad(blankNodes[38], f.namedNode(`${ns3}maxCount`), f.literal('1', f.namedNode(`${ns6}integer`))),
+        f.quad(blankNodes[38], f.namedNode(`${ns3}nodeKind`), f.namedNode(`${ns3}Literal`)),
+        f.quad(blankNodes[39], f.namedNode(`${ns3}path`), f.namedNode(`${ns3}minLength`)),
+        f.quad(blankNodes[39], f.namedNode(`${ns3}maxCount`), f.literal('1', f.namedNode(`${ns6}integer`))),
+        f.quad(blankNodes[39], f.namedNode(`${ns3}datatype`), f.namedNode(`${ns6}integer`)),
+        f.quad(blankNodes[40], f.namedNode(`${ns3}path`), f.namedNode(`${ns3}nodeKind`)),
+        f.quad(blankNodes[40], f.namedNode(`${ns3}maxCount`), f.literal('1', f.namedNode(`${ns6}integer`))),
+        f.quad(blankNodes[40], f.namedNode(`${ns3}in`), blankNodes[83]),
+        f.quad(blankNodes[83], f.namedNode(`${ns4}rest`), blankNodes[84]),
+        f.quad(blankNodes[83], f.namedNode(`${ns4}first`), f.namedNode(`${ns3}BlankNode`)),
+        f.quad(blankNodes[84], f.namedNode(`${ns4}rest`), blankNodes[85]),
+        f.quad(blankNodes[84], f.namedNode(`${ns4}first`), f.namedNode(`${ns3}IRI`)),
+        f.quad(blankNodes[85], f.namedNode(`${ns4}rest`), blankNodes[86]),
+        f.quad(blankNodes[85], f.namedNode(`${ns4}first`), f.namedNode(`${ns3}Literal`)),
+        f.quad(blankNodes[86], f.namedNode(`${ns4}rest`), blankNodes[87]),
+        f.quad(blankNodes[86], f.namedNode(`${ns4}first`), f.namedNode(`${ns3}BlankNodeOrIRI`)),
+        f.quad(blankNodes[87], f.namedNode(`${ns4}rest`), blankNodes[88]),
+        f.quad(blankNodes[87], f.namedNode(`${ns4}first`), f.namedNode(`${ns3}BlankNodeOrLiteral`)),
+        f.quad(blankNodes[88], f.namedNode(`${ns4}rest`), f.namedNode(`${ns4}nil`)),
+        f.quad(blankNodes[88], f.namedNode(`${ns4}first`), f.namedNode(`${ns3}IRIOrLiteral`)),
+        f.quad(blankNodes[41], f.namedNode(`${ns3}path`), f.namedNode(`${ns3}or`)),
+        f.quad(blankNodes[41], f.namedNode(`${ns3}node`), f.namedNode(`${ns1}ListShape`)),
+        f.quad(blankNodes[42], f.namedNode(`${ns3}path`), f.namedNode(`${ns3}pattern`)),
+        f.quad(blankNodes[42], f.namedNode(`${ns3}maxCount`), f.literal('1', f.namedNode(`${ns6}integer`))),
+        f.quad(blankNodes[42], f.namedNode(`${ns3}datatype`), f.namedNode(`${ns6}string`)),
+        f.quad(blankNodes[43], f.namedNode(`${ns3}path`), f.namedNode(`${ns3}flags`)),
+        f.quad(blankNodes[43], f.namedNode(`${ns3}maxCount`), f.literal('1', f.namedNode(`${ns6}integer`))),
+        f.quad(blankNodes[43], f.namedNode(`${ns3}datatype`), f.namedNode(`${ns6}string`)),
+        f.quad(blankNodes[44], f.namedNode(`${ns3}path`), f.namedNode(`${ns3}qualifiedMaxCount`)),
+        f.quad(blankNodes[44], f.namedNode(`${ns3}maxCount`), f.literal('1', f.namedNode(`${ns6}integer`))),
+        f.quad(blankNodes[44], f.namedNode(`${ns3}datatype`), f.namedNode(`${ns6}integer`)),
+        f.quad(blankNodes[45], f.namedNode(`${ns3}path`), f.namedNode(`${ns3}qualifiedMinCount`)),
+        f.quad(blankNodes[45], f.namedNode(`${ns3}maxCount`), f.literal('1', f.namedNode(`${ns6}integer`))),
+        f.quad(blankNodes[45], f.namedNode(`${ns3}datatype`), f.namedNode(`${ns6}integer`)),
+        f.quad(blankNodes[46], f.namedNode(`${ns3}path`), f.namedNode(`${ns3}qualifiedValueShape`)),
+        f.quad(blankNodes[46], f.namedNode(`${ns3}maxCount`), f.literal('1', f.namedNode(`${ns6}integer`))),
+        f.quad(blankNodes[47], f.namedNode(`${ns3}path`), f.namedNode(`${ns3}qualifiedValueShapesDisjoint`)),
+        f.quad(blankNodes[47], f.namedNode(`${ns3}maxCount`), f.literal('1', f.namedNode(`${ns6}integer`))),
+        f.quad(blankNodes[47], f.namedNode(`${ns3}datatype`), f.namedNode(`${ns6}boolean`)),
+        f.quad(blankNodes[48], f.namedNode(`${ns3}path`), f.namedNode(`${ns3}uniqueLang`)),
+        f.quad(blankNodes[48], f.namedNode(`${ns3}maxCount`), f.literal('1', f.namedNode(`${ns6}integer`))),
+        f.quad(blankNodes[48], f.namedNode(`${ns3}datatype`), f.namedNode(`${ns6}boolean`)),
+        f.quad(blankNodes[49], f.namedNode(`${ns3}path`), f.namedNode(`${ns3}xone`)),
+        f.quad(blankNodes[49], f.namedNode(`${ns3}node`), f.namedNode(`${ns1}ListShape`)),
+        f.quad(blankNodes[53], f.namedNode(`${ns3}path`), f.namedNode(`${ns3}path`)),
+        f.quad(blankNodes[53], f.namedNode(`${ns3}maxCount`), f.literal('0', f.namedNode(`${ns6}integer`))),
+        f.quad(blankNodes[54], f.namedNode(`${ns3}path`), f.namedNode(`${ns3}lessThan`)),
+        f.quad(blankNodes[54], f.namedNode(`${ns3}maxCount`), f.literal('0', f.namedNode(`${ns6}integer`))),
+        f.quad(blankNodes[55], f.namedNode(`${ns3}path`), f.namedNode(`${ns3}lessThanOrEquals`)),
+        f.quad(blankNodes[55], f.namedNode(`${ns3}maxCount`), f.literal('0', f.namedNode(`${ns6}integer`))),
+        f.quad(blankNodes[56], f.namedNode(`${ns3}path`), f.namedNode(`${ns3}maxCount`)),
+        f.quad(blankNodes[56], f.namedNode(`${ns3}maxCount`), f.literal('0', f.namedNode(`${ns6}integer`))),
+        f.quad(blankNodes[57], f.namedNode(`${ns3}path`), f.namedNode(`${ns3}minCount`)),
+        f.quad(blankNodes[57], f.namedNode(`${ns3}maxCount`), f.literal('0', f.namedNode(`${ns6}integer`))),
+        f.quad(blankNodes[58], f.namedNode(`${ns3}path`), f.namedNode(`${ns3}qualifiedValueShape`)),
+        f.quad(blankNodes[58], f.namedNode(`${ns3}maxCount`), f.literal('0', f.namedNode(`${ns6}integer`))),
+        f.quad(blankNodes[59], f.namedNode(`${ns3}path`), f.namedNode(`${ns3}uniqueLang`)),
+        f.quad(blankNodes[59], f.namedNode(`${ns3}maxCount`), f.literal('0', f.namedNode(`${ns6}integer`))),
+        f.quad(blankNodes[60], f.namedNode(`${ns3}path`), f.namedNode(`${ns3}path`)),
+        f.quad(blankNodes[60], f.namedNode(`${ns3}node`), f.namedNode(`${ns1}PathShape`)),
+        f.quad(blankNodes[60], f.namedNode(`${ns3}maxCount`), f.literal('1', f.namedNode(`${ns6}integer`))),
+        f.quad(blankNodes[60], f.namedNode(`${ns3}minCount`), f.literal('1', f.namedNode(`${ns6}integer`))),
+        f.quad(f.namedNode(`${ns1}PathShape`), f.namedNode(`${ns2}label`), f.literal('Path shape', 'en')),
+        f.quad(f.namedNode(`${ns1}PathShape`), f.namedNode(`${ns2}comment`), f.literal('A shape that can be used to validate the syntax rules of well-formed SHACL paths.', 'en')),
+        f.quad(f.namedNode(`${ns1}PathShape`), f.namedNode(`${ns4}type`), f.namedNode(`${ns3}NodeShape`)),
+        f.quad(f.namedNode(`${ns1}PathShape`), f.namedNode(`${ns2}seeAlso`), f.namedNode(`${ns5}property-paths`)),
+        f.quad(f.namedNode(`${ns1}PathShape`), f.namedNode(`${ns3}property`), blankNodes[89]),
+        f.quad(f.namedNode(`${ns1}ShapesListShape`), f.namedNode(`${ns4}type`), f.namedNode(`${ns3}NodeShape`)),
+        f.quad(f.namedNode(`${ns1}ShapesListShape`), f.namedNode(`${ns3}property`), blankNodes[90]),
+        f.quad(f.namedNode(`${ns1}ShapesListShape`), f.namedNode(`${ns3}targetObjectsOf`), f.namedNode(`${ns3}or`)),
+        f.quad(f.namedNode(`${ns1}ShapesListShape`), f.namedNode(`${ns3}targetObjectsOf`), f.namedNode(`${ns3}and`)),
+        f.quad(f.namedNode(`${ns1}ShapesListShape`), f.namedNode(`${ns3}targetObjectsOf`), f.namedNode(`${ns3}xone`)),
+        f.quad(blankNodes[91], f.namedNode(`${ns4}rest`), blankNodes[92]),
+        f.quad(blankNodes[91], f.namedNode(`${ns4}first`), blankNodes[93]),
+        f.quad(blankNodes[93], f.namedNode(`${ns3}zeroOrMorePath`), f.namedNode(`${ns4}rest`)),
+        f.quad(blankNodes[92], f.namedNode(`${ns4}rest`), f.namedNode(`${ns4}nil`)),
+        f.quad(blankNodes[92], f.namedNode(`${ns4}first`), f.namedNode(`${ns4}first`)),
+        f.quad(blankNodes[90], f.namedNode(`${ns3}path`), blankNodes[91]),
+        f.quad(blankNodes[90], f.namedNode(`${ns3}node`), f.namedNode(`${ns1}ShapeShape`)),
+        f.quad(blankNodes[94], f.namedNode(`${ns4}rest`), blankNodes[95]),
+        f.quad(blankNodes[94], f.namedNode(`${ns4}first`), blankNodes[96]),
+        f.quad(blankNodes[96], f.namedNode(`${ns3}zeroOrMorePath`), f.namedNode(`${ns4}rest`)),
+        f.quad(blankNodes[95], f.namedNode(`${ns4}rest`), f.namedNode(`${ns4}nil`)),
+        f.quad(blankNodes[95], f.namedNode(`${ns4}first`), f.namedNode(`${ns4}first`)),
+        f.quad(blankNodes[97], f.namedNode(`${ns4}rest`), blankNodes[98]),
+        f.quad(blankNodes[97], f.namedNode(`${ns4}first`), blankNodes[94]),
+        f.quad(blankNodes[98], f.namedNode(`${ns4}rest`), blankNodes[99]),
+        f.quad(blankNodes[98], f.namedNode(`${ns4}first`), blankNodes[100]),
+        f.quad(blankNodes[100], f.namedNode(`${ns4}rest`), blankNodes[101]),
+        f.quad(blankNodes[100], f.namedNode(`${ns4}first`), f.namedNode(`${ns3}alternativePath`)),
+        f.quad(blankNodes[101], f.namedNode(`${ns4}rest`), blankNodes[102]),
+        f.quad(blankNodes[101], f.namedNode(`${ns4}first`), blankNodes[103]),
+        f.quad(blankNodes[103], f.namedNode(`${ns3}zeroOrMorePath`), f.namedNode(`${ns4}rest`)),
+        f.quad(blankNodes[102], f.namedNode(`${ns4}rest`), f.namedNode(`${ns4}nil`)),
+        f.quad(blankNodes[102], f.namedNode(`${ns4}first`), f.namedNode(`${ns4}first`)),
+        f.quad(blankNodes[99], f.namedNode(`${ns4}rest`), blankNodes[104]),
+        f.quad(blankNodes[99], f.namedNode(`${ns4}first`), f.namedNode(`${ns3}inversePath`)),
+        f.quad(blankNodes[104], f.namedNode(`${ns4}rest`), blankNodes[105]),
+        f.quad(blankNodes[104], f.namedNode(`${ns4}first`), f.namedNode(`${ns3}zeroOrMorePath`)),
+        f.quad(blankNodes[105], f.namedNode(`${ns4}rest`), blankNodes[106]),
+        f.quad(blankNodes[105], f.namedNode(`${ns4}first`), f.namedNode(`${ns3}oneOrMorePath`)),
+        f.quad(blankNodes[106], f.namedNode(`${ns4}rest`), f.namedNode(`${ns4}nil`)),
+        f.quad(blankNodes[106], f.namedNode(`${ns4}first`), f.namedNode(`${ns3}zeroOrOnePath`)),
+        f.quad(blankNodes[107], f.namedNode(`${ns3}alternativePath`), blankNodes[97]),
+        f.quad(blankNodes[108], f.namedNode(`${ns3}zeroOrMorePath`), blankNodes[107]),
+        f.quad(blankNodes[89], f.namedNode(`${ns3}path`), blankNodes[108]),
+        f.quad(blankNodes[89], f.namedNode(`${ns3}node`), f.namedNode(`${ns1}PathNodeShape`)),
+        f.quad(f.namedNode(`${ns1}PathNodeShape`), f.namedNode(`${ns3}xone`), blankNodes[109]),
+        f.quad(blankNodes[109], f.namedNode(`${ns4}rest`), blankNodes[110]),
+        f.quad(blankNodes[109], f.namedNode(`${ns4}first`), blankNodes[111]),
+        f.quad(blankNodes[111], f.namedNode(`${ns3}nodeKind`), f.namedNode(`${ns3}IRI`)),
+        f.quad(blankNodes[110], f.namedNode(`${ns4}rest`), blankNodes[112]),
+        f.quad(blankNodes[110], f.namedNode(`${ns4}first`), blankNodes[113]),
+        f.quad(blankNodes[113], f.namedNode(`${ns3}node`), f.namedNode(`${ns1}PathListWithAtLeast2Members`)),
+        f.quad(blankNodes[113], f.namedNode(`${ns3}nodeKind`), f.namedNode(`${ns3}BlankNode`)),
+        f.quad(f.namedNode(`${ns1}PathListWithAtLeast2Members`), f.namedNode(`${ns4}type`), f.namedNode(`${ns3}NodeShape`)),
+        f.quad(f.namedNode(`${ns1}PathListWithAtLeast2Members`), f.namedNode(`${ns3}node`), f.namedNode(`${ns1}ListShape`)),
+        f.quad(f.namedNode(`${ns1}PathListWithAtLeast2Members`), f.namedNode(`${ns3}property`), blankNodes[114]),
+        f.quad(blankNodes[112], f.namedNode(`${ns4}rest`), blankNodes[115]),
+        f.quad(blankNodes[112], f.namedNode(`${ns4}first`), blankNodes[116]),
+        f.quad(blankNodes[116], f.namedNode(`${ns3}property`), blankNodes[117]),
+        f.quad(blankNodes[116], f.namedNode(`${ns3}closed`), f.literal('true', f.namedNode(`${ns6}boolean`))),
+        f.quad(blankNodes[116], f.namedNode(`${ns3}nodeKind`), f.namedNode(`${ns3}BlankNode`)),
+        f.quad(blankNodes[117], f.namedNode(`${ns3}path`), f.namedNode(`${ns3}alternativePath`)),
+        f.quad(blankNodes[117], f.namedNode(`${ns3}node`), f.namedNode(`${ns1}PathListWithAtLeast2Members`)),
+        f.quad(blankNodes[117], f.namedNode(`${ns3}maxCount`), f.literal('1', f.namedNode(`${ns6}integer`))),
+        f.quad(blankNodes[117], f.namedNode(`${ns3}minCount`), f.literal('1', f.namedNode(`${ns6}integer`))),
+        f.quad(blankNodes[115], f.namedNode(`${ns4}rest`), blankNodes[118]),
+        f.quad(blankNodes[115], f.namedNode(`${ns4}first`), blankNodes[119]),
+        f.quad(blankNodes[119], f.namedNode(`${ns3}property`), blankNodes[120]),
+        f.quad(blankNodes[119], f.namedNode(`${ns3}closed`), f.literal('true', f.namedNode(`${ns6}boolean`))),
+        f.quad(blankNodes[119], f.namedNode(`${ns3}nodeKind`), f.namedNode(`${ns3}BlankNode`)),
+        f.quad(blankNodes[120], f.namedNode(`${ns3}path`), f.namedNode(`${ns3}inversePath`)),
+        f.quad(blankNodes[120], f.namedNode(`${ns3}maxCount`), f.literal('1', f.namedNode(`${ns6}integer`))),
+        f.quad(blankNodes[120], f.namedNode(`${ns3}minCount`), f.literal('1', f.namedNode(`${ns6}integer`))),
+        f.quad(blankNodes[118], f.namedNode(`${ns4}rest`), blankNodes[121]),
+        f.quad(blankNodes[118], f.namedNode(`${ns4}first`), blankNodes[122]),
+        f.quad(blankNodes[122], f.namedNode(`${ns3}property`), blankNodes[123]),
+        f.quad(blankNodes[122], f.namedNode(`${ns3}closed`), f.literal('true', f.namedNode(`${ns6}boolean`))),
+        f.quad(blankNodes[122], f.namedNode(`${ns3}nodeKind`), f.namedNode(`${ns3}BlankNode`)),
+        f.quad(blankNodes[123], f.namedNode(`${ns3}path`), f.namedNode(`${ns3}zeroOrMorePath`)),
+        f.quad(blankNodes[123], f.namedNode(`${ns3}maxCount`), f.literal('1', f.namedNode(`${ns6}integer`))),
+        f.quad(blankNodes[123], f.namedNode(`${ns3}minCount`), f.literal('1', f.namedNode(`${ns6}integer`))),
+        f.quad(blankNodes[121], f.namedNode(`${ns4}rest`), blankNodes[124]),
+        f.quad(blankNodes[121], f.namedNode(`${ns4}first`), blankNodes[125]),
+        f.quad(blankNodes[125], f.namedNode(`${ns3}property`), blankNodes[126]),
+        f.quad(blankNodes[125], f.namedNode(`${ns3}closed`), f.literal('true', f.namedNode(`${ns6}boolean`))),
+        f.quad(blankNodes[125], f.namedNode(`${ns3}nodeKind`), f.namedNode(`${ns3}BlankNode`)),
+        f.quad(blankNodes[126], f.namedNode(`${ns3}path`), f.namedNode(`${ns3}oneOrMorePath`)),
+        f.quad(blankNodes[126], f.namedNode(`${ns3}maxCount`), f.literal('1', f.namedNode(`${ns6}integer`))),
+        f.quad(blankNodes[126], f.namedNode(`${ns3}minCount`), f.literal('1', f.namedNode(`${ns6}integer`))),
+        f.quad(blankNodes[124], f.namedNode(`${ns4}rest`), f.namedNode(`${ns4}nil`)),
+        f.quad(blankNodes[124], f.namedNode(`${ns4}first`), blankNodes[127]),
+        f.quad(blankNodes[127], f.namedNode(`${ns3}property`), blankNodes[128]),
+        f.quad(blankNodes[127], f.namedNode(`${ns3}closed`), f.literal('true', f.namedNode(`${ns6}boolean`))),
+        f.quad(blankNodes[127], f.namedNode(`${ns3}nodeKind`), f.namedNode(`${ns3}BlankNode`)),
+        f.quad(blankNodes[128], f.namedNode(`${ns3}path`), f.namedNode(`${ns3}zeroOrOnePath`)),
+        f.quad(blankNodes[128], f.namedNode(`${ns3}maxCount`), f.literal('1', f.namedNode(`${ns6}integer`))),
+        f.quad(blankNodes[128], f.namedNode(`${ns3}minCount`), f.literal('1', f.namedNode(`${ns6}integer`))),
+        f.quad(blankNodes[129], f.namedNode(`${ns3}oneOrMorePath`), f.namedNode(`${ns4}rest`)),
+        f.quad(blankNodes[114], f.namedNode(`${ns3}path`), blankNodes[129]),
+        f.quad(blankNodes[114], f.namedNode(`${ns3}minCount`), f.literal('2', f.namedNode(`${ns6}integer`))),
+        f.quad(f.namedNode(`${ns1}ShapesGraphShape`), f.namedNode(`${ns4}type`), f.namedNode(`${ns3}NodeShape`)),
+        f.quad(f.namedNode(`${ns1}ShapesGraphShape`), f.namedNode(`${ns3}targetObjectsOf`), f.namedNode(`${ns3}shapesGraph`)),
+        f.quad(f.namedNode(`${ns1}ShapesGraphShape`), f.namedNode(`${ns3}nodeKind`), f.namedNode(`${ns3}IRI`)),
+        f.quad(f.namedNode(`${ns1}EntailmentShape`), f.namedNode(`${ns4}type`), f.namedNode(`${ns3}NodeShape`)),
+        f.quad(f.namedNode(`${ns1}EntailmentShape`), f.namedNode(`${ns3}targetObjectsOf`), f.namedNode(`${ns3}entailment`)),
+        f.quad(f.namedNode(`${ns1}EntailmentShape`), f.namedNode(`${ns3}nodeKind`), f.namedNode(`${ns3}IRI`))
+    ];
+};
+//# sourceMappingURL=shaclShaclQuads.js.map

package/package.json

@@ -0,0 +1,82 @@
+{
+  "dependencies": {
+    "@shaclmate/shacl-ast": "4.0.60",
+    "@rdfjs/dataset": "~2.0.2",
+    "@rdfjs/prefix-map": "~0.1.2",
+    "@rdfjs/types": "~2.0.1",
+    "@rdfx/data-factory": "0.0.30",
+    "@rdfx/parsers": "0.0.30",
+    "@rdfx/resource": "0.0.30",
+    "@rdfx/serializers": "0.0.30",
+    "@types/rdfjs__prefix-map": "~0.1.5",
+    "get-stream": "~9.0.1",
+    "purify-ts": "~2.1.4",
+    "rdf-validate-shacl": "0.6.5",
+    "tmp-promise": "~3.0.3",
+    "ts-log": "~3.0.2",
+    "which": "~6.0.1"
+  },
+  "devDependencies": {
+    "@rdfx/fs": "0.0.30",
+    "@types/rdfjs__dataset": "~2.0.7",
+    "@types/which": "~3.0.4"
+  },
+  "exports": {
+    ".": {
+      "default": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./JenaValidator": {
+      "default": "./dist/JenaValidator.js",
+      "types": "./dist/JenaValidator.d.ts"
+    },
+    "./PyShaclValidator": {
+      "default": "./dist/PyShaclValidator.js",
+      "types": "./dist/PyShaclValidator.d.ts"
+    },
+    "./ZazukoValidator": {
+      "default": "./dist/ZazukoValidator.js",
+      "types": "./dist/ZazukoValidator.d.ts"
+    }
+  },
+  "files": [
+    "dist/JenaValidator.d.ts",
+    "dist/JenaValidator.js",
+    "dist/PyShaclValidator.d.ts",
+    "dist/PyShaclValidator.js",
+    "dist/Validator.d.ts",
+    "dist/Validator.js",
+    "dist/ZazukoValidator.d.ts",
+    "dist/ZazukoValidator.js",
+    "dist/execPromisified.d.ts",
+    "dist/execPromisified.js",
+    "dist/index.d.ts",
+    "dist/index.js",
+    "dist/shacl-shacl.ttl",
+    "dist/shaclShaclDataset.d.ts",
+    "dist/shaclShaclDataset.js",
+    "dist/shaclShaclQuads.d.ts",
+    "dist/shaclShaclQuads.js"
+  ],
+  "license": "Apache-2.0",
+  "main": "./dist/index.js",
+  "name": "@shaclmate/validator",
+  "packageManager": "npm@11.11.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/minorg/shaclmate.git"
+  },
+  "scripts": {
+    "build": "tsc -b && cp src/shacl-shacl.ttl dist/shacl-shacl.ttl",
+    "clean": "rimraf dist",
+    "depcheck": "depcheck .",
+    "dev": "tsc -w --preserveWatchOutput",
+    "dev:tests": "tsc -p __tests__ -w --preserveWatchOutput",
+    "test": "cd ../.. && vitest run /Users/minor/projects/shaclmate/packages/validator/__tests__",
+    "typecheck": "tsc --noEmit",
+    "typecheck:watch": "tsc --noEmit -w --preserveWatchOutput"
+  },
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "version": "4.0.60"
+}