@shaclmate/compiler 4.0.19 → 4.0.21

package/dist/Compiler.d.ts

@@ -1,12 +1,15 @@
 import type { Either } from "purify-ts";
+import type { Logger } from "ts-log";
 import type { TsFeature } from "./enums/TsFeature.js";
 import type { Generator } from "./generators/Generator.js";
 import type { ShapesGraph } from "./input/ShapesGraph.js";
 export declare class Compiler {
     private readonly generator;
+    private readonly logger;
     private readonly tsFeaturesDefault?;
-    constructor({ generator, }: {
+    constructor({ generator, logger, }: {
         generator: Generator;
+        logger: Logger;
         tsFeaturesDefault?: ReadonlySet<TsFeature>;
     });
     compile(shapesGraph: ShapesGraph): Either<Error, string>;

package/dist/Compiler.js

@@ -1,12 +1,15 @@
 import { ShapesGraphToAstTransformer } from "./ShapesGraphToAstTransformer.js";
 export class Compiler {
     generator;
+    logger;
     tsFeaturesDefault;
-    constructor({ generator, }) {
+    constructor({ generator, logger, }) {
         this.generator = generator;
+        this.logger = logger;
     }
     compile(shapesGraph) {
         return new ShapesGraphToAstTransformer({
+            logger: this.logger,
             shapesGraph,
             tsFeaturesDefault: this.tsFeaturesDefault,
         })

package/dist/ShapesGraphToAstTransformer.d.ts

@@ -1,6 +1,7 @@
 import TermMap from "@rdfjs/term-map";
 import type { BlankNode, NamedNode } from "@rdfjs/types";
 import { Either } from "purify-ts";
+import type { Logger } from "ts-log";
 import type * as ast from "./ast/index.js";
 import type { TsFeature } from "./enums/TsFeature.js";
 import type * as input from "./input/index.js";
@@ -12,10 +13,12 @@ interface RelatedNodeShapes {
 }
 export declare class ShapesGraphToAstTransformer {
     protected readonly cachedAstTypesByShapeIdentifier: TermMap<BlankNode | NamedNode, ast.Type>;
+    protected readonly logger: Logger;
     protected readonly shapesGraph: input.ShapesGraph;
     protected readonly relatedNodeShapesByIdentifier: TermMap<BlankNode | NamedNode, RelatedNodeShapes>;
     protected tsFeaturesDefault: ReadonlySet<TsFeature>;
-    constructor({ shapesGraph, tsFeaturesDefault, }: {
+    constructor({ logger, shapesGraph, tsFeaturesDefault, }: {
+        logger: Logger;
         shapesGraph: input.ShapesGraph;
         tsFeaturesDefault?: ReadonlySet<TsFeature>;
     });

package/dist/ShapesGraphToAstTransformer.js

@@ -1,12 +1,10 @@
 import TermMap from "@rdfjs/term-map";
-import { Resource } from "@rdfx/resource";
 import { dash } from "@tpluscode/rdf-ns-builders";
 import { Either } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { ShapeStack } from "./_ShapesGraphToAstTransformer/ShapeStack.js";
 import { transformShapeToAstType } from "./_ShapesGraphToAstTransformer/transformShapeToAstType.js";
-import { logger } from "./logger.js";
-function relatedNodeShapes(shapesGraph) {
+function relatedNodeShapes({ logger, shapesGraph, }) {
     const immediateRelatedNodeShapes = new TermMap();
     for (const childNodeShape of shapesGraph.nodeShapes) {
         let childRelatedNodeShapes = immediateRelatedNodeShapes.get(childNodeShape.$identifier);
@@ -21,7 +19,7 @@ function relatedNodeShapes(shapesGraph) {
             shapesGraph
                 .nodeShape(parentClassIdentifier)
                 .ifLeft((error) => {
-                logger.error("%s is rdfs:subClassOf %s which is either missing or not a node shape: %s", childNodeShape, Resource.Identifier.toString(parentClassIdentifier), error.message);
+                logger.error("%s is rdfs:subClassOf %s which is either missing or not a node shape: %s", childNodeShape, parentClassIdentifier, error.message);
             })
                 .ifRight((parentNodeShape) => {
                 childRelatedNodeShapes.parents.set(parentNodeShape.$identifier, parentNodeShape);
@@ -76,11 +74,16 @@ function relatedNodeShapes(shapesGraph) {
 export class ShapesGraphToAstTransformer {
     // Members are protected so they're accessible to functions in other files
     cachedAstTypesByShapeIdentifier = new TermMap();
+    logger;
     shapesGraph;
     relatedNodeShapesByIdentifier = new TermMap();
     tsFeaturesDefault;
-    constructor({ shapesGraph, tsFeaturesDefault, }) {
-        this.relatedNodeShapesByIdentifier = relatedNodeShapes(shapesGraph);
+    constructor({ logger, shapesGraph, tsFeaturesDefault, }) {
+        this.logger = logger;
+        this.relatedNodeShapesByIdentifier = relatedNodeShapes({
+            logger: this.logger,
+            shapesGraph,
+        });
         this.shapesGraph = shapesGraph;
         this.tsFeaturesDefault =
             tsFeaturesDefault ??

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstObjectTypeProperty.js

@@ -1,4 +1,4 @@
-import dataFactory from "@rdfjs/data-model";
+import dataFactory from "@rdfx/data-factory";
 import { Curie } from "@shaclmate/shacl-ast";
 import { Either, Left, Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstListType.js

@@ -1,4 +1,4 @@
-import dataFactory from "@rdfjs/data-model";
+import dataFactory from "@rdfx/data-factory";
 import { rdf } from "@tpluscode/rdf-ns-builders";
 import { Either, Left, Maybe } from "purify-ts";
 import * as ast from "../ast/index.js";

package/dist/ast/AbstractCollectionType.d.ts

@@ -20,7 +20,7 @@ export declare abstract class AbstractCollectionType<ItemTypeT extends AbstractC
         label: string | undefined;
         name: string | undefined;
         recursive: boolean | undefined;
-        shapeIdentifier: string;
+        shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>;
     };
 }
 export declare namespace AbstractCollectionType {

package/dist/ast/AbstractContainerType.d.ts

@@ -34,7 +34,7 @@ export declare abstract class AbstractContainerType<ItemTypeT extends AbstractCo
         label: string | undefined;
         name: string | undefined;
         recursive: boolean | undefined;
-        shapeIdentifier: string;
+        shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>;
     };
 }
 export declare namespace AbstractContainerType {

package/dist/ast/AbstractLazyObjectType.d.ts

@@ -20,58 +20,28 @@ export declare abstract class AbstractLazyObjectType<PartialTypeT extends Abstra
     equals(other: AbstractLazyObjectType<PartialTypeT, ResolveTypeT>): boolean;
     toJSON(): {
         partialType: {
-            fromRdfType: string | undefined;
+            fromRdfType: import("@rdfjs/types").NamedNode<string> | undefined;
             identifierMintingStrategy: "blankNode" | "sha256" | "uuidv4" | undefined;
             identifierType: {
-                hasValues: ({
-                    termType: "BlankNode";
-                    value: string;
-                    datatype?: undefined;
-                    language?: undefined;
-                } | {
-                    datatype: string;
-                    language: string;
-                    termType: "Literal";
-                    value: string;
-                } | {
-                    termType: "NamedNode";
-                    value: string;
-                    datatype?: undefined;
-                    language?: undefined;
-                })[] | undefined;
-                in: ({
-                    termType: "BlankNode";
-                    value: string;
-                    datatype?: undefined;
-                    language?: undefined;
-                } | {
-                    datatype: string;
-                    language: string;
-                    termType: "Literal";
-                    value: string;
-                } | {
-                    termType: "NamedNode";
-                    value: string;
-                    datatype?: undefined;
-                    language?: undefined;
-                })[] | undefined;
+                hasValues: readonly import("@rdfjs/types").NamedNode<string>[] | undefined;
+                in: readonly import("@rdfjs/types").NamedNode<string>[] | undefined;
                 nodeKinds: NodeKind[];
                 comment: string | undefined;
                 kind: string;
                 label: string | undefined;
                 name: string | undefined;
                 recursive: boolean | undefined;
-                shapeIdentifier: string;
+                shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>;
             };
-            parentObjectTypes: string[] | undefined;
+            parentObjectTypes: (string | import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>)[] | undefined;
             synthetic: boolean | undefined;
-            toRdfTypes: string[] | undefined;
+            toRdfTypes: readonly import("@rdfjs/types").NamedNode<string>[] | undefined;
             comment: string | undefined;
             kind: string;
             label: string | undefined;
             name: string | undefined;
             recursive: boolean | undefined;
-            shapeIdentifier: string;
+            shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>;
         } | {
             members: {
                 discriminantValue: string | number | undefined;
@@ -82,7 +52,7 @@ export declare abstract class AbstractLazyObjectType<PartialTypeT extends Abstra
             label: string | undefined;
             name: string | undefined;
             recursive: boolean | undefined;
-            shapeIdentifier: string;
+            shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>;
         } | {
             itemType: any;
             comment: string | undefined;
@@ -90,61 +60,31 @@ export declare abstract class AbstractLazyObjectType<PartialTypeT extends Abstra
             label: string | undefined;
             name: string | undefined;
             recursive: boolean | undefined;
-            shapeIdentifier: string;
+            shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>;
         };
         resolveType: {
-            fromRdfType: string | undefined;
+            fromRdfType: import("@rdfjs/types").NamedNode<string> | undefined;
             identifierMintingStrategy: "blankNode" | "sha256" | "uuidv4" | undefined;
             identifierType: {
-                hasValues: ({
-                    termType: "BlankNode";
-                    value: string;
-                    datatype?: undefined;
-                    language?: undefined;
-                } | {
-                    datatype: string;
-                    language: string;
-                    termType: "Literal";
-                    value: string;
-                } | {
-                    termType: "NamedNode";
-                    value: string;
-                    datatype?: undefined;
-                    language?: undefined;
-                })[] | undefined;
-                in: ({
-                    termType: "BlankNode";
-                    value: string;
-                    datatype?: undefined;
-                    language?: undefined;
-                } | {
-                    datatype: string;
-                    language: string;
-                    termType: "Literal";
-                    value: string;
-                } | {
-                    termType: "NamedNode";
-                    value: string;
-                    datatype?: undefined;
-                    language?: undefined;
-                })[] | undefined;
+                hasValues: readonly import("@rdfjs/types").NamedNode<string>[] | undefined;
+                in: readonly import("@rdfjs/types").NamedNode<string>[] | undefined;
                 nodeKinds: NodeKind[];
                 comment: string | undefined;
                 kind: string;
                 label: string | undefined;
                 name: string | undefined;
                 recursive: boolean | undefined;
-                shapeIdentifier: string;
+                shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>;
             };
-            parentObjectTypes: string[] | undefined;
+            parentObjectTypes: (string | import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>)[] | undefined;
             synthetic: boolean | undefined;
-            toRdfTypes: string[] | undefined;
+            toRdfTypes: readonly import("@rdfjs/types").NamedNode<string>[] | undefined;
             comment: string | undefined;
             kind: string;
             label: string | undefined;
             name: string | undefined;
             recursive: boolean | undefined;
-            shapeIdentifier: string;
+            shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>;
         } | {
             members: {
                 discriminantValue: string | number | undefined;
@@ -155,7 +95,7 @@ export declare abstract class AbstractLazyObjectType<PartialTypeT extends Abstra
             label: string | undefined;
             name: string | undefined;
             recursive: boolean | undefined;
-            shapeIdentifier: string;
+            shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>;
         } | {
             itemType: any;
             comment: string | undefined;
@@ -163,14 +103,14 @@ export declare abstract class AbstractLazyObjectType<PartialTypeT extends Abstra
             label: string | undefined;
             name: string | undefined;
             recursive: boolean | undefined;
-            shapeIdentifier: string;
+            shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>;
         };
         comment: string | undefined;
         kind: string;
         label: string | undefined;
         name: string | undefined;
         recursive: boolean | undefined;
-        shapeIdentifier: string;
+        shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>;
     };
 }
 export declare namespace AbstractLazyObjectType {

package/dist/ast/AbstractTermType.d.ts

@@ -19,45 +19,15 @@ export declare abstract class AbstractTermType<ConstantTermT extends Literal | N
     } & ConstructorParameters<typeof AbstractType>[0]);
     equals(other: AbstractTermType<ConstantTermT, _RuntimeTermT>): boolean;
     toJSON(): {
-        hasValues: ({
-            termType: "BlankNode";
-            value: string;
-            datatype?: undefined;
-            language?: undefined;
-        } | {
-            datatype: string;
-            language: string;
-            termType: "Literal";
-            value: string;
-        } | {
-            termType: "NamedNode";
-            value: string;
-            datatype?: undefined;
-            language?: undefined;
-        })[] | undefined;
-        in: ({
-            termType: "BlankNode";
-            value: string;
-            datatype?: undefined;
-            language?: undefined;
-        } | {
-            datatype: string;
-            language: string;
-            termType: "Literal";
-            value: string;
-        } | {
-            termType: "NamedNode";
-            value: string;
-            datatype?: undefined;
-            language?: undefined;
-        })[] | undefined;
+        hasValues: readonly ConstantTermT[] | undefined;
+        in: readonly ConstantTermT[] | undefined;
         nodeKinds: import("@shaclmate/shacl-ast").NodeKind[];
         comment: string | undefined;
         kind: string;
         label: string | undefined;
         name: string | undefined;
         recursive: boolean | undefined;
-        shapeIdentifier: string;
+        shapeIdentifier: BlankNode | NamedNode<string>;
     };
 }
 //# sourceMappingURL=AbstractTermType.d.ts.map

package/dist/ast/AbstractTermType.js

@@ -1,6 +1,5 @@
 import { AbstractType } from "./AbstractType.js";
 import { arrayEquals, setEquals, strictEquals, termEquals } from "./equals.js";
-import { termToJson } from "./termToJson.js";
 /**
  * Abstract base class of term types (BlankNodeType, IdentifierType, LiteralType, IriType, TermType).
  *
@@ -39,8 +38,8 @@ export class AbstractTermType extends AbstractType {
     toJSON() {
         return {
             ...super.toJSON(),
-            hasValues: this.hasValues.length > 0 ? this.hasValues.map(termToJson) : undefined,
-            in: this.in_.length > 0 ? this.in_.map(termToJson) : undefined,
+            hasValues: this.hasValues.length > 0 ? this.hasValues : undefined,
+            in: this.in_.length > 0 ? this.in_ : undefined,
             nodeKinds: [...this.nodeKinds],
         };
     }

package/dist/ast/AbstractType.d.ts

@@ -48,7 +48,7 @@ export declare abstract class AbstractType {
         label: string | undefined;
         name: string | undefined;
         recursive: boolean | undefined;
-        shapeIdentifier: string;
+        shapeIdentifier: BlankNode | NamedNode<string>;
     };
     toString(): string;
 }

package/dist/ast/AbstractType.js

@@ -1,4 +1,3 @@
-import { Resource } from "@rdfx/resource";
 import { Maybe } from "purify-ts";
 import { maybeEquals, strictEquals } from "./equals.js";
 /**
@@ -43,7 +42,7 @@ export class AbstractType {
             label: this.label.extract(),
             name: this.name.extract(),
             recursive: this.recursive ? true : undefined,
-            shapeIdentifier: Resource.Identifier.toString(this.shapeIdentifier),
+            shapeIdentifier: this.shapeIdentifier,
         };
     }
     toString() {

package/dist/ast/BlankNodeType.d.ts

@@ -6,6 +6,6 @@ import { AbstractTermType } from "./AbstractTermType.js";
 export declare class BlankNodeType extends AbstractTermType<NamedNode, BlankNode> {
     readonly kind = "BlankNodeType";
     readonly nodeKinds: ReadonlySet<"BlankNode">;
-    constructor(superParameters: Pick<ConstructorParameters<typeof AbstractTermType<NamedNode, BlankNode>>[0], "comment" | "label" | "name" | "shapeIdentifier">);
+    constructor(superParameters: Omit<ConstructorParameters<typeof AbstractTermType<NamedNode, BlankNode>>[0], "hasValues" | "in_">);
 }
 //# sourceMappingURL=BlankNodeType.d.ts.map

package/dist/ast/DefaultValueType.d.ts

@@ -18,29 +18,14 @@ export declare class DefaultValueType<ItemTypeT extends DefaultValueType.ItemTyp
     });
     equals(other: DefaultValueType<ItemTypeT>): boolean;
     toJSON(): {
-        defaultValue: {
-            termType: "BlankNode";
-            value: string;
-            datatype?: undefined;
-            language?: undefined;
-        } | {
-            datatype: string;
-            language: string;
-            termType: "Literal";
-            value: string;
-        } | {
-            termType: "NamedNode";
-            value: string;
-            datatype?: undefined;
-            language?: undefined;
-        };
+        defaultValue: Literal | NamedNode<string>;
         itemType: any;
         comment: string | undefined;
         kind: string;
         label: string | undefined;
         name: string | undefined;
         recursive: boolean | undefined;
-        shapeIdentifier: string;
+        shapeIdentifier: import("@rdfjs/types").BlankNode | NamedNode<string>;
     };
 }
 export declare namespace DefaultValueType {

package/dist/ast/DefaultValueType.js

@@ -1,6 +1,5 @@
 import { AbstractContainerType } from "./AbstractContainerType.js";
 import { termEquals } from "./equals.js";
-import { termToJson } from "./termToJson.js";
 /**
  * A type with an sh:defaultValue.
  *
@@ -34,7 +33,7 @@ export class DefaultValueType extends AbstractContainerType {
     toJSON() {
         return {
             ...super.toJSON(),
-            defaultValue: termToJson(this.defaultValue),
+            defaultValue: this.defaultValue,
         };
     }
 }

package/dist/ast/IdentifierType.d.ts

@@ -7,6 +7,6 @@ import { AbstractTermType } from "./AbstractTermType.js";
 export declare class IdentifierType extends AbstractTermType<NamedNode, BlankNode | NamedNode> {
     readonly kind = "IdentifierType";
     readonly nodeKinds: ReadonlySet<IdentifierNodeKind>;
-    constructor(superParameters: Pick<ConstructorParameters<typeof AbstractTermType<NamedNode, BlankNode>>[0], "comment" | "label" | "name" | "shapeIdentifier">);
+    constructor(superParameters: Omit<ConstructorParameters<typeof AbstractTermType<NamedNode, BlankNode>>[0], "hasValues" | "in_">);
 }
 //# sourceMappingURL=IdentifierType.d.ts.map

package/dist/ast/LiteralType.d.ts

@@ -20,111 +20,21 @@ export declare class LiteralType extends AbstractTermType<Literal, Literal> {
     } & Omit<ConstructorParameters<typeof AbstractTermType<Literal, Literal>>[0], "nodeKinds">);
     equals(other: AbstractTermType<Literal, Literal>): boolean;
     toJSON(): {
-        datatype: string | undefined;
+        datatype: NamedNode<string> | undefined;
         languageIn: readonly string[] | undefined;
-        maxExclusive: {
-            termType: "BlankNode";
-            value: string;
-            datatype?: undefined;
-            language?: undefined;
-        } | {
-            datatype: string;
-            language: string;
-            termType: "Literal";
-            value: string;
-        } | {
-            termType: "NamedNode";
-            value: string;
-            datatype?: undefined;
-            language?: undefined;
-        } | undefined;
-        maxInclusive: {
-            termType: "BlankNode";
-            value: string;
-            datatype?: undefined;
-            language?: undefined;
-        } | {
-            datatype: string;
-            language: string;
-            termType: "Literal";
-            value: string;
-        } | {
-            termType: "NamedNode";
-            value: string;
-            datatype?: undefined;
-            language?: undefined;
-        } | undefined;
-        minExclusive: {
-            termType: "BlankNode";
-            value: string;
-            datatype?: undefined;
-            language?: undefined;
-        } | {
-            datatype: string;
-            language: string;
-            termType: "Literal";
-            value: string;
-        } | {
-            termType: "NamedNode";
-            value: string;
-            datatype?: undefined;
-            language?: undefined;
-        } | undefined;
-        minInclusive: {
-            termType: "BlankNode";
-            value: string;
-            datatype?: undefined;
-            language?: undefined;
-        } | {
-            datatype: string;
-            language: string;
-            termType: "Literal";
-            value: string;
-        } | {
-            termType: "NamedNode";
-            value: string;
-            datatype?: undefined;
-            language?: undefined;
-        } | undefined;
-        hasValues: ({
-            termType: "BlankNode";
-            value: string;
-            datatype?: undefined;
-            language?: undefined;
-        } | {
-            datatype: string;
-            language: string;
-            termType: "Literal";
-            value: string;
-        } | {
-            termType: "NamedNode";
-            value: string;
-            datatype?: undefined;
-            language?: undefined;
-        })[] | undefined;
-        in: ({
-            termType: "BlankNode";
-            value: string;
-            datatype?: undefined;
-            language?: undefined;
-        } | {
-            datatype: string;
-            language: string;
-            termType: "Literal";
-            value: string;
-        } | {
-            termType: "NamedNode";
-            value: string;
-            datatype?: undefined;
-            language?: undefined;
-        })[] | undefined;
+        maxExclusive: Literal | undefined;
+        maxInclusive: Literal | undefined;
+        minExclusive: Literal | undefined;
+        minInclusive: Literal | undefined;
+        hasValues: readonly Literal[] | undefined;
+        in: readonly Literal[] | undefined;
         nodeKinds: import("@shaclmate/shacl-ast").NodeKind[];
         comment: string | undefined;
         kind: string;
         label: string | undefined;
         name: string | undefined;
         recursive: boolean | undefined;
-        shapeIdentifier: string;
+        shapeIdentifier: import("@rdfjs/types").BlankNode | NamedNode<string>;
     };
 }
 //# sourceMappingURL=LiteralType.d.ts.map

package/dist/ast/LiteralType.js

@@ -1,7 +1,5 @@
-import { Resource } from "@rdfx/resource";
 import { AbstractTermType } from "./AbstractTermType.js";
 import { arrayEquals, maybeEquals, strictEquals, termEquals, } from "./equals.js";
-import { termToJson } from "./termToJson.js";
 export class LiteralType extends AbstractTermType {
     datatype;
     kind = "LiteralType";
@@ -48,12 +46,12 @@ export class LiteralType extends AbstractTermType {
     toJSON() {
         return {
             ...super.toJSON(),
-            datatype: this.datatype.map(Resource.Identifier.toString).extract(),
+            datatype: this.datatype.extract(),
             languageIn: this.languageIn.length > 0 ? this.languageIn : undefined,
-            maxExclusive: this.maxExclusive.map(termToJson).extract(),
-            maxInclusive: this.maxInclusive.map(termToJson).extract(),
-            minExclusive: this.minExclusive.map(termToJson).extract(),
-            minInclusive: this.minInclusive.map(termToJson).extract(),
+            maxExclusive: this.maxExclusive.extract(),
+            maxInclusive: this.maxInclusive.extract(),
+            minExclusive: this.minExclusive.extract(),
+            minInclusive: this.minInclusive.extract(),
         };
     }
 }

package/dist/ast/ObjectCompoundType.js

@@ -1,5 +1,4 @@
 import TermSet from "@rdfjs/term-set";
-import { Resource } from "@rdfx/resource";
 import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { BlankNodeType } from "./BlankNodeType.js";
@@ -79,7 +78,7 @@ export var ObjectCompoundType;
         }
         if (fromRdfTypes.size > 0 &&
             fromRdfTypes.size !== expectUniqueFromRdfTypesCount) {
-            throw new Error(`one or more ${objectCompoundType} members ([${memberObjectTypes_.map((memberType) => memberType.toString()).join(", ")}]) lack distinguishing fromRdfType's ({${[...fromRdfTypes].map((fromRdfType) => Resource.Identifier.toString(fromRdfType)).join(", ")}})`);
+            throw new Error(`one or more ${objectCompoundType} members ([${memberObjectTypes_.map((memberType) => memberType.toString()).join(", ")}]) lack distinguishing fromRdfType's ({${[...fromRdfTypes].join(", ")}})`);
         }
         return memberObjectTypes_;
     }