@shaclmate/shacl-ast 4.0.7 → 4.0.9

package/dist/Curie.d.ts

@@ -0,0 +1,21 @@
+import type { BlankNode, NamedNode } from "@rdfjs/types";
+/**
+ * A Compact URI (https://www.w3.org/TR/curie)
+ */
+export declare class Curie implements NamedNode {
+    #private;
+    readonly prefix: string;
+    readonly reference: string;
+    readonly termType = "NamedNode";
+    readonly value: string;
+    constructor({ hasUniqueReference, prefix, reference, value, }: {
+        hasUniqueReference?: () => boolean;
+        prefix: string;
+        reference: string;
+        value: string;
+    });
+    equals(other: BlankNode | NamedNode): boolean;
+    get hasUniqueReference(): boolean;
+    toString(): string;
+}
+//# sourceMappingURL=Curie.d.ts.map

package/dist/Curie.js

@@ -0,0 +1,29 @@
+/**
+ * A Compact URI (https://www.w3.org/TR/curie)
+ */
+export class Curie {
+    prefix;
+    #hasUniqueReference;
+    reference;
+    termType = "NamedNode";
+    value;
+    constructor({ hasUniqueReference, prefix, reference, value, }) {
+        this.#hasUniqueReference = hasUniqueReference ?? (() => false);
+        this.prefix = prefix;
+        this.reference = reference;
+        this.value = value;
+    }
+    equals(other) {
+        if (other.termType === "BlankNode") {
+            return false;
+        }
+        return this.value === other.value; // Allow a Curie to equal a NamedNode
+    }
+    get hasUniqueReference() {
+        return this.#hasUniqueReference();
+    }
+    toString() {
+        return `${this.prefix}:${this.reference}`;
+    }
+}
+//# sourceMappingURL=Curie.js.map

package/dist/CurieFactory.d.ts

@@ -0,0 +1,16 @@
+import type PrefixMap from "@rdfjs/prefix-map/PrefixMap.js";
+import type { NamedNode } from "@rdfjs/types";
+import { Maybe } from "purify-ts";
+import { Curie } from "./Curie.js";
+/**
+ * Factory for Compact URIs (CURIEs). Tracks whether the reference part of the CURIE is unique.
+ */
+export declare class CurieFactory {
+    private readonly prefixMap;
+    private readonly referenceCounts;
+    constructor({ prefixMap }: {
+        prefixMap: PrefixMap;
+    });
+    create(namedNode: NamedNode): Maybe<Curie>;
+}
+//# sourceMappingURL=CurieFactory.d.ts.map

package/dist/CurieFactory.js

