@sinclair/typebox 0.32.0-dev-27 → 0.32.0

package/build/import/type/record/record.d.mts

@@ -5,6 +5,7 @@ import { type TObject, type TProperties, type TAdditionalProperties, type Object
 import { type TLiteral, type TLiteralValue } from '../literal/index.mjs';
 import { type TNever } from '../never/index.mjs';
 import { type TUnion } from '../union/index.mjs';
+import { type TRegExp } from '../regexp/index.mjs';
 import { type TString } from '../string/index.mjs';
 import { type TInteger } from '../integer/index.mjs';
 import { type TNumber } from '../number/index.mjs';
@@ -30,6 +31,7 @@ type TFromUnionKey<K extends TSchema[], T extends TSchema, P extends TProperties
 type TFromLiteralKey<K extends TLiteralValue, T extends TSchema> = (Ensure<TObject<{
     [_ in Assert<K, PropertyKey>]: T;
 }>>);
+type TFromRegExpKey<_ extends TRegExp, T extends TSchema> = (Ensure<TRecord<TRegExp, T>>);
 type TFromStringKey<_ extends TString, T extends TSchema> = (Ensure<TRecord<TString, T>>);
 type TFromIntegerKey<_ extends TSchema, T extends TSchema> = (Ensure<TRecord<TNumber, T>>);
 type TFromNumberKey<_ extends TSchema, T extends TSchema> = (Ensure<TRecord<TNumber, T>>);
@@ -43,7 +45,7 @@ export interface TRecord<K extends TSchema = TSchema, T extends TSchema = TSchem
     };
     additionalProperties: TAdditionalProperties;
 }
-export type TRecordOrObject<K extends TSchema, T extends TSchema> = K extends TTemplateLiteral ? TFromTemplateLiteralKey<K, T> : K extends TEnum<infer S> ? TFromEnumKey<S, T> : K extends TUnion<infer S> ? TFromUnionKey<S, T> : K extends TLiteral<infer S> ? TFromLiteralKey<S, T> : K extends TInteger ? TFromIntegerKey<K, T> : K extends TNumber ? TFromNumberKey<K, T> : K extends TString ? TFromStringKey<K, T> : TNever;
+export type TRecordOrObject<K extends TSchema, T extends TSchema> = K extends TTemplateLiteral ? TFromTemplateLiteralKey<K, T> : K extends TEnum<infer S> ? TFromEnumKey<S, T> : K extends TUnion<infer S> ? TFromUnionKey<S, T> : K extends TLiteral<infer S> ? TFromLiteralKey<S, T> : K extends TInteger ? TFromIntegerKey<K, T> : K extends TNumber ? TFromNumberKey<K, T> : K extends TRegExp ? TFromRegExpKey<K, T> : K extends TString ? TFromStringKey<K, T> : TNever;
 /** `[Json]` Creates a Record type */
 export declare function Record<K extends TSchema, T extends TSchema>(K: K, T: T, options?: ObjectOptions): TRecordOrObject<K, T>;
 export {};

package/build/import/type/record/record.mjs

@@ -13,7 +13,7 @@ import { IsUndefined } from '../guard/value.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsInteger, IsLiteral, IsNumber, IsString, IsTemplateLiteral, IsUnion } from '../guard/type.mjs';
+import { IsInteger, IsLiteral, IsNumber, IsString, IsRegExp, IsTemplateLiteral, IsUnion } from '../guard/type.mjs';
 // ------------------------------------------------------------------
 // RecordCreateFromPattern
 // ------------------------------------------------------------------
@@ -49,6 +49,10 @@ function FromLiteralKey(K, T, options) {
     return RecordCreateFromKeys([K.toString()], T, options);
 }
 // prettier-ignore
