@sinclair/typebox 0.32.0-dev-27 → 0.32.0

package/build/require/type/indexed/indexed-property-keys.d.ts

@@ -5,7 +5,7 @@ import type { TNumber } from '../number/index';
 import type { TSchema } from '../schema/index';
 import type { TUnion } from '../union/index';
 type TFromTemplateLiteral<T extends TTemplateLiteral, R extends string[] = TTemplateLiteralGenerate<T>> = (R);
-type TFromUnion<T extends TSchema[], Acc extends string[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromUnion<R, [...TIndexPropertyKeys<L>, ...Acc]> : Acc);
+type TFromUnion<T extends TSchema[], Acc extends string[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromUnion<R, [...Acc, ...TIndexPropertyKeys<L>]> : Acc);
 type TFromLiteral<T extends TLiteralValue> = (T extends PropertyKey ? [`${T}`] : []);
 export type TIndexPropertyKeys<T extends TSchema> = (T extends TTemplateLiteral ? TFromTemplateLiteral<T> : T extends TUnion<infer S> ? TFromUnion<S> : T extends TLiteral<infer S> ? TFromLiteral<S> : T extends TNumber ? ['[number]'] : T extends TInteger ? ['[number]'] : [
 ]);

package/build/require/type/record/record.d.ts

@@ -5,6 +5,7 @@ import { type TObject, type TProperties, type TAdditionalProperties, type Object
 import { type TLiteral, type TLiteralValue } from '../literal/index';
 import { type TNever } from '../never/index';
 import { type TUnion } from '../union/index';
+import { type TRegExp } from '../regexp/index';
 import { type TString } from '../string/index';
 import { type TInteger } from '../integer/index';
 import { type TNumber } from '../number/index';
@@ -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/require/type/record/record.js

@@ -53,6 +53,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 = (0, value_1.IsUndefined)(K.pattern) ? index_5.PatternStringExact : K.pattern;
     return RecordCreateFromPattern(pattern, T, options);
@@ -74,9 +78,10 @@ function Record(K, T, options = {}) {
     return ((0, type_2.IsUnion)(K) ? FromUnionKey(K.anyOf, T, options) :
         (0, type_2.IsTemplateLiteral)(K) ? FromTemplateLiteralKey(K, T, options) :
             (0, type_2.IsLiteral)(K) ? FromLiteralKey(K.const, T, options) :
-                (0, type_2.IsString)(K) ? FromStringKey(K, T, options) :
-                    (0, type_2.IsInteger)(K) ? FromIntegerKey(K, T, options) :
-                        (0, type_2.IsNumber)(K) ? FromNumberKey(K, T, options) :
-                            (0, index_2.Never)(options));
+                (0, type_2.IsInteger)(K) ? FromIntegerKey(K, T, options) :
+                    (0, type_2.IsNumber)(K) ? FromNumberKey(K, T, options) :
+                        (0, type_2.IsRegExp)(K) ? FromRegExpKey(K, T, options) :
+                            (0, type_2.IsString)(K) ? FromStringKey(K, T, options) :
+                                (0, index_2.Never)(options));
 }
 exports.Record = Record;

package/build/require/type/regexp/regexp.d.ts

@@ -1,7 +1,14 @@
 import type { SchemaOptions } from '../schema/index';
-import type { TString } from '../string/index';
-export type TRegExp = TString;
-/** `[JavaScript]` Creates a String type from a Regular Expression pattern */
+import type { TSchema } from '../schema/index';
+import { Kind } from '../symbols/index';
+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/require/type/regexp/regexp.js

@@ -4,9 +4,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RegExp = void 0;
 const value_1 = require("../guard/value");
 const index_1 = require("../symbols/index");
