@shaclmate/compiler 4.0.91 → 4.0.93

package/dist/generators/ts/AbstractNumericType.d.ts

@@ -13,6 +13,7 @@ export declare abstract class AbstractNumericType<ValueT extends bigint | number
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractPrimitiveType<string>["toRdfResourceValuesExpression"]>[0]): Code;
 }
 export declare namespace AbstractNumericType {
+    type ConversionFunction = AbstractPrimitiveType.ConversionFunction;
     const JsonType: typeof import("./_AbstractType/AbstractType_JsonType.js").AbstractType_JsonType;
     type JsonType = AbstractPrimitiveType.JsonType;
 }

package/dist/generators/ts/AbstractPrimitiveType.d.ts

@@ -1,5 +1,4 @@
 import type { Primitive } from "@rdfx/literal";
-import { Maybe } from "purify-ts";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
 import { AbstractTypedLiteralType } from "./AbstractTypedLiteralType.js";
 import { type Code } from "./ts-poet-wrapper.js";
@@ -7,12 +6,6 @@ import { type Code } from "./ts-poet-wrapper.js";
  * Abstract base class of typed literals whose datatype corresponds to a JavaScript primitive type.
  */
 export declare abstract class AbstractPrimitiveType<ValueT extends Primitive> extends AbstractTypedLiteralType<ValueT> {
-    /**
-     * Primitive types have no conversion functions to avoid source type overlap with other primitive types.
-     *
-     * A property that can take on multiple primitive types should be a union.
-     */
-    readonly conversionFunction: Maybe<AbstractLiteralType.ConversionFunction>;
     readonly equalsFunction: Code;
     protected get inlineExpression(): Code;
     fromJsonExpression({ variables, }: Parameters<AbstractLiteralType["fromJsonExpression"]>[0]): Code;

package/dist/generators/ts/AbstractPrimitiveType.js

@@ -4,7 +4,6 @@ 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 { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
 import { AbstractTypedLiteralType } from "./AbstractTypedLiteralType.js";
@@ -13,12 +12,6 @@ import { arrayOf, code, joinCode } from "./ts-poet-wrapper.js";
  * Abstract base class of typed literals whose datatype corresponds to a JavaScript primitive type.
  */
 export class AbstractPrimitiveType extends AbstractTypedLiteralType {
-    /**
-     * Primitive types have no conversion functions to avoid source type overlap with other primitive types.
-     *
-     * A property that can take on multiple primitive types should be a union.
-     */
-    conversionFunction = Maybe.empty();
     equalsFunction = code `${this.reusables.snippets.strictEquals}`;
     get inlineExpression() {
         if (this.in_.length > 0) {

package/dist/generators/ts/BigDecimalType.d.ts

@@ -6,18 +6,16 @@ import { AbstractTypedLiteralType } from "./AbstractTypedLiteralType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class BigDecimalType extends AbstractTypedLiteralType<Decimal> {
     protected readonly inlineExpression: Code;
-    /**
-     * BigDecimal has no conversion function to avoid source type overlap with other types (e.g., string).
-     */
+    readonly jsTypes: readonly [{
+        readonly className: Code;
+        readonly instanceof: "class";
+        readonly typeof: "object";
+    }];
     readonly conversionFunction: Maybe<AbstractLiteralType.ConversionFunction>;
     readonly filterFunction: Code;
     readonly filterType: Code;
     readonly fromRdfResourceValuesFunction: Code;
     readonly hashFunction: Code;
-    readonly jsTypes: readonly [{
-        readonly instanceof: "Object";
-        readonly typeof: "object";
-    }];
     readonly kind = "BigDecimal";
     readonly schemaType: Code;
     readonly valueSparqlWherePatternsFunction: Code;
@@ -26,8 +24,8 @@ export declare class BigDecimalType extends AbstractTypedLiteralType<Decimal> {
     graphqlResolveExpression({ variables, }: Parameters<AbstractLiteralType["graphqlResolveExpression"]>[0]): Code;
     jsonSchema(): Code;
     jsonType(): AbstractLiteralType.JsonType;
-    valueExpression(literal: Literal): Code;
     toJsonExpression({ variables, }: Parameters<AbstractTypedLiteralType<Decimal>["toJsonExpression"]>[0]): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractLiteralType["toRdfResourceValuesExpression"]>[0]): Code;
+    valueExpression(literal: Literal): Code;
 }
 //# sourceMappingURL=BigDecimalType.d.ts.map

package/dist/generators/ts/BigDecimalType.js

@@ -11,17 +11,34 @@ import { AbstractTypedLiteralType } from "./AbstractTypedLiteralType.js";
 import { code, literalOf } from "./ts-poet-wrapper.js";
 export class BigDecimalType extends AbstractTypedLiteralType {
     inlineExpression = code `${this.reusables.imports.BigDecimal}`;
-    /**
-     * BigDecimal has no conversion function to avoid source type overlap with other types (e.g., string).
-     */
-    conversionFunction = Maybe.empty();
+    jsTypes = [
+        {
+            className: code `${this.reusables.imports.BigDecimal}`,
+            instanceof: "class",
+            typeof: "object",
+        },
+    ];
+    conversionFunction = Maybe.of({
+        code: code `${this.reusables.snippets.convertToBigDecimal}`,
+        sourceTypes: [
+            {
+                expression: code `${this.reusables.imports.BigDecimal}`,
+                jsType: this.jsTypes[0],
+            },
+            {
+                expression: code `number`,
+                jsType: { typeof: "number" },
+            },
+            {
+                expression: code `string`,
+                jsType: { typeof: "string" },
+            },
+        ],
+    });
     filterFunction = code `${this.reusables.snippets.filterBigDecimal}`;
     filterType = code `${this.reusables.snippets.NumericFilter}<${this.reusables.imports.BigDecimal}>`;
     fromRdfResourceValuesFunction = code `${this.reusables.snippets.bigDecimalFromRdfResourceValues}`;
     hashFunction = code `${this.reusables.snippets.hashBigDecimal}`;
-    jsTypes = [
-        { instanceof: "Object", typeof: "object" },
-    ];
     kind = "BigDecimal";
     schemaType = code `${this.reusables.snippets.NumericSchema}<${this.reusables.imports.BigDecimal}>`;
     valueSparqlWherePatternsFunction = code `${this.reusables.snippets.bigDecimalSparqlWherePatterns}`;
@@ -40,15 +57,15 @@ export class BigDecimalType extends AbstractTypedLiteralType {
     jsonType() {
         return new AbstractLiteralType.JsonType(code `{ readonly "@type": ${literalOf(this.datatype.value)}, readonly "@value": string }`);
     }
-    valueExpression(literal) {
-        return code `new ${this.reusables.imports.BigDecimal}(${literalOf(literal.value)})`;
-    }
     toJsonExpression({ variables, }) {
         return code `{ "@type": ${literalOf(this.datatype.value)} as const, "@value": ${variables.value}.toFixed() }`;
     }
     toRdfResourceValuesExpression({ variables, }) {
         return code `[${this.reusables.snippets.bigDecimalLiteral}(${variables.value})]`;
     }
+    valueExpression(literal) {
+        return code `new ${this.reusables.imports.BigDecimal}(${literalOf(literal.value)})`;
+    }
 }
 __decorate([
     Memoize()

package/dist/generators/ts/BigIntType.d.ts

@@ -1,4 +1,5 @@
 import type { Literal } from "@rdfjs/types";
+import { Maybe } from "purify-ts";
 import { AbstractNumericType } from "./AbstractNumericType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class BigIntType extends AbstractNumericType<bigint> {
@@ -6,6 +7,7 @@ export declare class BigIntType extends AbstractNumericType<bigint> {
         readonly typeof: "bigint";
     }[];
     readonly kind = "BigInt";
+    get conversionFunction(): Maybe<AbstractNumericType.ConversionFunction>;
     get fromRdfResourceValuesFunction(): Code;
     get graphqlType(): import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
     private get decodedIn();

package/dist/generators/ts/BigIntType.js

@@ -5,12 +5,35 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { LiteralDecoder } from "@rdfx/literal";
+import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractNumericType } from "./AbstractNumericType.js";
 import { arrayOf, code, joinCode, literalOf, } from "./ts-poet-wrapper.js";
 export class BigIntType extends AbstractNumericType {
     jsTypes = [{ typeof: "bigint" }];
     kind = "BigInt";
+    get conversionFunction() {
+        if (this.in_.length > 0) {
+            return Maybe.empty();
+        }
+        return Maybe.of({
+            code: code `${this.reusables.snippets.convertToBigInt}`,
+            sourceTypes: [
+                {
+                    expression: code `bigint`,
+                    jsType: this.jsTypes[0],
+                },
+                {
+                    expression: code `number`,
+                    jsType: { typeof: "number" },
+                },
+                {
+                    expression: code `string`,
+                    jsType: { typeof: "string" },
+                },
+            ],
+        });
+    }
     get fromRdfResourceValuesFunction() {
         return code `${this.reusables.snippets.bigIntFromRdfResourceValues}<${this.expression}>`;
     }
@@ -58,6 +81,9 @@ export class BigIntType extends AbstractNumericType {
         return code `${typeof literal === "bigint" ? literal : LiteralDecoder.decodeBigIntLiteral(literal).unsafeCoerce()}n`;
     }
 }
+__decorate([
+    Memoize()
+], BigIntType.prototype, "conversionFunction", null);
 __decorate([
     Memoize()
 ], BigIntType.prototype, "fromRdfResourceValuesFunction", null);

package/dist/generators/ts/BooleanType.d.ts

@@ -1,7 +1,9 @@
 import type { Literal } from "@rdfjs/types";
+import { Maybe } from "purify-ts";
 import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class BooleanType extends AbstractPrimitiveType<boolean> {
+    readonly conversionFunction: Maybe<AbstractPrimitiveType.ConversionFunction>;
     readonly filterFunction: Code;
     readonly filterType: Code;
     readonly graphqlType: import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;

package/dist/generators/ts/BooleanType.js

@@ -5,10 +5,12 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { LiteralDecoder } from "@rdfx/literal";
+import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
 import { code } from "./ts-poet-wrapper.js";
 export class BooleanType extends AbstractPrimitiveType {
+    conversionFunction = Maybe.empty();
     filterFunction = code `${this.reusables.snippets.filterBoolean}`;
     filterType = code `${this.reusables.snippets.BooleanFilter}`;
     graphqlType = new AbstractPrimitiveType.GraphqlType(code `${this.reusables.imports.GraphQLBoolean}`, this.reusables);

package/dist/generators/ts/DefaultValueType.d.ts

@@ -19,7 +19,8 @@ export declare class DefaultValueType<ItemTypeT extends DefaultValueType.ItemTyp
         readonly instanceof: "Object";
         readonly typeof: "object";
     }] | readonly [{
-        readonly instanceof: "Object";
+        readonly className: Code;
+        readonly instanceof: "class";
         readonly typeof: "object";
     }] | {
         readonly typeof: "bigint";

package/dist/generators/ts/FloatType.d.ts

@@ -1,7 +1,9 @@
 import type { Literal } from "@rdfjs/types";
+import { Maybe } from "purify-ts";
 import { AbstractNumericType } from "./AbstractNumericType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class FloatType extends AbstractNumericType<number> {
+    readonly conversionFunction: Maybe<AbstractNumericType.ConversionFunction>;
     readonly jsTypes: readonly [{
         readonly typeof: "number";
     }];

package/dist/generators/ts/FloatType.js

@@ -5,10 +5,12 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { LiteralDecoder } from "@rdfx/literal";
+import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractNumericType } from "./AbstractNumericType.js";
 import { code } from "./ts-poet-wrapper.js";
 export class FloatType extends AbstractNumericType {
+    conversionFunction = Maybe.empty();
     jsTypes = [{ typeof: "number" }];
     kind = "Float";
     get fromRdfResourceValuesFunction() {

package/dist/generators/ts/IntType.d.ts

@@ -1,7 +1,9 @@
 import type { Literal } from "@rdfjs/types";
+import { Maybe } from "purify-ts";
 import { AbstractNumericType } from "./AbstractNumericType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class IntType extends AbstractNumericType<number> {
+    readonly conversionFunction: Maybe<AbstractNumericType.ConversionFunction>;
     readonly jsTypes: readonly [{
         readonly typeof: "number";
     }];

package/dist/generators/ts/IntType.js

@@ -5,10 +5,12 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { LiteralDecoder } from "@rdfx/literal";
+import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractNumericType } from "./AbstractNumericType.js";
 import { code } from "./ts-poet-wrapper.js";
 export class IntType extends AbstractNumericType {
+    conversionFunction = Maybe.empty();
     jsTypes = [{ typeof: "number" }];
     kind = "Int";
     get fromRdfResourceValuesFunction() {

package/dist/generators/ts/Snippets.d.ts

@@ -77,6 +77,8 @@ export declare class Snippets {
     get booleanSparqlWherePatterns(): Snippet;
     get compactRecord(): Snippet;
     get convertToArraySet(): Snippet;
+    get convertToBigDecimal(): Snippet;
+    get convertToBigInt(): Snippet;
     get convertToBlankNode(): Snippet;
     get convertToBlankNodeIdentifierProperty(): Snippet;
     get convertToIdentifier(): Snippet;

package/dist/generators/ts/Snippets.js

@@ -28,6 +28,8 @@ import { snippets_CollectionSchema } from "./_snippets/snippets_CollectionSchema
 import { snippets_ConversionFunction } from "./_snippets/snippets_ConversionFunction.js";
 import { snippets_compactRecord } from "./_snippets/snippets_compactRecord.js";
 import { snippets_convertToArraySet } from "./_snippets/snippets_convertToArraySet.js";
+import { snippets_convertToBigDecimal } from "./_snippets/snippets_convertToBigDecimal.js";
+import { snippets_convertToBigInt } from "./_snippets/snippets_convertToBigInt.js";
 import { snippets_convertToBlankNode } from "./_snippets/snippets_convertToBlankNode.js";
 import { snippets_convertToBlankNodeIdentifierProperty } from "./_snippets/snippets_convertToBlankNodeIdentifierProperty.js";
 import { snippets_convertToIdentifier } from "./_snippets/snippets_convertToIdentifier.js";
@@ -383,6 +385,12 @@ export class Snippets {
     get convertToArraySet() {
         return this.snippet(snippets_convertToArraySet);
     }
+    get convertToBigDecimal() {
+        return this.snippet(snippets_convertToBigDecimal);
+    }
+    get convertToBigInt() {
+        return this.snippet(snippets_convertToBigInt);
+    }
     get convertToBlankNode() {
         return this.snippet(snippets_convertToBlankNode);
     }
@@ -933,6 +941,12 @@ __decorate([
 __decorate([
     Memoize()
 ], Snippets.prototype, "convertToArraySet", null);
+__decorate([
+    Memoize()
+], Snippets.prototype, "convertToBigDecimal", null);
+__decorate([
+    Memoize()
+], Snippets.prototype, "convertToBigInt", null);
 __decorate([
     Memoize()
 ], Snippets.prototype, "convertToBlankNode", null);

package/dist/generators/ts/StringType.d.ts

@@ -1,8 +1,10 @@
 import type { Literal } from "@rdfjs/types";
+import { Maybe } from "purify-ts";
 import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class StringType extends AbstractPrimitiveType<string> {
     private readonly languageIn;
+    readonly conversionFunction: Maybe<AbstractPrimitiveType.ConversionFunction>;
     readonly filterFunction: Code;
     readonly filterType: Code;
     readonly graphqlType: import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
@@ -19,7 +21,7 @@ export declare class StringType extends AbstractPrimitiveType<string> {
     get schemaType(): Code;
     protected get schemaInitializers(): readonly Code[];
     jsonSchema(parameters: Parameters<AbstractPrimitiveType<string>["jsonSchema"]>[0]): Code;
-    valueExpression(literal: Literal | string): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractPrimitiveType<string>["toRdfResourceValuesExpression"]>[0]): Code;
+    valueExpression(literal: Literal | string): Code;
 }
 //# sourceMappingURL=StringType.d.ts.map

package/dist/generators/ts/StringType.js

@@ -5,11 +5,13 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { xsd } from "@tpluscode/rdf-ns-builders";
+import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
 import { arrayOf, code, literalOf } from "./ts-poet-wrapper.js";
 export class StringType extends AbstractPrimitiveType {
     languageIn;
+    conversionFunction = Maybe.empty();
     filterFunction = code `${this.reusables.snippets.filterString}`;
     filterType = code `${this.reusables.snippets.StringFilter}`;
     graphqlType = new AbstractPrimitiveType.GraphqlType(code `${this.reusables.imports.GraphQLString}`, this.reusables);
@@ -51,12 +53,12 @@ export class StringType extends AbstractPrimitiveType {
         }
         return super.jsonSchema(parameters);
     }
-    valueExpression(literal) {
-        return code `${literalOf(typeof literal === "string" ? literal : literal.value)}`;
-    }
     toRdfResourceValuesExpression({ variables, }) {
         return code `[${this.reusables.snippets.literalFactory}.string(${variables.value}${!this.datatype.equals(xsd.string) ? `, ${this.rdfjsTermExpression(this.datatype)}` : ""})]`;
     }
+    valueExpression(literal) {
+        return code `${literalOf(typeof literal === "string" ? literal : literal.value)}`;
+    }
 }
 __decorate([
     Memoize()

package/dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_conversionFunctionExpression.js

@@ -5,6 +5,8 @@ import { code, joinCode } from "../ts-poet-wrapper.js";
 export function AbstractDiscriminatedUnionType_conversionFunctionExpression() {
     if (this.discriminant.kind === "Typeof") {
         // If the members are discriminated by typeof, they can all be used as source types.
+        // Don't consider the member types' conversion functions, since the source types might overlap.
+        // Only consider the member types' declared type(s) (e.g., type.jsTypes).
         return Maybe.of({
             code: code `${this.reusables.snippets.identityConversionFunction}`,
             sourceTypes: this.members.flatMap(({ type }) => type.jsTypes.map((jsType) => ({

package/dist/generators/ts/_snippets/snippets_NamespaceBuilder.js

@@ -3,7 +3,7 @@ export const snippets_NamespaceBuilder = ({ imports, syntheticNamePrefix, }) =>
 /**
  * NamespaceBuilder type excerpted from @rdfjs/namespace (MIT license) in lieu of a type import.
  */
-type ${syntheticNamePrefix}NamespaceBuilder<TermNames extends string = any> = Record<TermNames, NamedNode> & {
+export type ${syntheticNamePrefix}NamespaceBuilder<TermNames extends string = any> = Record<TermNames, NamedNode> & {
     (property?: TemplateStringsArray | TermNames): ${imports.NamedNode};
 };`);
 //# sourceMappingURL=snippets_NamespaceBuilder.js.map

package/dist/generators/ts/_snippets/snippets_convertToBigDecimal.d.ts

@@ -0,0 +1,3 @@
+import type { SnippetFactory } from "../SnippetFactory.js";
+export declare const snippets_convertToBigDecimal: SnippetFactory;
+//# sourceMappingURL=snippets_convertToBigDecimal.d.ts.map

package/dist/generators/ts/_snippets/snippets_convertToBigDecimal.js

@@ -0,0 +1,5 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_convertToBigDecimal = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToBigDecimal`, code `\
+const ${syntheticNamePrefix}convertToBigDecimal: ${snippets.ConversionFunction}<number | string | ${imports.BigDecimal}, ${imports.BigDecimal}> = (value) =>
+  ${imports.Either}.encase(() => new ${imports.BigDecimal}(value));`);
+//# sourceMappingURL=snippets_convertToBigDecimal.js.map

package/dist/generators/ts/_snippets/snippets_convertToBigInt.d.ts

@@ -0,0 +1,3 @@
+import type { SnippetFactory } from "../SnippetFactory.js";
+export declare const snippets_convertToBigInt: SnippetFactory;
+//# sourceMappingURL=snippets_convertToBigInt.d.ts.map

package/dist/generators/ts/_snippets/snippets_convertToBigInt.js

@@ -0,0 +1,5 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_convertToBigInt = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToBigInt`, code `\
+const ${syntheticNamePrefix}convertToBigInt: ${snippets.ConversionFunction}<bigint | number | string, bigint> = (value) =>
+  ${imports.Either}.encase(() => BigInt(value));`);
+//# sourceMappingURL=snippets_convertToBigInt.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "dependencies": {
-    "@shaclmate/shacl-ast": "4.0.91",
+    "@shaclmate/shacl-ast": "4.0.93",
     "@rdfjs/types": "~2.0.1",
     "@rdfx/collection": "0.0.57",
     "@rdfx/data-factory": "0.0.57",
@@ -483,6 +483,10 @@
     "dist/generators/ts/_snippets/snippets_compactRecord.js",
     "dist/generators/ts/_snippets/snippets_convertToArraySet.d.ts",
     "dist/generators/ts/_snippets/snippets_convertToArraySet.js",
+    "dist/generators/ts/_snippets/snippets_convertToBigDecimal.d.ts",
+    "dist/generators/ts/_snippets/snippets_convertToBigDecimal.js",
+    "dist/generators/ts/_snippets/snippets_convertToBigInt.d.ts",
+    "dist/generators/ts/_snippets/snippets_convertToBigInt.js",
     "dist/generators/ts/_snippets/snippets_convertToBlankNode.d.ts",
     "dist/generators/ts/_snippets/snippets_convertToBlankNode.js",
     "dist/generators/ts/_snippets/snippets_convertToBlankNodeIdentifierProperty.d.ts",
@@ -735,5 +739,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "4.0.91"
+  "version": "4.0.93"
 }