+function FromRegExpKey(K, T, options) {
+    return RecordCreateFromPattern(K.source, T, options);
+}
+// prettier-ignore
 function FromStringKey(K, T, options) {
     const pattern = IsUndefined(K.pattern) ? PatternStringExact : K.pattern;
     return RecordCreateFromPattern(pattern, T, options);
@@ -70,8 +74,9 @@ export function Record(K, T, options = {}) {
     return (IsUnion(K) ? FromUnionKey(K.anyOf, T, options) :
         IsTemplateLiteral(K) ? FromTemplateLiteralKey(K, T, options) :
             IsLiteral(K) ? FromLiteralKey(K.const, T, options) :
-                IsString(K) ? FromStringKey(K, T, options) :
-                    IsInteger(K) ? FromIntegerKey(K, T, options) :
-                        IsNumber(K) ? FromNumberKey(K, T, options) :
-                            Never(options));
+                IsInteger(K) ? FromIntegerKey(K, T, options) :
+                    IsNumber(K) ? FromNumberKey(K, T, options) :
+                        IsRegExp(K) ? FromRegExpKey(K, T, options) :
+                            IsString(K) ? FromStringKey(K, T, options) :
+                                Never(options));
 }

package/build/import/type/regexp/regexp.d.mts

@@ -1,7 +1,14 @@
 import type { SchemaOptions } from '../schema/index.mjs';
-import type { TString } from '../string/index.mjs';
-export type TRegExp = TString;
-/** `[JavaScript]` Creates a String type from a Regular Expression pattern */
+import type { TSchema } from '../schema/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+export interface TRegExp extends TSchema {
+    [Kind]: 'RegExp';
+    static: `${string}`;
+    type: 'RegExp';
+    source: string;
+    flags: string;
+}
+/** `[JavaScript]` Creates a RegExp type */
 export declare function RegExp(pattern: string, options?: SchemaOptions): TRegExp;
-/** `[JavaScript]` Creates a String type from a Regular Expression */
+/** `[JavaScript]` Creates a RegExp type */
 export declare function RegExp(regex: RegExp, options?: SchemaOptions): TRegExp;

package/build/import/type/regexp/regexp.mjs

@@ -1,7 +1,7 @@
 import { IsString } from '../guard/value.mjs';
 import { Kind } from '../symbols/index.mjs';
-/** `[JavaScript]` Creates a String type */
+/** `[JavaScript]` Creates a RegExp type */
 export function RegExp(unresolved, options = {}) {
-    const pattern = IsString(unresolved) ? unresolved : unresolved.source;
-    return { ...options, [Kind]: 'String', type: 'string', pattern };
+    const expr = IsString(unresolved) ? new globalThis.RegExp(unresolved) : unresolved;
+    return { ...options, [Kind]: 'RegExp', type: 'RegExp', source: expr.source, flags: expr.flags };
 }

package/build/import/type/schema/anyschema.d.mts

@@ -19,6 +19,7 @@ import type { TPromise } from '../promise/index.mjs';
 import type { TRecord } from '../record/index.mjs';
 import type { TThis } from '../recursive/index.mjs';
 import type { TRef } from '../ref/index.mjs';
+import type { TRegExp } from '../regexp/index.mjs';
 import type { TString } from '../string/index.mjs';
 import type { TSymbol } from '../symbol/index.mjs';
 import type { TTemplateLiteral } from '../template-literal/index.mjs';
@@ -29,4 +30,4 @@ import type { TUnion } from '../union/index.mjs';
 import type { TUnknown } from '../unknown/index.mjs';
 import type { TVoid } from '../void/index.mjs';
 import type { TSchema } from './schema.mjs';
-export type TAnySchema = TSchema | TAny | TArray | TAsyncIterator | TBigInt | TBoolean | TConstructor | TDate | TEnum | TFunction | TInteger | TIntersect | TIterator | TLiteral | TNot | TNull | TNumber | TObject | TPromise | TRecord | TRef | TString | TSymbol | TTemplateLiteral | TThis | TTuple | TUndefined | TUnion | TUint8Array | TUnknown | TVoid;
+export type TAnySchema = TSchema | TAny | TArray | TAsyncIterator | TBigInt | TBoolean | TConstructor | TDate | TEnum | TFunction | TInteger | TIntersect | TIterator | TLiteral | TNot | TNull | TNumber | TObject | TPromise | TRecord | TRef | TRegExp | TString | TSymbol | TTemplateLiteral | TThis | TTuple | TUndefined | TUnion | TUint8Array | TUnknown | TVoid;

package/build/import/type/type/javascript.d.mts