-/** `[JavaScript]` Creates a String type */
+/** `[JavaScript]` Creates a RegExp type */
 function RegExp(unresolved, options = {}) {
-    const pattern = (0, value_1.IsString)(unresolved) ? unresolved : unresolved.source;
-    return { ...options, [index_1.Kind]: 'String', type: 'string', pattern };
+    const expr = (0, value_1.IsString)(unresolved) ? new globalThis.RegExp(unresolved) : unresolved;
+    return { ...options, [index_1.Kind]: 'RegExp', type: 'RegExp', source: expr.source, flags: expr.flags };
 }
 exports.RegExp = RegExp;

package/build/require/type/schema/anyschema.d.ts

@@ -19,6 +19,7 @@ import type { TPromise } from '../promise/index';
 import type { TRecord } from '../record/index';
 import type { TThis } from '../recursive/index';
 import type { TRef } from '../ref/index';
+import type { TRegExp } from '../regexp/index';
 import type { TString } from '../string/index';
 import type { TSymbol } from '../symbol/index';
 import type { TTemplateLiteral } from '../template-literal/index';
@@ -29,4 +30,4 @@ import type { TUnion } from '../union/index';
 import type { TUnknown } from '../unknown/index';
 import type { TVoid } from '../void/index';
 import type { TSchema } from './schema';
-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/require/type/type/javascript.d.ts

@@ -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/require/type/type/javascript.js