@@ -0,0 +1,46 @@
+import { Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
+import { Curie } from "./Curie.js";
+/**
+ * Factory for Compact URIs (CURIEs). Tracks whether the reference part of the CURIE is unique.
+ */
+export class CurieFactory {
+    prefixMap;
+    referenceCounts = {};
+    constructor({ prefixMap }) {
+        this.prefixMap = prefixMap;
+    }
+    create(namedNode) {
+        return Maybe.fromNullable(this.prefixMap.shrink(namedNode)?.value).map((value) => {
+            const split = value.split(":", 2);
+            invariant(split.length === 2);
+            const prefix = split[0];
+            const reference = split[1];
+            if (this.referenceCounts[reference] === undefined) {
+                this.referenceCounts[reference] = {};
+            }
+            if (this.referenceCounts[reference][prefix] === undefined) {
+                this.referenceCounts[reference][prefix] = 1;
+            }
+            else {
+                this.referenceCounts[reference][prefix] += 1;
+            }
+            return new Curie({
+                hasUniqueReference: () => {
+                    const referenceCounts = this.referenceCounts[reference];
+                    if (Object.entries(referenceCounts).length === 1) {
+                        return true;
+                    }
+                    // logger.debug(
+                    //   `duplicate local part ${reference} in ${JSON.stringify(referenceCounts)}`,
+                    // );
+                    return false;
+                },
+                prefix: split[0],
+                reference: split[1],
+                value: namedNode.value,
+            });
+        });
+    }
+}
+//# sourceMappingURL=CurieFactory.js.map

package/dist/NodeShape.d.ts

@@ -5,13 +5,13 @@ import { Shape } from "./Shape.js";
 import type { ShapesGraph } from "./ShapesGraph.js";
 export declare class NodeShape<NodeShapeT extends ShapeT, OntologyT extends OntologyLike, PropertyGroupT, PropertyShapeT extends ShapeT, ShapeT> extends Shape<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT> {
     readonly constraints: NodeShape.Constraints<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>;
-    constructor(generatedShaclCoreNodeShape: Omit<generated.ShaclCoreNodeShape, "$type">, shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>);
+    constructor(generatedNodeShape: Omit<generated.NodeShape, "$type">, shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>);
     toString(): string;
 }
 export declare namespace NodeShape {
     class Constraints<NodeShapeT extends ShapeT, OntologyT extends OntologyLike, PropertyGroupT, PropertyShapeT extends ShapeT, ShapeT> extends Shape.Constraints<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT> {
-        private readonly generatedShaclCoreNodeShape;
-        constructor(generatedShaclCoreNodeShape: Omit<generated.ShaclCoreNodeShape, "$type">, shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>);
+        private readonly generatedNodeShape;
+        constructor(generatedNodeShape: Omit<generated.NodeShape, "$type">, shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>);
         get closed(): Maybe<boolean>;
         get properties(): Either<Error, readonly PropertyShapeT[]>;
     }

package/dist/NodeShape.js

@@ -10,9 +10,9 @@ import { Memoize } from "typescript-memoize";
 import { Shape } from "./Shape.js";
 export class NodeShape extends Shape {
     constraints;
-    constructor(generatedShaclCoreNodeShape, shapesGraph) {
-        super(generatedShaclCoreNodeShape, shapesGraph);
-        this.constraints = new NodeShape.Constraints(generatedShaclCoreNodeShape, shapesGraph);
+    constructor(generatedNodeShape, shapesGraph) {
+        super(generatedNodeShape, shapesGraph);
+        this.constraints = new NodeShape.Constraints(generatedNodeShape, shapesGraph);
     }
     toString() {
         return `NodeShape(identifier=${Resource.Identifier.toString(this.identifier)})`;
@@ -23,16 +23,16 @@ __decorate([
 ], NodeShape.prototype, "toString", null);
 (function (NodeShape) {
     class Constraints extends Shape.Constraints {
-        generatedShaclCoreNodeShape;
-        constructor(generatedShaclCoreNodeShape, shapesGraph) {
-            super(generatedShaclCoreNodeShape, shapesGraph);
-            this.generatedShaclCoreNodeShape = generatedShaclCoreNodeShape;
+        generatedNodeShape;
+        constructor(generatedNodeShape, shapesGraph) {
+            super(generatedNodeShape, shapesGraph);
+            this.generatedNodeShape = generatedNodeShape;
         }
         get closed() {
-            return this.generatedShaclCoreNodeShape.closed;
+            return this.generatedNodeShape.closed;
         }
         get properties() {
-            return Either.sequence(this.generatedShaclCoreNodeShape.properties.map((identifier) => this.shapesGraph.propertyShapeByIdentifier(identifier)));
+            return Either.sequence(this.generatedNodeShape.properties.map((identifier) => this.shapesGraph.propertyShapeByIdentifier(identifier)));
         }
     }
     __decorate([

package/dist/Ontology.d.ts

@@ -3,7 +3,7 @@ import type * as generated from "./generated.js";
 import type { OntologyLike } from "./OntologyLike.js";
 export declare class Ontology implements OntologyLike {
     private readonly generatedOntology;
-    constructor(generatedOntology: Omit<generated.OwlOntology, "$type">);
+    constructor(generatedOntology: Omit<generated.Ontology, "$type">);
     get identifier(): BlankNode | NamedNode;
     toString(): string;
 }

package/dist/PropertyGroup.d.ts

@@ -2,7 +2,7 @@ import type { BlankNode, NamedNode } from "@rdfjs/types";
 import type * as generated from "./generated.js";
 export declare class PropertyGroup {
     private readonly delegate;
-    constructor(delegate: generated.ShaclCorePropertyGroup);
+    constructor(delegate: generated.PropertyGroup);
     get comments(): readonly string[];
     get identifier(): BlankNode | NamedNode;
     get labels(): readonly string[];

package/dist/PropertyShape.d.ts

@@ -6,9 +6,9 @@ import type { OntologyLike } from "./OntologyLike.js";
 import { Shape } from "./Shape.js";
 import type { ShapesGraph } from "./ShapesGraph.js";
 export declare class PropertyShape<NodeShapeT extends ShapeT, OntologyT extends OntologyLike, PropertyGroupT, PropertyShapeT extends ShapeT, ShapeT> extends Shape<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT> {
-    private readonly generatedShaclCorePropertyShape;
+    private readonly generatedPropertyShape;
     readonly constraints: Shape.Constraints<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>;
-    constructor(generatedShaclCorePropertyShape: Omit<generated.ShaclCorePropertyShape, "$type">, shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>);
+    constructor(generatedPropertyShape: Omit<generated.PropertyShape, "$type">, shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>);
     get defaultValue(): Maybe<Literal | NamedNode>;
     get descriptions(): readonly string[];
     get groups(): Either<Error, readonly PropertyGroupT[]>;

package/dist/PropertyShape.js

@@ -9,35 +9,35 @@ import { PropertyPath, Resource } from "rdfjs-resource";
 import { Memoize } from "typescript-memoize";
 import { Shape } from "./Shape.js";
 export class PropertyShape extends Shape {
-    generatedShaclCorePropertyShape;
+    generatedPropertyShape;
     constraints;
-    constructor(generatedShaclCorePropertyShape, shapesGraph) {
-        super(generatedShaclCorePropertyShape, shapesGraph);
-        this.generatedShaclCorePropertyShape = generatedShaclCorePropertyShape;
-        this.constraints = new Shape.Constraints(generatedShaclCorePropertyShape, shapesGraph);
+    constructor(generatedPropertyShape, shapesGraph) {
+        super(generatedPropertyShape, shapesGraph);
+        this.generatedPropertyShape = generatedPropertyShape;
+        this.constraints = new Shape.Constraints(generatedPropertyShape, shapesGraph);
     }
     get defaultValue() {
-        return this.generatedShaclCorePropertyShape.defaultValue;
+        return this.generatedPropertyShape.defaultValue;
     }
     get descriptions() {
-        return this.generatedShaclCorePropertyShape.descriptions;
+        return this.generatedPropertyShape.descriptions;
     }
     get groups() {
-        return Either.sequence(this.generatedShaclCorePropertyShape.groups.map((identifier) => this.shapesGraph.propertyGroupByIdentifier(identifier)));
+        return Either.sequence(this.generatedPropertyShape.groups.map((identifier) => this.shapesGraph.propertyGroupByIdentifier(identifier)));
     }
     get names() {
-        return this.generatedShaclCorePropertyShape.names;
+        return this.generatedPropertyShape.names;
     }
     get order() {
-        return this.generatedShaclCorePropertyShape.order;
+        return this.generatedPropertyShape.order;
     }
     get path() {
-        return this.generatedShaclCorePropertyShape.path;
+        return this.generatedPropertyShape.path;
     }
     toString() {
         return `PropertyShape(${[
             `identifier=${Resource.Identifier.toString(this.identifier)}`,
-            `path=${PropertyPath.$toString(this.path)}`,
+            `path=${PropertyPath.toString(this.path)}`,
         ].join(", ")})`;
     }
 }

package/dist/Shape.d.ts

@@ -5,10 +5,10 @@ import type { NodeKind } from "./NodeKind.js";
 import type { OntologyLike } from "./OntologyLike.js";
 import type { ShapesGraph } from "./ShapesGraph.js";
 export declare abstract class Shape<NodeShapeT extends ShapeT, OntologyT extends OntologyLike, PropertyGroupT, PropertyShapeT extends ShapeT, ShapeT> {
-    private readonly generatedShaclCoreShape;
+    private readonly generatedShape;
     protected readonly shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>;
     abstract readonly constraints: Shape.Constraints<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>;
-    constructor(generatedShaclCoreShape: Omit<generated.ShaclCoreShape, "$type">, shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>);
+    constructor(generatedShape: Omit<generated.Shape, "$type">, shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>);
     get comments(): readonly string[];
     get identifier(): BlankNode | NamedNode;
     get isDefinedBy(): Either<Error, Maybe<OntologyT>>;
@@ -16,9 +16,9 @@ export declare abstract class Shape<NodeShapeT extends ShapeT, OntologyT extends
 }
 export declare namespace Shape {
     class Constraints<NodeShapeT extends ShapeT, OntologyT extends OntologyLike, PropertyGroupT, PropertyShapeT extends ShapeT, ShapeT> {
-        private readonly generatedShaclCoreShape;
+        private readonly generatedShape;
         protected readonly shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>;
-        constructor(generatedShaclCoreShape: Omit<generated.ShaclCoreShape, "$type">, shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>);
+        constructor(generatedShape: Omit<generated.Shape, "$type">, shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>);
         get and(): Either<Error, readonly ShapeT[]>;
         get classes(): readonly NamedNode[];
         get datatype(): Maybe<NamedNode>;

package/dist/Shape.js

@@ -7,23 +7,23 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { Either, Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 export class Shape {
-    generatedShaclCoreShape;
+    generatedShape;
     shapesGraph;
-    constructor(generatedShaclCoreShape, shapesGraph) {
-        this.generatedShaclCoreShape = generatedShaclCoreShape;
+    constructor(generatedShape, shapesGraph) {
+        this.generatedShape = generatedShape;
         this.shapesGraph = shapesGraph;
     }
     get comments() {
-        return this.generatedShaclCoreShape.comments;
+        return this.generatedShape.comments;
     }
     get identifier() {
-        return this.generatedShaclCoreShape.$identifier;
+        return this.generatedShape.$identifier;
     }
     get isDefinedBy() {
-        if (this.generatedShaclCoreShape.isDefinedBy.isJust()) {
+        if (this.generatedShape.isDefinedBy.isJust()) {
             // If there's an rdfs:isDefinedBy statement on the shape then don't fall back to anything else
             return this.shapesGraph
-                .ontologyByIdentifier(this.generatedShaclCoreShape.isDefinedBy.unsafeCoerce())
+                .ontologyByIdentifier(this.generatedShape.isDefinedBy.unsafeCoerce())
                 .map(Maybe.of);
         }
         // No rdfs:isDefinedBy statement on the shape
@@ -43,7 +43,7 @@ export class Shape {
         return Either.of(Maybe.empty());
     }
     get labels() {
-        return this.generatedShaclCoreShape.labels;
+        return this.generatedShape.labels;
     }
 }
 __decorate([
@@ -51,50 +51,50 @@ __decorate([
 ], Shape.prototype, "isDefinedBy", null);
 (function (Shape) {
     class Constraints {
-        generatedShaclCoreShape;
+        generatedShape;
         shapesGraph;
-        constructor(generatedShaclCoreShape, shapesGraph) {
-            this.generatedShaclCoreShape = generatedShaclCoreShape;
+        constructor(generatedShape, shapesGraph) {
+            this.generatedShape = generatedShape;
             this.shapesGraph = shapesGraph;
         }
         get and() {
-            return this.shapeListTakingConstraint(this.generatedShaclCoreShape.and);
+            return this.shapeListTakingConstraint(this.generatedShape.and);
         }
         get classes() {
-            return this.generatedShaclCoreShape.classes;
+            return this.generatedShape.classes;
         }
         get datatype() {
-            return this.generatedShaclCoreShape.datatype;
+            return this.generatedShape.datatype;
         }
         get hasValues() {
-            return this.generatedShaclCoreShape.hasValues;
+            return this.generatedShape.hasValues;
         }
         get in_() {
-            return this.generatedShaclCoreShape.in_.orDefault([]);
+            return this.generatedShape.in_.orDefault([]);
         }
         get languageIn() {
-            return this.generatedShaclCoreShape.languageIn.orDefault([]);
+            return this.generatedShape.languageIn.orDefault([]);
         }
         get maxCount() {
-            return this.generatedShaclCoreShape.maxCount;
+            return this.generatedShape.maxCount;
         }
         get maxExclusive() {
-            return this.generatedShaclCoreShape.maxExclusive;
+            return this.generatedShape.maxExclusive;
         }
         get maxInclusive() {
-            return this.generatedShaclCoreShape.maxInclusive;
+            return this.generatedShape.maxInclusive;
         }
         get minCount() {
-            return this.generatedShaclCoreShape.minCount;
+            return this.generatedShape.minCount;
         }
         get minExclusive() {
-            return this.generatedShaclCoreShape.minExclusive;
+            return this.generatedShape.minExclusive;
         }
         get minInclusive() {
-            return this.generatedShaclCoreShape.minInclusive;
+            return this.generatedShape.minInclusive;
         }
         get nodeKinds() {
-            return this.generatedShaclCoreShape.nodeKind
+            return this.generatedShape.nodeKind
                 .map((iri) => {
                 const nodeKinds = new Set();
                 switch (iri.value) {
@@ -125,16 +125,16 @@ __decorate([
                 .orDefault(new Set([]));
         }
         get nodes() {
-            return Either.sequence(this.generatedShaclCoreShape.nodes.map((identifier) => this.shapesGraph.nodeShapeByIdentifier(identifier)));
+            return Either.sequence(this.generatedShape.nodes.map((identifier) => this.shapesGraph.nodeShapeByIdentifier(identifier)));
         }
         get not() {
-            return Either.sequence(this.generatedShaclCoreShape.not.map((identifier) => this.shapesGraph.shapeByIdentifier(identifier)));
+            return Either.sequence(this.generatedShape.not.map((identifier) => this.shapesGraph.shapeByIdentifier(identifier)));
         }
         get or() {
-            return this.shapeListTakingConstraint(this.generatedShaclCoreShape.or);
+            return this.shapeListTakingConstraint(this.generatedShape.or);
         }
         get xone() {
-            return this.shapeListTakingConstraint(this.generatedShaclCoreShape.xone);
+            return this.shapeListTakingConstraint(this.generatedShape.xone);
         }
         shapeListTakingConstraint(identifiers) {
             return Either.sequence(identifiers.flatMap((identifiers) => identifiers.map((identifier) => this.shapesGraph.shapeByIdentifier(identifier))));

package/dist/ShapesGraph.d.ts

@@ -1,7 +1,9 @@
+import PrefixMap from "@rdfjs/prefix-map/PrefixMap.js";
 import TermMap from "@rdfjs/term-map";
 import type { BlankNode, DatasetCore, NamedNode } from "@rdfjs/types";
 import { Either } from "purify-ts";
 import { Resource } from "rdfjs-resource";
+import { CurieFactory } from "./CurieFactory.js";
 import { NodeShape } from "./NodeShape.js";
 import { Ontology } from "./Ontology.js";
 import type { OntologyLike } from "./OntologyLike.js";
@@ -35,23 +37,28 @@ export declare namespace ShapesGraph {
         constructor(parameters?: {
             preferredLanguages?: readonly string[];
         });
-        createShapesGraph({ dataset, ignoreUndefinedShapes, }: {
+        createShapesGraph({ dataset, prefixMap, ignoreUndefinedShapes, }: {
             dataset: DatasetCore;
+            prefixMap?: PrefixMap;
             ignoreUndefinedShapes?: boolean;
         }): Either<Error, ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>>;
         protected abstract createNodeShape(parameters: {
+            curieFactory: CurieFactory;
             resource: Resource;
             shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>;
         }): Either<Error, NodeShapeT>;
         protected abstract createOntology(parameters: {
+            curieFactory: CurieFactory;
             resource: Resource;
             shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>;
         }): Either<Error, OntologyT>;
         protected abstract createPropertyGroup(parameters: {
+            curieFactory: CurieFactory;
             resource: Resource;
             shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>;
         }): Either<Error, PropertyGroupT>;
         protected abstract createPropertyShape(parameters: {
+            curieFactory: CurieFactory;
             resource: Resource;
             shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>;
         }): Either<Error, PropertyShapeT>;
@@ -66,14 +73,17 @@ export declare namespace ShapesGraph {
             shapesGraph: DefaultShapesGraph;
         }): Either<Error, NodeShape<DefaultNodeShape, Ontology, PropertyGroup, DefaultPropertyShape, DefaultShape>>;
         protected createOntology({ resource, }: {
+            curieFactory: CurieFactory;
             resource: Resource;
             shapesGraph: DefaultShapesGraph;
         }): Either<Error, Ontology>;
         protected createPropertyGroup({ resource, }: {
+            curieFactory: CurieFactory;
             resource: Resource;
             shapesGraph: DefaultShapesGraph;
         }): Either<Error, PropertyGroup>;
-        protected createPropertyShape({ resource, shapesGraph, }: {
+        protected createPropertyShape({ curieFactory, resource, shapesGraph, }: {
+            curieFactory: CurieFactory;
             resource: Resource;
             shapesGraph: DefaultShapesGraph;
         }): Either<Error, DefaultPropertyShape>;

package/dist/ShapesGraph.js

@@ -4,12 +4,15 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+import DataFactory from "@rdfjs/data-model";
+import PrefixMap from "@rdfjs/prefix-map/PrefixMap.js";
 import TermMap from "@rdfjs/term-map";
 import TermSet from "@rdfjs/term-set";
 import { owl, sh } from "@tpluscode/rdf-ns-builders";
 import { Either, Left } from "purify-ts";
 import { Resource, ResourceSet } from "rdfjs-resource";
 import { Memoize } from "typescript-memoize";
+import { CurieFactory } from "./CurieFactory.js";
 import * as generated from "./generated.js";
 import { NodeShape } from "./NodeShape.js";
 import { Ontology } from "./Ontology.js";
@@ -84,14 +87,26 @@ __decorate([
         constructor(parameters) {
             this.preferredLanguages = parameters?.preferredLanguages ?? ["en", ""];
         }
-        createShapesGraph({ dataset, ignoreUndefinedShapes, }) {
+        createShapesGraph({ dataset, prefixMap, ignoreUndefinedShapes, }) {
             function datasetHasMatch(subject, predicate, object, graph) {
                 for (const _ of dataset.match(subject, predicate, object, graph)) {
                     return true;
                 }
                 return false;
             }
+            const curieFactory = new CurieFactory({
+                prefixMap: prefixMap ?? new PrefixMap(undefined, { factory: DataFactory }),
+            });
             const resourceSet = new ResourceSet(dataset);
+            const curieResource = (identifier) => {
+                if (identifier.termType === "NamedNode") {
+                    const curie = curieFactory.create(identifier).extract();
+                    if (curie) {
+                        return resourceSet.resource(curie);
+                    }
+                }
+                return resourceSet.resource(identifier);
+            };
             const nodeShapesByIdentifier = new TermMap();
             const ontologiesByIdentifier = new TermMap();
             const propertyGroupsByIdentifier = new TermMap();
@@ -132,7 +147,8 @@ __decorate([
                         continue;
                     }
                     this.createOntology({
-                        resource: ontologyResource,
+                        curieFactory,
+                        resource: curieResource(ontologyResource.identifier),
                         shapesGraph,
                     }).ifRight((ontology) => ontologiesByIdentifier.set(ontologyResource.identifier, ontology));
                 }
@@ -145,7 +161,8 @@ __decorate([
                         continue;
                     }
                     this.createPropertyGroup({
-                        resource: propertyGroupResource,
+                        curieFactory,
+                        resource: curieResource(propertyGroupResource.identifier),
                         shapesGraph,
                     }).ifRight((propertyGroup) => propertyGroupsByIdentifier.set(propertyGroupResource.identifier, propertyGroup));
                 }
@@ -260,14 +277,16 @@ __decorate([
                     if (dataset.match(shapeNode, sh.path, null, graph).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.
                         propertyShapesByIdentifier.set(shapeNode, this.createPropertyShape({
-                            resource: resourceSet.resource(shapeNode),
+                            curieFactory,
+                            resource: curieResource(shapeNode),
                             shapesGraph,
                         }).unsafeCoerce());
                     }
                     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.
                         nodeShapesByIdentifier.set(shapeNode, this.createNodeShape({
-                            resource: resourceSet.resource(shapeNode),
+                            curieFactory,
+                            resource: curieResource(shapeNode),
                             shapesGraph,
                         }).unsafeCoerce());
                     }
@@ -279,28 +298,33 @@ __decorate([
     ShapesGraph.Factory = Factory;
     class DefaultFactory extends Factory {
         createNodeShape({ resource, shapesGraph, }) {
-            return generated.ShaclCoreNodeShape.$fromRdf(resource, {
+            return generated.NodeShape.$fromRdfResource(resource, {
                 ignoreRdfType: true,
                 preferredLanguages: this.preferredLanguages,
             }).map((generatedShape) => new NodeShape(generatedShape, shapesGraph));
         }
         createOntology({ resource, }) {
-            return generated.OwlOntology.$fromRdf(resource, {
+            return generated.Ontology.$fromRdfResource(resource, {
                 ignoreRdfType: true,
                 preferredLanguages: this.preferredLanguages,
             }).map((generatedOntology) => new Ontology(generatedOntology));
         }
         createPropertyGroup({ resource, }) {
-            return generated.ShaclCorePropertyGroup.$fromRdf(resource, {
+            return generated.PropertyGroup.$fromRdfResource(resource, {
                 ignoreRdfType: true,
                 preferredLanguages: this.preferredLanguages,
             }).map((propertyGroup) => new PropertyGroup(propertyGroup));
         }
-        createPropertyShape({ resource, shapesGraph, }) {
-            return generated.ShaclCorePropertyShape.$fromRdf(resource, {
+        createPropertyShape({ curieFactory, resource, shapesGraph, }) {
+            return generated.PropertyShape.$fromRdfResource(resource, {
                 ignoreRdfType: true,
                 preferredLanguages: this.preferredLanguages,
-            }).map((generatedShape) => new PropertyShape(generatedShape, shapesGraph));
+            }).map((generatedShape) => new PropertyShape({
+                ...generatedShape,
+                path: (generatedShape.path.termType === "NamedNode"
+                    ? curieFactory.create(generatedShape.path).extract()
+                    : undefined) ?? generatedShape.path,
+            }, shapesGraph));
         }
     }
     const defaultFactory = new DefaultFactory();