@@ -41,9 +41,9 @@ export declare class JavaScriptTypeBuilder extends JsonTypeBuilder {
     Parameters<T extends TFunction<TSchema[], TSchema>>(schema: T, options?: SchemaOptions): TParameters<T>;
     /** `[JavaScript]` Creates a Promise type */
     Promise<T extends TSchema>(item: T, options?: SchemaOptions): TPromise<T>;
-    /** `[JavaScript]` Creates a String type from a Regular Expression pattern */
+    /** `[JavaScript]` Creates a RegExp type */
     RegExp(pattern: string, options?: SchemaOptions): TRegExp;
-    /** `[JavaScript]` Creates a String type from a Regular Expression */
+    /** `[JavaScript]` Creates a RegExp type */
     RegExp(regex: RegExp, options?: SchemaOptions): TRegExp;
     /** `[JavaScript]` Extracts the ReturnType from the given Function type */
     ReturnType<T extends TFunction<any[], any>>(schema: T, options?: SchemaOptions): TReturnType<T>;

package/build/import/type/type/javascript.mjs

@@ -62,7 +62,7 @@ export class JavaScriptTypeBuilder extends JsonTypeBuilder {
     Promise(item, options = {}) {
         return Promise(item, options);
     }
-    /** `[JavaScript]` Creates a String type */
+    /** `[JavaScript]` Creates a RegExp type */
     RegExp(unresolved, options = {}) {
         return RegExp(unresolved, options);
     }

package/build/import/value/cast/cast.d.mts

@@ -1,22 +1,9 @@
 import { TypeBoxError } from '../../type/error/index.mjs';
 import type { TSchema } from '../../type/schema/index.mjs';
 import type { Static } from '../../type/static/index.mjs';
-export declare class ValueCastArrayUniqueItemsTypeError extends TypeBoxError {
+export declare class ValueCastError extends TypeBoxError {
     readonly schema: TSchema;
-    readonly value: unknown;
-    constructor(schema: TSchema, value: unknown);
-}
-export declare class ValueCastNeverTypeError extends TypeBoxError {
-    readonly schema: TSchema;
-    constructor(schema: TSchema);
-}
-export declare class ValueCastRecursiveTypeError extends TypeBoxError {
-    readonly schema: TSchema;
-    constructor(schema: TSchema);
-}
-export declare class ValueCastUnknownTypeError extends TypeBoxError {
-    readonly schema: TSchema;
-    constructor(schema: TSchema);
+    constructor(schema: TSchema, message: string);
 }
 /** Casts a value into a given type and references. The return value will retain as much information of the original value as possible. */
 export declare function Cast<T extends TSchema>(schema: T, references: TSchema[], value: unknown): Static<T>;

package/build/import/value/cast/cast.mjs

@@ -8,33 +8,10 @@ import { Deref } from '../deref/index.mjs';
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
-export class ValueCastArrayUniqueItemsTypeError extends TypeBoxError {
+export class ValueCastError extends TypeBoxError {
     schema;
-    value;
-    constructor(schema, value) {
-        super('Array cast produced invalid data due to uniqueItems constraint');
-        this.schema = schema;
-        this.value = value;
-    }
-}
-export class ValueCastNeverTypeError extends TypeBoxError {
-    schema;
-    constructor(schema) {
-        super('Never types cannot be cast');
-        this.schema = schema;
-    }
-}
-export class ValueCastRecursiveTypeError extends TypeBoxError {
-    schema;
-    constructor(schema) {
-        super('Cannot cast recursive schemas');
-        this.schema = schema;
-    }
-}
-export class ValueCastUnknownTypeError extends TypeBoxError {
-    schema;
-    constructor(schema) {
-        super('Unknown type');
+    constructor(schema, message) {
+        super(message);
         this.schema = schema;
     }
 }
@@ -106,7 +83,7 @@ function FromArray(schema, references, value) {
         return casted;
     const unique = [...new Set(casted)];
     if (!Check(schema, references, unique))
-        throw new ValueCastArrayUniqueItemsTypeError(schema, unique);
+        throw new ValueCastError(schema, 'Array cast produced invalid data due to uniqueItems constraint');
     return unique;
 }
 function FromConstructor(schema, references, value) {
@@ -127,7 +104,7 @@ function FromIntersect(schema, references, value) {
     return Check(schema, references, mapped) ? mapped : Create(schema, references);
 }
 function FromNever(schema, references, value) {
-    throw new ValueCastNeverTypeError(schema);
+    throw new ValueCastError(schema, 'Never types cannot be cast');
 }
 function FromObject(schema, references, value) {
     if (Check(schema, references, value))

package/build/import/value/check/check.mjs

@@ -10,7 +10,6 @@ import { Never } from '../../type/never/index.mjs';
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 import { IsArray, IsUint8Array, IsDate, IsPromise, IsFunction, IsAsyncIterator, IsIterator, IsBoolean, IsNumber, IsBigInt, IsString, IsSymbol, IsInteger, IsNull, IsUndefined } from '../guard/index.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
@@ -286,6 +285,10 @@ function FromRecord(schema, references, value) {
 function FromRef(schema, references, value) {
     return Visit(Deref(schema, references), references, value);
 }
+function FromRegExp(schema, references, value) {
+    const regex = new RegExp(schema.source, schema.flags);
+    return regex.test(value);
+}
 function FromString(schema, references, value) {
     if (!IsString(value)) {
         return false;
@@ -413,6 +416,8 @@ function Visit(schema, references, value) {
             return FromRecord(schema_, references_, value);
         case 'Ref':
             return FromRef(schema_, references_, value);
+        case 'RegExp':
+            return FromRegExp(schema_, references_, value);
         case 'String':
             return FromString(schema_, references_, value);
         case 'Symbol':

package/build/import/value/convert/convert.d.mts

@@ -1,9 +1,4 @@
-import { TypeBoxError } from '../../type/error/index.mjs';
 import type { TSchema } from '../../type/schema/index.mjs';
-export declare class ValueConvertUnknownTypeError extends TypeBoxError {
-    readonly schema: TSchema;
-    constructor(schema: TSchema);
-}
 /** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
 export declare function Convert<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown;
 /** Converts any type mismatched values to their target type if a reasonable conversion is possible. */

package/build/import/value/convert/convert.mjs

@@ -1,26 +1,14 @@
 import { Clone } from '../clone/index.mjs';
 import { Check } from '../check/index.mjs';
 import { Deref } from '../deref/index.mjs';
-import { TypeBoxError } from '../../type/error/index.mjs';
 import { IsObject as IsObjectType } from '../../type/guard/type.mjs';
 import { Kind } from '../../type/symbols/index.mjs';
 import { Composite } from '../../type/composite/index.mjs';
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 import { IsArray, IsObject, IsDate, IsUndefined, IsString, IsNumber, IsBoolean, IsBigInt, IsSymbol } from '../guard/index.mjs';
 // ------------------------------------------------------------------
-// Errors
-// ------------------------------------------------------------------
-export class ValueConvertUnknownTypeError extends TypeBoxError {
-    schema;
-    constructor(schema) {
-        super('Unknown type');
-        this.schema = schema;
-    }
-}
-// ------------------------------------------------------------------
 // Conversions
 // ------------------------------------------------------------------
 function IsStringNumeric(value) {

package/build/import/value/create/create.d.mts

@@ -1,30 +1,9 @@
 import { TypeBoxError } from '../../type/error/index.mjs';
 import type { TSchema } from '../../type/schema/index.mjs';
 import type { Static } from '../../type/static/index.mjs';
-export declare class ValueCreateUnknownTypeError extends TypeBoxError {
+export declare class ValueCreateError extends TypeBoxError {
     readonly schema: TSchema;
-    constructor(schema: TSchema);
-}
-export declare class ValueCreateNeverTypeError extends TypeBoxError {
-    readonly schema: TSchema;
-    constructor(schema: TSchema);
-}
-export declare class ValueCreateNotTypeError extends TypeBoxError {
-    readonly schema: TSchema;
-    constructor(schema: TSchema);
-}
-export declare class ValueCreateIntersectTypeError extends TypeBoxError {
-    readonly schema: TSchema;
-    constructor(schema: TSchema);
-}
-export declare class ValueCreateTempateLiteralTypeError extends TypeBoxError {
-    readonly schema: TSchema;
-    constructor(schema: TSchema);
-}
-export declare class ValueCreateRecursiveInstantiationError extends TypeBoxError {
-    readonly schema: TSchema;
-    readonly recursiveMaxDepth: number;
-    constructor(schema: TSchema, recursiveMaxDepth: number);
+    constructor(schema: TSchema, message: string);
 }
 /** Creates a value from the given schema and references */
 export declare function Create<T extends TSchema>(schema: T, references: TSchema[]): Static<T>;

package/build/import/value/create/create.mjs

@@ -9,50 +9,13 @@ import { TypeBoxError } from '../../type/error/index.mjs';
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
-export class ValueCreateUnknownTypeError extends TypeBoxError {
+export class ValueCreateError extends TypeBoxError {
     schema;
-    constructor(schema) {
-        super('Unknown type');
+    constructor(schema, message) {
+        super(message);
         this.schema = schema;
     }
 }
-export class ValueCreateNeverTypeError extends TypeBoxError {
-    schema;
-    constructor(schema) {
-        super('Never types cannot be created');
-        this.schema = schema;
-    }
-}
-export class ValueCreateNotTypeError extends TypeBoxError {
-    schema;
-    constructor(schema) {
-        super('Not types must have a default value');
-        this.schema = schema;
-    }
-}
-export class ValueCreateIntersectTypeError extends TypeBoxError {
-    schema;
-    constructor(schema) {
-        super('Intersect produced invalid value. Consider using a default value.');
-        this.schema = schema;
-    }
-}
-export class ValueCreateTempateLiteralTypeError extends TypeBoxError {
-    schema;
-    constructor(schema) {
-        super('Can only create template literal values from patterns that produce finite sequences. Consider using a default value.');
-        this.schema = schema;
-    }
-}
-export class ValueCreateRecursiveInstantiationError extends TypeBoxError {
-    schema;
-    recursiveMaxDepth;
-    constructor(schema, recursiveMaxDepth) {
-        super('Value cannot be created as recursive type may produce value of infinite size. Consider using a default.');
-        this.schema = schema;
-        this.recursiveMaxDepth = recursiveMaxDepth;
-    }
-}
 // ------------------------------------------------------------------
 // Create
 // ------------------------------------------------------------------
@@ -66,10 +29,10 @@ function FromAny(schema, references) {
 }
 function FromArray(schema, references) {
     if (schema.uniqueItems === true && !HasPropertyKey(schema, 'default')) {
-        throw new Error('ValueCreate.Array: Array with the uniqueItems constraint requires a default value');
+        throw new ValueCreateError(schema, 'Array with the uniqueItems constraint requires a default value');
     }
     else if ('contains' in schema && !HasPropertyKey(schema, 'default')) {
-        throw new Error('ValueCreate.Array: Array with the contains constraint requires a default value');
+        throw new ValueCreateError(schema, 'Array with the contains constraint requires a default value');
     }
     else if ('default' in schema) {
         return schema.default;
@@ -176,7 +139,7 @@ function FromIntersect(schema, references) {
             return typeof next === 'object' ? { ...acc, ...next } : next;
         }, {});
         if (!Check(schema, references, value))
-            throw new ValueCreateIntersectTypeError(schema);
+            throw new ValueCreateError(schema, 'Intersect produced invalid value. Consider using a default value.');
         return value;
     }
 }
@@ -197,14 +160,19 @@ function FromLiteral(schema, references) {
     }
 }
 function FromNever(schema, references) {
-    throw new ValueCreateNeverTypeError(schema);
+    if (HasPropertyKey(schema, 'default')) {
+        return schema.default;
+    }
+    else {
+        throw new ValueCreateError(schema, 'Never types cannot be created. Consider using a default value.');
+    }
 }
 function FromNot(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
         return schema.default;
     }
     else {
-        throw new ValueCreateNotTypeError(schema);
+        throw new ValueCreateError(schema, 'Not types must have a default value');
     }
 }
 function FromNull(schema, references) {
@@ -269,10 +237,18 @@ function FromRef(schema, references) {
         return Visit(Deref(schema, references), references);
     }
 }
+function FromRegExp(schema, references) {
+    if (HasPropertyKey(schema, 'default')) {
+        return schema.default;
+    }
+    else {
+        throw new ValueCreateError(schema, 'RegExp types cannot be created. Consider using a default value.');
+    }
+}
 function FromString(schema, references) {
     if (schema.pattern !== undefined) {
         if (!HasPropertyKey(schema, 'default')) {
-            throw new Error('ValueCreate.String: String types with patterns must specify a default value');
+            throw new ValueCreateError(schema, 'String types with patterns must specify a default value');
         }
         else {
             return schema.default;
@@ -280,7 +256,7 @@ function FromString(schema, references) {
     }
     else if (schema.format !== undefined) {
         if (!HasPropertyKey(schema, 'default')) {
-            throw new Error('ValueCreate.String: String types with formats must specify a default value');
+            throw new ValueCreateError(schema, 'String types with formats must specify a default value');
         }
         else {
             return schema.default;
@@ -291,9 +267,8 @@ function FromString(schema, references) {
             return schema.default;
         }
         else if (schema.minLength !== undefined) {
-            return Array.from({ length: schema.minLength })
-                .map(() => '.')
-                .join('');
+            // prettier-ignore
+            return Array.from({ length: schema.minLength }).map(() => ' ').join('');
         }
         else {
             return '';
@@ -316,13 +291,13 @@ function FromTemplateLiteral(schema, references) {
         return schema.default;
     }
     if (!IsTemplateLiteralFinite(schema))
-        throw new ValueCreateTempateLiteralTypeError(schema);
+        throw new ValueCreateError(schema, 'Can only create template literals that produce a finite variants. Consider using a default value.');
     const generated = TemplateLiteralGenerate(schema);
     return generated[0];
 }
 function FromThis(schema, references) {
     if (recursiveDepth++ > recursiveMaxDepth)
-        throw new ValueCreateRecursiveInstantiationError(schema, recursiveMaxDepth);
+        throw new ValueCreateError(schema, 'Cannot create recursive type as it appears possibly infinite. Consider using a default.');
     if (HasPropertyKey(schema, 'default')) {
         return schema.default;
     }
@@ -439,6 +414,8 @@ function Visit(schema, references) {
             return FromRecord(schema_, references_);
         case 'Ref':
             return FromRef(schema_, references_);
+        case 'RegExp':
+            return FromRegExp(schema_, references_);
         case 'String':
             return FromString(schema_, references_);
         case 'Symbol':
@@ -461,7 +438,7 @@ function Visit(schema, references) {
             return FromVoid(schema_, references_);
         default:
             if (!TypeRegistry.Has(schema_[Kind]))
-                throw new ValueCreateUnknownTypeError(schema_);
+                throw new ValueCreateError(schema_, 'Unknown type');
             return FromKind(schema_, references_);
     }
 }

package/build/import/value/default/default.mjs

@@ -4,12 +4,10 @@ import { Kind } from '../../type/symbols/index.mjs';
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 import { IsString, IsObject, IsArray, IsUndefined } from '../guard/index.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 import { IsSchema } from '../../type/guard/type.mjs';
 // ------------------------------------------------------------------
 // ValueOrDefault

package/build/import/value/delta/delta.d.mts

@@ -30,11 +30,11 @@ export declare const Edit: import("../../type/union/union-type.mjs").TUnion<[imp
     type: import("../../type/literal/literal.mjs").TLiteral<"delete">;
     path: import("../../type/string/string.mjs").TString;
 }>]>;
-export declare class ValueDeltaObjectWithSymbolKeyError extends TypeBoxError {
-    readonly key: unknown;
-    constructor(key: unknown);
+export declare class ValueDeltaError extends TypeBoxError {
+    readonly value: unknown;
+    constructor(value: unknown, message: string);
 }
-export declare class ValueDeltaUnableToDiffUnknownValue extends TypeBoxError {
+export declare class ValueDeltaSymbolError extends ValueDeltaError {
     readonly value: unknown;
     constructor(value: unknown);
 }

package/build/import/value/delta/delta.mjs

@@ -25,17 +25,17 @@ export const Edit = CreateUnion([Insert, Update, Delete]);
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
-export class ValueDeltaObjectWithSymbolKeyError extends TypeBoxError {
-    key;
-    constructor(key) {
-        super('Cannot diff objects with symbol keys');
-        this.key = key;
+export class ValueDeltaError extends TypeBoxError {
+    value;
+    constructor(value, message) {
+        super(message);
+        this.value = value;
     }
 }
-export class ValueDeltaUnableToDiffUnknownValue extends TypeBoxError {
+export class ValueDeltaSymbolError extends ValueDeltaError {
     value;
     constructor(value) {
-        super('Unable to create diff edits for unknown value');
+        super(value, 'Cannot diff objects with symbol keys');
         this.value = value;
     }
 }
@@ -61,7 +61,7 @@ function* ObjectType(path, current, next) {
     const nextKeys = [...globalThis.Object.keys(next), ...globalThis.Object.getOwnPropertySymbols(next)];
     for (const key of currentKeys) {
         if (IsSymbol(key))
-            throw new ValueDeltaObjectWithSymbolKeyError(key);
+            throw new ValueDeltaSymbolError(key);
         if (IsUndefined(next[key]) && nextKeys.includes(key))
             yield CreateUpdate(`${path}/${globalThis.String(key)}`, undefined);
     }
@@ -69,18 +69,18 @@ function* ObjectType(path, current, next) {
         if (IsUndefined(current[key]) || IsUndefined(next[key]))
             continue;
         if (IsSymbol(key))
-            throw new ValueDeltaObjectWithSymbolKeyError(key);
+            throw new ValueDeltaSymbolError(key);
         yield* Visit(`${path}/${globalThis.String(key)}`, current[key], next[key]);
     }
     for (const key of nextKeys) {
         if (IsSymbol(key))
-            throw new ValueDeltaObjectWithSymbolKeyError(key);
+            throw new ValueDeltaSymbolError(key);
         if (IsUndefined(current[key]))
             yield CreateInsert(`${path}/${globalThis.String(key)}`, next[key]);
     }
     for (const key of currentKeys.reverse()) {
         if (IsSymbol(key))
-            throw new ValueDeltaObjectWithSymbolKeyError(key);
+            throw new ValueDeltaSymbolError(key);
         if (IsUndefined(next[key]) && !nextKeys.includes(key))
             yield CreateDelete(`${path}/${globalThis.String(key)}`);
     }
@@ -123,7 +123,7 @@ function* Visit(path, current, next) {
         return yield* TypedArrayType(path, current, next);
     if (IsValueType(current))
         return yield* ValueType(path, current, next);
-    throw new ValueDeltaUnableToDiffUnknownValue(current);
+    throw new ValueDeltaError(current, 'Unable to create diff edits for unknown value');
 }
 // ------------------------------------------------------------------
 // Diff

package/build/import/value/index.d.mts

@@ -1,16 +1,16 @@
 export { ValueError, ValueErrorType, ValueErrorIterator } from '../errors/index.mjs';
-export { Cast, ValueCastArrayUniqueItemsTypeError, ValueCastNeverTypeError, ValueCastRecursiveTypeError, ValueCastUnknownTypeError } from './cast/index.mjs';
+export { Cast, ValueCastError } from './cast/index.mjs';
 export { Check } from './check/index.mjs';
 export { Clean } from './clean/index.mjs';
 export { Clone } from './clone/index.mjs';
-export { Convert, ValueConvertUnknownTypeError } from './convert/index.mjs';
-export { Create, ValueCreateIntersectTypeError, ValueCreateNeverTypeError, ValueCreateNotTypeError, ValueCreateRecursiveInstantiationError, ValueCreateTempateLiteralTypeError, ValueCreateUnknownTypeError } from './create/index.mjs';
+export { Convert } from './convert/index.mjs';
+export { Create, ValueCreateError } from './create/index.mjs';
 export { Default } from './default/index.mjs';
-export { Diff, Patch, Edit, Delete, Insert, Update, ValueDeltaObjectWithSymbolKeyError, ValueDeltaUnableToDiffUnknownValue } from './delta/index.mjs';
+export { Diff, Patch, Edit, Delete, Insert, Update, ValueDeltaError } from './delta/index.mjs';
 export { Equal } from './equal/index.mjs';
 export { Hash, ValueHashError } from './hash/index.mjs';
-export { Mutate, type Mutable, ValueMutateInvalidRootMutationError, ValueMutateTypeMismatchError } from './mutate/index.mjs';
+export { Mutate, ValueMutateError, type Mutable } from './mutate/index.mjs';
 export { ValuePointer } from './pointer/index.mjs';
-export { TransformDecode as DecodeTransform, TransformEncode as EncodeTransform, HasTransform, TransformDecodeCheckError, TransformDecodeError, TransformEncodeCheckError, TransformEncodeError } from './transform/index.mjs';
-export { ArrayType, HasPropertyKey, IsArray, IsAsyncIterator, IsBigInt, IsBoolean, IsDate, IsFunction, IsInteger, IsIterator, IsNull, IsNumber, IsObject, IsPlainObject, IsPromise, IsString, IsSymbol, IsTypedArray, IsUint8Array, IsUndefined, IsValueType, ObjectType, TypedArrayType, ValueType, } from './guard/index.mjs';
+export { TransformDecode, TransformEncode, HasTransform, TransformDecodeCheckError, TransformDecodeError, TransformEncodeCheckError, TransformEncodeError } from './transform/index.mjs';
+export { ArrayType, HasPropertyKey, IsArray, IsAsyncIterator, IsBigInt, IsBoolean, IsDate, IsFunction, IsInteger, IsIterator, IsNull, IsNumber, IsObject, IsPlainObject, IsPromise, IsString, IsSymbol, IsTypedArray, IsUint8Array, IsUndefined, IsValueType, type ObjectType, type TypedArrayType, type ValueType, } from './guard/index.mjs';
 export { Value } from './value/index.mjs';

package/build/import/value/index.mjs

@@ -5,19 +5,19 @@ export { ValueErrorType, ValueErrorIterator } from '../errors/index.mjs';
 // ------------------------------------------------------------------
 // Value Operators
 // ------------------------------------------------------------------
-export { Cast, ValueCastArrayUniqueItemsTypeError, ValueCastNeverTypeError, ValueCastRecursiveTypeError, ValueCastUnknownTypeError } from './cast/index.mjs';
+export { Cast, ValueCastError } from './cast/index.mjs';
 export { Check } from './check/index.mjs';
 export { Clean } from './clean/index.mjs';
 export { Clone } from './clone/index.mjs';
-export { Convert, ValueConvertUnknownTypeError } from './convert/index.mjs';
-export { Create, ValueCreateIntersectTypeError, ValueCreateNeverTypeError, ValueCreateNotTypeError, ValueCreateRecursiveInstantiationError, ValueCreateTempateLiteralTypeError, ValueCreateUnknownTypeError } from './create/index.mjs';
+export { Convert } from './convert/index.mjs';
+export { Create, ValueCreateError } from './create/index.mjs';
 export { Default } from './default/index.mjs';
-export { Diff, Patch, Edit, Delete, Insert, Update, ValueDeltaObjectWithSymbolKeyError, ValueDeltaUnableToDiffUnknownValue } from './delta/index.mjs';
+export { Diff, Patch, Edit, Delete, Insert, Update, ValueDeltaError } from './delta/index.mjs';
 export { Equal } from './equal/index.mjs';
 export { Hash, ValueHashError } from './hash/index.mjs';
-export { Mutate, ValueMutateInvalidRootMutationError, ValueMutateTypeMismatchError } from './mutate/index.mjs';
+export { Mutate, ValueMutateError } from './mutate/index.mjs';
 export { ValuePointer } from './pointer/index.mjs';
-export { TransformDecode as DecodeTransform, TransformEncode as EncodeTransform, HasTransform, TransformDecodeCheckError, TransformDecodeError, TransformEncodeCheckError, TransformEncodeError } from './transform/index.mjs';
+export { TransformDecode, TransformEncode, HasTransform, TransformDecodeCheckError, TransformDecodeError, TransformEncodeCheckError, TransformEncodeError } from './transform/index.mjs';
 // ------------------------------------------------------------------
 // Value Guards
 // ------------------------------------------------------------------