@@ -66,7 +66,7 @@ class JavaScriptTypeBuilder extends json_1.JsonTypeBuilder {
     Promise(item, options = {}) {
         return (0, index_11.Promise)(item, options);
     }
-    /** `[JavaScript]` Creates a String type */
+    /** `[JavaScript]` Creates a RegExp type */
     RegExp(unresolved, options = {}) {
         return (0, index_12.RegExp)(unresolved, options);
     }

package/build/require/value/cast/cast.d.ts

@@ -1,22 +1,9 @@
 import { TypeBoxError } from '../../type/error/index';
 import type { TSchema } from '../../type/schema/index';
 import type { Static } from '../../type/static/index';
-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/require/value/cast/cast.js

@@ -1,7 +1,7 @@
 "use strict";
 
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Cast = exports.ValueCastUnknownTypeError = exports.ValueCastRecursiveTypeError = exports.ValueCastNeverTypeError = exports.ValueCastArrayUniqueItemsTypeError = void 0;
+exports.Cast = exports.ValueCastError = void 0;
 const index_1 = require("../guard/index");
 const index_2 = require("../../type/error/index");
 const index_3 = require("../../type/symbols/index");
@@ -12,35 +12,13 @@ const index_7 = require("../deref/index");
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
-class ValueCastArrayUniqueItemsTypeError extends index_2.TypeBoxError {
-    constructor(schema, value) {
-        super('Array cast produced invalid data due to uniqueItems constraint');
+class ValueCastError extends index_2.TypeBoxError {
+    constructor(schema, message) {
+        super(message);
         this.schema = schema;
-        this.value = value;
     }
 }
-exports.ValueCastArrayUniqueItemsTypeError = ValueCastArrayUniqueItemsTypeError;
-class ValueCastNeverTypeError extends index_2.TypeBoxError {
-    constructor(schema) {
-        super('Never types cannot be cast');
-        this.schema = schema;
-    }
-}
-exports.ValueCastNeverTypeError = ValueCastNeverTypeError;
-class ValueCastRecursiveTypeError extends index_2.TypeBoxError {
-    constructor(schema) {
-        super('Cannot cast recursive schemas');
-        this.schema = schema;
-    }
-}
-exports.ValueCastRecursiveTypeError = ValueCastRecursiveTypeError;
-class ValueCastUnknownTypeError extends index_2.TypeBoxError {
-    constructor(schema) {
-        super('Unknown type');
-        this.schema = schema;
-    }
-}
-exports.ValueCastUnknownTypeError = ValueCastUnknownTypeError;
+exports.ValueCastError = ValueCastError;
 // ------------------------------------------------------------------
 // The following will score a schema against a value. For objects,
 // the score is the tally of points awarded for each property of
@@ -109,7 +87,7 @@ function FromArray(schema, references, value) {
         return casted;
     const unique = [...new Set(casted)];
     if (!(0, index_5.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) {
@@ -130,7 +108,7 @@ function FromIntersect(schema, references, value) {
     return (0, index_5.Check)(schema, references, mapped) ? mapped : (0, index_4.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 ((0, index_5.Check)(schema, references, value))

package/build/require/value/check/check.js

@@ -14,7 +14,6 @@ const index_9 = require("../../type/never/index");
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 const index_10 = require("../guard/index");
 // ------------------------------------------------------------------
 // TypeGuard
@@ -290,6 +289,10 @@ function FromRecord(schema, references, value) {
 function FromRef(schema, references, value) {
     return Visit((0, index_2.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 (!(0, index_10.IsString)(value)) {
         return false;
@@ -417,6 +420,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/require/value/convert/convert.d.ts

@@ -1,9 +1,4 @@
-import { TypeBoxError } from '../../type/error/index';
 import type { TSchema } from '../../type/schema/index';
-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/require/value/convert/convert.js

@@ -1,58 +1,46 @@
 "use strict";
 
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Convert = exports.ValueConvertUnknownTypeError = void 0;
+exports.Convert = void 0;
 const index_1 = require("../clone/index");
 const index_2 = require("../check/index");
 const index_3 = require("../deref/index");
-const index_4 = require("../../type/error/index");
 const type_1 = require("../../type/guard/type");
-const index_5 = require("../../type/symbols/index");
-const index_6 = require("../../type/composite/index");
+const index_4 = require("../../type/symbols/index");
+const index_5 = require("../../type/composite/index");
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
-// prettier-ignore
-const index_7 = require("../guard/index");
-// ------------------------------------------------------------------
-// Errors
-// ------------------------------------------------------------------
-class ValueConvertUnknownTypeError extends index_4.TypeBoxError {
-    constructor(schema) {
-        super('Unknown type');
-        this.schema = schema;
-    }
-}
-exports.ValueConvertUnknownTypeError = ValueConvertUnknownTypeError;
+const index_6 = require("../guard/index");
 // ------------------------------------------------------------------
 // Conversions
 // ------------------------------------------------------------------
 function IsStringNumeric(value) {
-    return (0, index_7.IsString)(value) && !isNaN(value) && !isNaN(parseFloat(value));
+    return (0, index_6.IsString)(value) && !isNaN(value) && !isNaN(parseFloat(value));
 }
 function IsValueToString(value) {
-    return (0, index_7.IsBigInt)(value) || (0, index_7.IsBoolean)(value) || (0, index_7.IsNumber)(value);
+    return (0, index_6.IsBigInt)(value) || (0, index_6.IsBoolean)(value) || (0, index_6.IsNumber)(value);
 }
 function IsValueTrue(value) {
-    return value === true || ((0, index_7.IsNumber)(value) && value === 1) || ((0, index_7.IsBigInt)(value) && value === BigInt('1')) || ((0, index_7.IsString)(value) && (value.toLowerCase() === 'true' || value === '1'));
+    return value === true || ((0, index_6.IsNumber)(value) && value === 1) || ((0, index_6.IsBigInt)(value) && value === BigInt('1')) || ((0, index_6.IsString)(value) && (value.toLowerCase() === 'true' || value === '1'));
 }
 function IsValueFalse(value) {
-    return value === false || ((0, index_7.IsNumber)(value) && (value === 0 || Object.is(value, -0))) || ((0, index_7.IsBigInt)(value) && value === BigInt('0')) || ((0, index_7.IsString)(value) && (value.toLowerCase() === 'false' || value === '0' || value === '-0'));
+    return value === false || ((0, index_6.IsNumber)(value) && (value === 0 || Object.is(value, -0))) || ((0, index_6.IsBigInt)(value) && value === BigInt('0')) || ((0, index_6.IsString)(value) && (value.toLowerCase() === 'false' || value === '0' || value === '-0'));
 }
 function IsTimeStringWithTimeZone(value) {
-    return (0, index_7.IsString)(value) && /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i.test(value);
+    return (0, index_6.IsString)(value) && /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i.test(value);
 }
 function IsTimeStringWithoutTimeZone(value) {
-    return (0, index_7.IsString)(value) && /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)?$/i.test(value);
+    return (0, index_6.IsString)(value) && /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)?$/i.test(value);
 }
 function IsDateTimeStringWithTimeZone(value) {
-    return (0, index_7.IsString)(value) && /^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i.test(value);
+    return (0, index_6.IsString)(value) && /^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i.test(value);
 }
 function IsDateTimeStringWithoutTimeZone(value) {
-    return (0, index_7.IsString)(value) && /^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)?$/i.test(value);
+    return (0, index_6.IsString)(value) && /^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)?$/i.test(value);
 }
 function IsDateString(value) {
-    return (0, index_7.IsString)(value) && /^\d\d\d\d-[0-1]\d-[0-3]\d$/i.test(value);
+    return (0, index_6.IsString)(value) && /^\d\d\d\d-[0-1]\d-[0-3]\d$/i.test(value);
 }
 // ------------------------------------------------------------------
 // Convert
@@ -71,31 +59,31 @@ function TryConvertLiteralBoolean(value, target) {
 }
 // prettier-ignore
 function TryConvertLiteral(schema, value) {
-    return ((0, index_7.IsString)(schema.const) ? TryConvertLiteralString(value, schema.const) :
-        (0, index_7.IsNumber)(schema.const) ? TryConvertLiteralNumber(value, schema.const) :
-            (0, index_7.IsBoolean)(schema.const) ? TryConvertLiteralBoolean(value, schema.const) :
+    return ((0, index_6.IsString)(schema.const) ? TryConvertLiteralString(value, schema.const) :
+        (0, index_6.IsNumber)(schema.const) ? TryConvertLiteralNumber(value, schema.const) :
+            (0, index_6.IsBoolean)(schema.const) ? TryConvertLiteralBoolean(value, schema.const) :
                 (0, index_1.Clone)(value));
 }
 function TryConvertBoolean(value) {
     return IsValueTrue(value) ? true : IsValueFalse(value) ? false : value;
 }
 function TryConvertBigInt(value) {
-    return IsStringNumeric(value) ? BigInt(parseInt(value)) : (0, index_7.IsNumber)(value) ? BigInt(value | 0) : IsValueFalse(value) ? BigInt(0) : IsValueTrue(value) ? BigInt(1) : value;
+    return IsStringNumeric(value) ? BigInt(parseInt(value)) : (0, index_6.IsNumber)(value) ? BigInt(value | 0) : IsValueFalse(value) ? BigInt(0) : IsValueTrue(value) ? BigInt(1) : value;
 }
 function TryConvertString(value) {
-    return IsValueToString(value) ? value.toString() : (0, index_7.IsSymbol)(value) && value.description !== undefined ? value.description.toString() : value;
+    return IsValueToString(value) ? value.toString() : (0, index_6.IsSymbol)(value) && value.description !== undefined ? value.description.toString() : value;
 }
 function TryConvertNumber(value) {
     return IsStringNumeric(value) ? parseFloat(value) : IsValueTrue(value) ? 1 : IsValueFalse(value) ? 0 : value;
 }
 function TryConvertInteger(value) {
-    return IsStringNumeric(value) ? parseInt(value) : (0, index_7.IsNumber)(value) ? value | 0 : IsValueTrue(value) ? 1 : IsValueFalse(value) ? 0 : value;
+    return IsStringNumeric(value) ? parseInt(value) : (0, index_6.IsNumber)(value) ? value | 0 : IsValueTrue(value) ? 1 : IsValueFalse(value) ? 0 : value;
 }
 function TryConvertNull(value) {
-    return (0, index_7.IsString)(value) && value.toLowerCase() === 'null' ? null : value;
+    return (0, index_6.IsString)(value) && value.toLowerCase() === 'null' ? null : value;
 }
 function TryConvertUndefined(value) {
-    return (0, index_7.IsString)(value) && value === 'undefined' ? undefined : value;
+    return (0, index_6.IsString)(value) && value === 'undefined' ? undefined : value;
 }
 // ------------------------------------------------------------------
 // note: this function may return an invalid dates for the regex
@@ -106,8 +94,8 @@ function TryConvertUndefined(value) {
 // ------------------------------------------------------------------
 // prettier-ignore
 function TryConvertDate(value) {
-    return ((0, index_7.IsDate)(value) ? value :
-        (0, index_7.IsNumber)(value) ? new Date(value) :
+    return ((0, index_6.IsDate)(value) ? value :
+        (0, index_6.IsNumber)(value) ? new Date(value) :
             IsValueTrue(value) ? new Date(1) :
                 IsValueFalse(value) ? new Date(0) :
                     IsStringNumeric(value) ? new Date(parseInt(value)) :
@@ -128,7 +116,7 @@ function Default(value) {
 // Convert
 // ------------------------------------------------------------------
 function FromArray(schema, references, value) {
-    if ((0, index_7.IsArray)(value)) {
+    if ((0, index_6.IsArray)(value)) {
         return value.map((value) => Visit(schema.items, references, value));
     }
     return value;
@@ -149,7 +137,7 @@ function FromInteger(schema, references, value) {
 function FromIntersect(schema, references, value) {
     const allObjects = schema.allOf.every(schema => (0, type_1.IsObject)(schema));
     if (allObjects)
-        return Visit((0, index_6.Composite)(schema.allOf), references, value);
+        return Visit((0, index_5.Composite)(schema.allOf), references, value);
     return Visit(schema.allOf[0], references, value); // todo: fix this
 }
 function FromLiteral(schema, references, value) {
@@ -163,11 +151,11 @@ function FromNumber(schema, references, value) {
 }
 // prettier-ignore
 function FromObject(schema, references, value) {
-    const isConvertable = (0, index_7.IsObject)(value);
+    const isConvertable = (0, index_6.IsObject)(value);
     if (!isConvertable)
         return value;
     return Object.getOwnPropertyNames(schema.properties).reduce((value, key) => {
-        return !(0, index_7.IsUndefined)(value[key])
+        return !(0, index_6.IsUndefined)(value[key])
             ? ({ ...value, [key]: Visit(schema.properties[key], references, value[key]) })
             : ({ ...value });
     }, value);
@@ -188,14 +176,14 @@ function FromString(schema, references, value) {
     return TryConvertString(value);
 }
 function FromSymbol(schema, references, value) {
-    return (0, index_7.IsString)(value) || (0, index_7.IsNumber)(value) ? Symbol(value) : value;
+    return (0, index_6.IsString)(value) || (0, index_6.IsNumber)(value) ? Symbol(value) : value;
 }
 function FromThis(schema, references, value) {
     return Visit((0, index_3.Deref)(schema, references), references, value);
 }
 // prettier-ignore
 function FromTuple(schema, references, value) {
-    const isConvertable = (0, index_7.IsArray)(value) && !(0, index_7.IsUndefined)(schema.items);
+    const isConvertable = (0, index_6.IsArray)(value) && !(0, index_6.IsUndefined)(schema.items);
     if (!isConvertable)
         return value;
     return value.map((value, index) => {
@@ -217,9 +205,9 @@ function FromUnion(schema, references, value) {
     return value;
 }
 function Visit(schema, references, value) {
-    const references_ = (0, index_7.IsString)(schema.$id) ? [...references, schema] : references;
+    const references_ = (0, index_6.IsString)(schema.$id) ? [...references, schema] : references;
     const schema_ = schema;
-    switch (schema[index_5.Kind]) {
+    switch (schema[index_4.Kind]) {
         case 'Array':
             return FromArray(schema_, references_, value);
         case 'BigInt':

package/build/require/value/create/create.d.ts

@@ -1,30 +1,9 @@
 import { TypeBoxError } from '../../type/error/index';
 import type { TSchema } from '../../type/schema/index';
 import type { Static } from '../../type/static/index';
-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>;