@shaclmate/shacl-ast 3.0.4 → 4.0.0

package/dist/index.d.ts

@@ -1,12 +1,10 @@
-export * from "./defaultFactory.js";
-export * from "./Factory.js";
 export * from "./IdentifierNodeKind.js";
 export * from "./NodeKind.js";
-export * from "./PropertyPath.js";
 export * from "./NodeShape.js";
 export * from "./Ontology.js";
+export * from "./OntologyLike.js";
 export * from "./PropertyGroup.js";
 export * from "./PropertyShape.js";
 export * from "./Shape.js";
-export * from "./RdfjsShapesGraph.js";
+export * from "./ShapesGraph.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,12 +1,10 @@
-export * from "./defaultFactory.js";
-export * from "./Factory.js";
 export * from "./IdentifierNodeKind.js";
 export * from "./NodeKind.js";
-export * from "./PropertyPath.js";
 export * from "./NodeShape.js";
 export * from "./Ontology.js";
+export * from "./OntologyLike.js";
 export * from "./PropertyGroup.js";
 export * from "./PropertyShape.js";
 export * from "./Shape.js";
-export * from "./RdfjsShapesGraph.js";
+export * from "./ShapesGraph.js";
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,26 +1,29 @@
 {
   "dependencies": {
-    "@rdfjs/term-map": "^2.0.2",
-    "@rdfjs/term-set": "^2.0.3",
-    "@rdfjs/types": "^1.1.0",
-    "@tpluscode/rdf-ns-builders": "^4.3.0",
-    "@types/n3": "^1.26.0",
-    "@types/rdfjs__term-map": "^2.0.10",
-    "@types/rdfjs__term-set": "^2.0.9",
-    "n3": "^1.26.0",
-    "purify-ts": "^2.1.0",
-    "rdfjs-resource": "1.0.24"
+    "@rdfjs/data-model": "~2.1.1",
+    "@rdfjs/dataset": "~2.0.2",
+    "@rdfjs/term-map": "~2.0.2",
+    "@rdfjs/term-set": "~2.0.3",
+    "@rdfjs/types": "~2.0.1",
+    "@tpluscode/rdf-ns-builders": "~4.3.0",
+    "@types/rdfjs__data-model": "~2.0.9",
+    "@types/rdfjs__dataset": "~2.0.7",
+    "@types/rdfjs__term-map": "~2.0.10",
+    "@types/rdfjs__term-set": "~2.0.9",
+    "purify-ts": "~2.1.4",
+    "rdfjs-resource": "3.0.6",
+    "typescript-memoize": "~1.1.1"
   },
   "devDependencies": {
-    "@biomejs/biome": "1.9.4",
-    "@tsconfig/node18": "^18.2.4",
-    "@tsconfig/strictest": "^2.0.5",
-    "@types/node": "^22",
-    "depcheck": "^1.4.7",
-    "rimraf": "^6.0.1",
-    "typescript": "5.8.2",
-    "vitest": "^3.2.4",
-    "@vitest/coverage-v8": "^3.2.4"
+    "@tsconfig/node18": "~18.2.4",
+    "@tsconfig/strictest": "~2.0.8",
+    "@types/n3": "~1.26.0",
+    "@types/node": "~18",
+    "depcheck": "~1.4.7",
+    "n3": "~1.26.0",
+    "rimraf": "~6.0.1",
+    "ts-invariant": "~0.10.3",
+    "typescript": "5.9.3"
   },
   "files": [
     "dist/*.d.ts",
@@ -36,21 +39,14 @@
   },
   "scripts": {
     "build": "tsc -b",
-    "build:noEmit": "tsc --noEmit",
-    "check": "biome check",
-    "check:write": "biome check --write",
-    "check:write:unsafe": "biome check --write --unsafe",
     "clean": "rimraf dist",
     "depcheck": "depcheck .",
     "dev": "tsc -w --preserveWatchOutput",
-    "dev:noEmit": "tsc --noEmit -w --preserveWatchOutput",
-    "link-dependencies": "npm link rdfjs-resource",
-    "test": "biome check && vitest run",
-    "test:coverage": "biome check && vitest run --coverage",
-    "test:watch": "biome check && vitest watch",
-    "unlink": "npm unlink -g @shaclmate/shacl-ast"
+    "dev:tests": "tsc -p __tests__ -w --preserveWatchOutput",
+    "typecheck": "tsc --noEmit",
+    "typecheck:watch": "tsc --noEmit -w --preserveWatchOutput"
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "3.0.4"
+  "version": "4.0.0"
 }

package/dist/Factory.d.ts

@@ -1,23 +0,0 @@
-import type { Either } from "purify-ts";
-import type { Resource } from "rdfjs-resource";
-import type { OntologyLike } from "./OntologyLike.js";
-import type { ShapesGraph } from "./ShapesGraph.js";
-export interface Factory<NodeShapeT extends ShapeT, OntologyT extends OntologyLike, PropertyGroupT, PropertyShapeT extends ShapeT, ShapeT> {
-    nodeShapeFromRdf(parameters: {
-        resource: Resource;
-        shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>;
-    }): Either<Error, NodeShapeT>;
-    ontologyFromRdf(parameters: {
-        resource: Resource;
-        shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>;
-    }): Either<Error, OntologyT>;
-    propertyGroupFromRdf(parameters: {
-        resource: Resource;
-        shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>;
-    }): Either<Error, PropertyGroupT>;
-    propertyShapeFromRdf(parameters: {
-        resource: Resource;
-        shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>;
-    }): Either<Error, PropertyShapeT>;
-}
-//# sourceMappingURL=Factory.d.ts.map

package/dist/Factory.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=Factory.js.map

package/dist/PropertyPath.d.ts

@@ -1,41 +0,0 @@
-import type { NamedNode } from "@rdfjs/types";
-import { Either } from "purify-ts";
-import { Resource } from "rdfjs-resource";
-export interface AlternativePath {
-    readonly kind: "AlternativePath";
-    readonly members: readonly PropertyPath[];
-}
-export interface InversePath {
-    readonly kind: "InversePath";
-    readonly path: PropertyPath;
-}
-export interface OneOrMorePath {
-    readonly kind: "OneOrMorePath";
-    readonly path: PropertyPath;
-}
-export interface PredicatePath {
-    readonly iri: NamedNode;
-    readonly kind: "PredicatePath";
-}
-export interface SequencePath {
-    readonly kind: "SequencePath";
-    readonly members: readonly PropertyPath[];
-}
-export interface ZeroOrMorePath {
-    readonly kind: "ZeroOrMorePath";
-    readonly path: PropertyPath;
-}
-export interface ZeroOrOnePath {
-    readonly kind: "ZeroOrOnePath";
-    readonly path: PropertyPath;
-}
-export type PropertyPath = AlternativePath | InversePath | OneOrMorePath | PredicatePath | SequencePath | ZeroOrMorePath | ZeroOrOnePath;
-export declare namespace PropertyPath {
-    function $fromRdf(resource: Resource, _?: {
-        [_index: string]: any;
-        ignoreRdfType?: boolean;
-        preferredLanguages?: readonly string[];
-    }): Either<Error, PropertyPath>;
-    function $toRdf(_propertyPath: PropertyPath, _options?: any): Resource;
-}
-//# sourceMappingURL=PropertyPath.d.ts.map

package/dist/PropertyPath.js

@@ -1,95 +0,0 @@
-import { rdf, sh } from "@tpluscode/rdf-ns-builders";
-import { Either, Left } from "purify-ts";
-import { Resource } from "rdfjs-resource";
-export var PropertyPath;
-(function (PropertyPath) {
-    function $fromRdf(resource, _) {
-        // Predicate path
-        // sh:path ex:parent
-        if (resource.identifier.termType === "NamedNode") {
-            return Either.of({ iri: resource.identifier, kind: "PredicatePath" });
-        }
-        // The other property path types are BlankNodes
-        const getPropertyPathList = (listResource) => {
-            return listResource.toList().chain((values) => {
-                const members = [];
-                for (const value of values) {
-                    const memberResource = value.toResource().toMaybe();
-                    if (memberResource.isNothing()) {
-                        return Left(new Error(`non-identifier in property path list ${Resource.Identifier.toString(listResource.identifier)}`));
-                    }
-                    const member = PropertyPath.$fromRdf(memberResource.unsafeCoerce());
-                    if (member.isLeft()) {
-                        return member;
-                    }
-                    members.push(member.unsafeCoerce());
-                }
-                return Either.of(members);
-            });
-        };
-        for (const quad of resource.dataset.match(resource.identifier, null, null, null)) {
-            switch (quad.object.termType) {
-                case "BlankNode":
-                case "NamedNode":
-                    break;
-                default:
-                    return Left(new Error(`non-BlankNode/NamedNode property path object on path ${Resource.Identifier.toString(resource.identifier)}: ${quad.object.termType} ${quad.object.value}`));
-            }
-            const objectResource = new Resource({
-                dataset: resource.dataset,
-                identifier: quad.object,
-            });
-            // Alternative path
-            // sh:path: [ sh:alternativePath ( ex:father ex:mother  ) ]
-            if (quad.predicate.equals(sh.alternativePath)) {
-                return getPropertyPathList(objectResource).map((members) => ({
-                    kind: "AlternativePath",
-                    members,
-                }));
-            }
-            // Inverse path
-            // sh:path: [ sh:inversePath ex:parent ]
-            if (quad.predicate.equals(sh.inversePath)) {
-                return PropertyPath.$fromRdf(objectResource).map((path) => ({
-                    kind: "InversePath",
-                    path,
-                }));
-            }
-            // One or more path
-            if (quad.predicate.equals(sh.oneOrMorePath)) {
-                return PropertyPath.$fromRdf(objectResource).map((path) => ({
-                    kind: "OneOrMorePath",
-                    path,
-                }));
-            }
-            // Sequence path
-            // sh:path ( ex:parent ex:firstName )
-            if (quad.predicate.equals(rdf.first)) {
-                return getPropertyPathList(objectResource).map((members) => ({
-                    kind: "SequencePath",
-                    members,
-                }));
-            }
-            // Zero or more path
-            if (quad.predicate.equals(sh.zeroOrMorePath)) {
-                return PropertyPath.$fromRdf(objectResource).map((path) => ({
-                    kind: "ZeroOrMorePath",
-                    path,
-                }));
-            }
-            if (quad.predicate.equals(sh.zeroOrOnePath)) {
-                return PropertyPath.$fromRdf(objectResource).map((path) => ({
-                    kind: "ZeroOrOnePath",
-                    path,
-                }));
-            }
-        }
-        return Left(new Error(`unrecognized or ill-formed SHACL property path ${Resource.Identifier.toString(resource.identifier)}`));
-    }
-    PropertyPath.$fromRdf = $fromRdf;
-    function $toRdf(_propertyPath, _options) {
-        throw new Error("not implemented");
-    }
-    PropertyPath.$toRdf = $toRdf;
-})(PropertyPath || (PropertyPath = {}));
-//# sourceMappingURL=PropertyPath.js.map

package/dist/RdfjsShapesGraph.d.ts

@@ -1,31 +0,0 @@
-import type { BlankNode, DatasetCore, DefaultGraph, NamedNode } from "@rdfjs/types";
-import { Maybe } from "purify-ts";
-import type { Factory } from "./Factory.js";
-import type { OntologyLike } from "./OntologyLike.js";
-export declare class RdfjsShapesGraph<NodeShapeT extends ShapeT, OntologyT extends OntologyLike, PropertyGroupT, PropertyShapeT extends ShapeT, ShapeT> {
-    readonly dataset: DatasetCore;
-    readonly node: BlankNode | DefaultGraph | NamedNode | null;
-    readonly nodeShapes: readonly NodeShapeT[];
-    readonly ontologies: readonly OntologyT[];
-    readonly propertyGroups: readonly PropertyGroupT[];
-    readonly propertyShapes: readonly PropertyShapeT[];
-    private readonly nodeShapesByIdentifier;
-    private readonly ontologiesByIdentifier;
-    private readonly propertyGroupsByIdentifier;
-    private readonly propertyShapesByIdentifier;
-    private readonly resourceSet;
-    constructor({ dataset, factory, }: {
-        dataset: DatasetCore;
-        factory: Factory<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>;
-    });
-    nodeShapeByIdentifier(nodeShapeNode: BlankNode | NamedNode): Maybe<NodeShapeT>;
-    ontologyByIdentifier(identifier: BlankNode | NamedNode): Maybe<OntologyT>;
-    propertyGroupByIdentifier(identifier: BlankNode | NamedNode): Maybe<PropertyGroupT>;
-    propertyShapeByIdentifier(identifier: BlankNode | NamedNode): Maybe<PropertyShapeT>;
-    shapeByIdentifier(identifier: BlankNode | NamedNode): Maybe<ShapeT>;
-    private readGraph;
-    private readOntologies;
-    private readPropertyGroups;
-    private readShapes;
-}
-//# sourceMappingURL=RdfjsShapesGraph.d.ts.map

package/dist/RdfjsShapesGraph.js

@@ -1,250 +0,0 @@
-import TermMap from "@rdfjs/term-map";
-import TermSet from "@rdfjs/term-set";
-import { owl, sh } from "@tpluscode/rdf-ns-builders";
-import { Maybe } from "purify-ts";
-import { ResourceSet } from "rdfjs-resource";
-export class RdfjsShapesGraph {
-    dataset;
-    node;
-    nodeShapes;
-    ontologies;
-    propertyGroups;
-    propertyShapes;
-    nodeShapesByIdentifier;
-    ontologiesByIdentifier;
-    propertyGroupsByIdentifier;
-    propertyShapesByIdentifier;
-    resourceSet;
-    constructor({ dataset, factory, }) {
-        this.dataset = dataset;
-        this.resourceSet = new ResourceSet({ dataset: this.dataset });
-        this.node = this.readGraph();
-        const { nodeShapes, nodeShapesByIdentifier, propertyShapes, propertyShapesByIdentifier, } = this.readShapes(factory);
-        this.nodeShapes = nodeShapes;
-        this.nodeShapesByIdentifier = nodeShapesByIdentifier;
-        this.propertyShapes = propertyShapes;
-        this.propertyShapesByIdentifier = propertyShapesByIdentifier;
-        const { ontologies, ontologiesByIdentifier } = this.readOntologies(factory);
-        this.ontologies = ontologies;
-        this.ontologiesByIdentifier = ontologiesByIdentifier;
-        const { propertyGroups, propertyGroupsByIdentifier } = this.readPropertyGroups(factory);
-        this.propertyGroups = propertyGroups;
-        this.propertyGroupsByIdentifier = propertyGroupsByIdentifier;
-    }
-    nodeShapeByIdentifier(nodeShapeNode) {
-        return Maybe.fromNullable(this.nodeShapesByIdentifier.get(nodeShapeNode));
-    }
-    ontologyByIdentifier(identifier) {
-        return Maybe.fromNullable(this.ontologiesByIdentifier.get(identifier));
-    }
-    propertyGroupByIdentifier(identifier) {
-        return Maybe.fromNullable(this.propertyGroupsByIdentifier.get(identifier));
-    }
-    propertyShapeByIdentifier(identifier) {
-        return Maybe.fromNullable(this.propertyShapesByIdentifier.get(identifier));
-    }
-    shapeByIdentifier(identifier) {
-        const nodeShape = this.nodeShapeByIdentifier(identifier);
-        if (nodeShape.isJust()) {
-            return nodeShape;
-        }
-        return this.propertyShapeByIdentifier(identifier);
-    }
-    readGraph() {
-        const graphs = new TermSet();
-        for (const quad of this.dataset) {
-            graphs.add(quad.graph);
-        }
-        if (graphs.size !== 1) {
-            return null;
-        }
-        const graph = [...graphs.values()][0];
-        switch (graph.termType) {
-            case "BlankNode":
-            case "DefaultGraph":
-            case "NamedNode":
-                return graph;
-            default:
-                throw new RangeError(`expected NamedNode or default graph, actual ${graph.termType}`);
-        }
-    }
-    readOntologies(factory) {
-        const ontologies = [];
-        const ontologiesByIdentifier = new TermMap();
-        for (const ontologyResource of this.resourceSet.instancesOf(owl.Ontology, {
-            graph: this.node,
-        })) {
-            if (ontologiesByIdentifier.has(ontologyResource.identifier)) {
-                continue;
-            }
-            factory
-                .ontologyFromRdf({
-                resource: ontologyResource,
-                shapesGraph: this,
-            })
-                .ifRight((ontology) => {
-                ontologies.push(ontology);
-                ontologiesByIdentifier.set(ontologyResource.identifier, ontology);
-            });
-        }
-        return { ontologies, ontologiesByIdentifier };
-    }
-    readPropertyGroups(factory) {
-        const propertyGroups = [];
-        const propertyGroupsByIdentifier = new TermMap();
-        for (const propertyGroupResource of this.resourceSet.instancesOf(sh.PropertyGroup, { graph: this.node })) {
-            if (propertyGroupResource.identifier.termType !== "NamedNode") {
-                continue;
-            }
-            if (propertyGroupsByIdentifier.has(propertyGroupResource.identifier)) {
-                continue;
-            }
-            factory
-                .propertyGroupFromRdf({
-                resource: propertyGroupResource,
-                shapesGraph: this,
-            })
-                .ifRight((propertyGroup) => {
-                propertyGroups.push(propertyGroup);
-                propertyGroupsByIdentifier.set(propertyGroupResource.identifier, propertyGroup);
-            });
-        }
-        return { propertyGroups, propertyGroupsByIdentifier };
-    }
-    readShapes(factory) {
-        // Collect the shape identifiers in sets
-        const shapeNodeSet = new TermSet();
-        // Utility function for doing the collection
-        const addShapeNode = (shapeNode) => {
-            switch (shapeNode.termType) {
-                case "BlankNode":
-                case "NamedNode":
-                    shapeNodeSet.add(shapeNode);
-                    break;
-            }
-        };
-        // Test each shape condition
-        // https://www.w3.org/TR/shacl/#shapes
-        // Subject is a SHACL instance of sh:NodeShape or sh:PropertyShape
-        for (const rdfType of [sh.NodeShape, sh.PropertyShape]) {
-            for (const resource of this.resourceSet.instancesOf(rdfType, {
-                graph: this.node,
-            })) {
-                addShapeNode(resource.identifier);
-            }
-        }
-        // Subject of a triple with sh:targetClass, sh:targetNode, sh:targetObjectsOf, or sh:targetSubjectsOf predicate
-        for (const predicate of [
-            sh.targetClass,
-            sh.targetNode,
-            sh.targetObjectsOf,
-            sh.targetSubjectsOf,
-        ]) {
-            for (const quad of this.dataset.match(null, predicate, null, this.node)) {
-                addShapeNode(quad.subject);
-            }
-        }
-        // Subject of a triple that has a parameter as predicate
-        // https://www.w3.org/TR/shacl/#constraints
-        // https://www.w3.org/TR/shacl/#core-components
-        for (const predicate of [
-            sh.class,
-            sh.datatype,
-            sh.nodeKind,
-            sh.minCount,
-            sh.maxCount,
-            sh.minExclusive,
-            sh.minInclusive,
-            sh.maxExclusive,
-            sh.maxInclusive,
-            sh.minLength,
-            sh.maxLength,
-            sh.pattern,
-            sh.languageIn,
-            sh.uniqueLang,
-            sh.equals,
-            sh.disjoint,
-            sh.lessThan,
-            sh.lessThanOrEquals,
-            sh.not,
-            sh.and,
-            sh.or,
-            sh.xone,
-            sh.node,
-            sh.property,
-            sh.qualifiedValueShape,
-            sh.qualifiedMinCount,
-            sh.qualifiedMaxCount,
-            sh.closed,
-            sh.ignoredProperties,
-            sh.hasValue,
-            sh.in,
-        ]) {
-            for (const quad of this.dataset.match(null, predicate, null, this.node)) {
-                addShapeNode(quad.subject);
-            }
-        }
-        // Object of a shape-expecting, non-list-taking parameter such as sh:node
-        for (const predicate of [sh.node, sh.property]) {
-            for (const quad of this.dataset.match(null, predicate, null, this.node)) {
-                addShapeNode(quad.object);
-            }
-        }
-        // Member of a SHACL list that is a value of a shape-expecting and list-taking parameter such as sh:or
-        for (const predicate of [sh.and, sh.or, sh.xone]) {
-            for (const quad of this.dataset.match(null, predicate, null, this.node)) {
-                switch (quad.object.termType) {
-                    case "BlankNode":
-                    case "NamedNode":
-                        break;
-                    default:
-                        continue;
-                }
-                for (const value of this.resourceSet
-                    .resource(quad.object)
-                    .toList()
-                    .orDefault([])) {
-                    value.toIdentifier().ifRight(addShapeNode);
-                }
-            }
-        }
-        // Separate shapes into node and property shapes.
-        const nodeShapes = [];
-        const nodeShapesByIdentifier = new TermMap();
-        const propertyShapes = [];
-        const propertyShapesByIdentifier = new TermMap();
-        for (const shapeNode of shapeNodeSet) {
-            if (this.dataset.match(shapeNode, sh.path, null, this.node).size > 0) {
-                // A property shape is a shape in the shapes graph that is the subject of a triple that has sh:path as its predicate. A shape has at most one value for sh:path. Each value of sh:path in a shape must be a well-formed SHACL property path. It is recommended, but not required, for a property shape to be declared as a SHACL instance of sh:PropertyShape. SHACL instances of sh:PropertyShape have one value for the property sh:path.
-                factory
-                    .propertyShapeFromRdf({
-                    resource: this.resourceSet.resource(shapeNode),
-                    shapesGraph: this,
-                })
-                    .ifRight((propertyShape) => {
-                    propertyShapes.push(propertyShape);
-                    propertyShapesByIdentifier.set(shapeNode, propertyShape);
-                });
-            }
-            else {
-                // A node shape is a shape in the shapes graph that is not the subject of a triple with sh:path as its predicate. It is recommended, but not required, for a node shape to be declared as a SHACL instance of sh:NodeShape. SHACL instances of sh:NodeShape cannot have a value for the property sh:path.
-                factory
-                    .nodeShapeFromRdf({
-                    resource: this.resourceSet.resource(shapeNode),
-                    shapesGraph: this,
-                })
-                    .ifRight((nodeShape) => {
-                    nodeShapes.push(nodeShape);
-                    nodeShapesByIdentifier.set(shapeNode, nodeShape);
-                });
-            }
-        }
-        return {
-            nodeShapes,
-            nodeShapesByIdentifier,
-            propertyShapes,
-            propertyShapesByIdentifier,
-        };
-    }
-}
-//# sourceMappingURL=RdfjsShapesGraph.js.map

package/dist/defaultFactory.d.ts

@@ -1,12 +0,0 @@
-import type { Factory } from "./Factory.js";
-import { NodeShape } from "./NodeShape.js";
-import { Ontology } from "./Ontology.js";
-import { PropertyGroup } from "./PropertyGroup.js";
-import { PropertyShape } from "./PropertyShape.js";
-import type { Shape } from "./Shape.js";
-type DefaultNodeShape = NodeShape<any, Ontology, PropertyGroup, DefaultPropertyShape, DefaultShape>;
-type DefaultPropertyShape = PropertyShape<DefaultNodeShape, Ontology, PropertyGroup, any, DefaultShape>;
-type DefaultShape = Shape<DefaultNodeShape, Ontology, PropertyGroup, DefaultPropertyShape, any>;
-export declare const defaultFactory: Factory<DefaultNodeShape, Ontology, PropertyGroup, DefaultPropertyShape, DefaultShape>;
-export {};
-//# sourceMappingURL=defaultFactory.d.ts.map

package/dist/defaultFactory.js

@@ -1,28 +0,0 @@
-import { NodeShape } from "./NodeShape.js";
-import { Ontology } from "./Ontology.js";
-import { PropertyGroup } from "./PropertyGroup.js";
-import { PropertyShape } from "./PropertyShape.js";
-import * as generated from "./generated.js";
-export const defaultFactory = {
-    nodeShapeFromRdf({ resource, shapesGraph, }) {
-        return generated.ShaclCoreNodeShape.$fromRdf(resource, {
-            ignoreRdfType: true,
-        }).map((generatedShape) => new NodeShape(generatedShape, shapesGraph));
-    },
-    ontologyFromRdf({ resource, }) {
-        return generated.OwlOntology.$fromRdf(resource, {
-            ignoreRdfType: true,
-        }).map((generatedOntology) => new Ontology(generatedOntology));
-    },
-    propertyGroupFromRdf({ resource, }) {
-        return generated.ShaclCorePropertyGroup.$fromRdf(resource, {
-            ignoreRdfType: true,
-        }).map((propertyGroup) => new PropertyGroup(propertyGroup));
-    },
-    propertyShapeFromRdf({ resource, shapesGraph, }) {
-        return generated.ShaclCorePropertyShape.$fromRdf(resource, {
-            ignoreRdfType: true,
-        }).map((generatedShape) => new PropertyShape(generatedShape, shapesGraph));
-    },
-};
-//# sourceMappingURL=defaultFactory.js.map