@sinclair/typebox 0.32.0-dev-23 → 0.32.0-dev-25

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

@@ -1,4 +1,5 @@
 import { Kind, Hint, TransformKind } from '../symbols/index';
+import { TypeBoxError } from '../error/index';
 import { TransformOptions } from '../transform/index';
 import { TTemplateLiteral, TTemplateLiteralKind } from '../template-literal/index';
 import { TArray } from '../array/index';
@@ -35,7 +36,7 @@ import type { TUnsafe } from '../unsafe/index';
 import type { TVoid } from '../void/index';
 import type { TDate } from '../date/index';
 import type { TThis } from '../recursive/index';
-export declare class TypeGuardUnknownTypeError extends Error {
+export declare class TypeGuardUnknownTypeError extends TypeBoxError {
 }
 /** Returns true if this value has a Readonly symbol */
 export declare function IsReadonly<T extends TSchema>(value: T): value is TReadonly<T>;

package/build/require/type/guard/type.js

@@ -4,7 +4,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.IsSchema = exports.IsKind = exports.IsVoid = exports.IsUnsafe = exports.IsUnknown = exports.IsUint8Array = exports.IsUnion = exports.IsUnionLiteral = exports.IsUndefined = exports.IsTuple = exports.IsTransform = exports.IsThis = exports.IsTemplateLiteral = exports.IsSymbol = exports.IsString = exports.IsRef = exports.IsRecursive = exports.IsRecord = exports.IsPromise = exports.IsObject = exports.IsNumber = exports.IsNull = exports.IsNot = exports.IsNever = exports.IsMappedResult = exports.IsMappedKey = exports.IsLiteralValue = exports.IsLiteral = exports.IsLiteralBoolean = exports.IsLiteralNumber = exports.IsLiteralString = exports.IsKindOf = exports.IsIterator = exports.IsIntersect = exports.IsProperties = exports.IsInteger = exports.IsFunction = exports.IsDate = exports.IsConstructor = exports.IsBoolean = exports.IsBigInt = exports.IsAsyncIterator = exports.IsArray = exports.IsAny = exports.IsOptional = exports.IsReadonly = exports.TypeGuardUnknownTypeError = void 0;
 const ValueGuard = require("./value");
 const index_1 = require("../symbols/index");
-class TypeGuardUnknownTypeError extends Error {
+const index_2 = require("../error/index");
+class TypeGuardUnknownTypeError extends index_2.TypeBoxError {
 }
 exports.TypeGuardUnknownTypeError = TypeGuardUnknownTypeError;
 const KnownTypes = [

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

@@ -13,6 +13,7 @@ export * from './date/index';
 export * from './deref/index';
 export * from './discard/index';
 export * from './enum/index';
+export * from './error/index';
 export * from './exclude/index';
 export * from './extends/index';
 export * from './extract/index';

package/build/require/type/index.js

@@ -30,6 +30,7 @@ __exportStar(require("./date/index"), exports);
 __exportStar(require("./deref/index"), exports);
 __exportStar(require("./discard/index"), exports);
 __exportStar(require("./enum/index"), exports);
+__exportStar(require("./error/index"), exports);
 __exportStar(require("./exclude/index"), exports);
 __exportStar(require("./extends/index"), exports);
 __exportStar(require("./extract/index"), exports);

package/build/require/type/indexed/index.d.ts

@@ -1,3 +1,4 @@
 export * from './indexed-from-mapped-key';
+export * from './indexed-from-mapped-result';
 export * from './indexed-property-keys';
 export * from './indexed';

package/build/require/type/indexed/index.js

@@ -16,5 +16,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./indexed-from-mapped-key"), exports);
+__exportStar(require("./indexed-from-mapped-result"), exports);
 __exportStar(require("./indexed-property-keys"), exports);
 __exportStar(require("./indexed"), exports);

package/build/require/type/indexed/indexed-from-mapped-result.d.ts

@@ -0,0 +1,12 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { TProperties } from '../object/index';
+import { type TMappedResult } from '../mapped/index';
+import { type TIndex } from './index';
+import { TIndexPropertyKeys } from './indexed-property-keys';
+type TFromProperties<T extends TSchema, P extends TProperties> = ({
+    [K2 in keyof P]: TIndex<T, TIndexPropertyKeys<P[K2]>>;
+});
+type TFromMappedResult<T extends TSchema, K extends TMappedResult> = (TFromProperties<T, K['properties']>);
+export type TIndexFromMappedResult<T extends TSchema, R extends TMappedResult, P extends TProperties = TFromMappedResult<T, R>> = (TMappedResult<P>);
+export declare function IndexFromMappedResult<T extends TSchema, R extends TMappedResult, P extends TProperties = TFromMappedResult<T, R>>(T: T, R: R, options: SchemaOptions): TMappedResult<P>;
+export {};

package/build/require/type/indexed/indexed-from-mapped-result.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexFromMappedResult = void 0;
+const index_1 = require("../mapped/index");
+const index_2 = require("./index");
+const indexed_property_keys_1 = require("./indexed-property-keys");
+// prettier-ignore
+function FromProperties(T, P, options) {
+    return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
+        return { ...Acc, [K2]: (0, index_2.Index)(T, (0, indexed_property_keys_1.IndexPropertyKeys)(P[K2]), options) };
+    }, {});
+}
+// prettier-ignore
+function FromMappedResult(T, R, options) {
+    return FromProperties(T, R.properties, options);
+}
+// prettier-ignore
+function IndexFromMappedResult(T, R, options) {
+    const P = FromMappedResult(T, R, options);
+    return (0, index_1.MappedResult)(P);
+}
+exports.IndexFromMappedResult = IndexFromMappedResult;

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

@@ -4,7 +4,7 @@ import { type Assert } from '../helpers/index';
 import { type TNever } from '../never/index';
 import { type TRecursive } from '../recursive/index';
 import { type TIntersect } from '../intersect/index';
-import { type TMappedKey } from '../mapped/index';
+import { TMappedResult, type TMappedKey } from '../mapped/index';
 import { type TUnion } from '../union/index';
 import { type TTuple } from '../tuple/index';
 import { type TArray } from '../array/index';
@@ -12,6 +12,7 @@ import { type TIntersectEvaluated } from '../intersect/index';
 import { type TUnionEvaluated } from '../union/index';
 import { type TIndexPropertyKeys } from './indexed-property-keys';
 import { type TIndexFromMappedKey } from './indexed-from-mapped-key';
+import { type TIndexFromMappedResult } from './indexed-from-mapped-result';
 type TFromRest<T extends TSchema[], K extends PropertyKey, Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, K, [...Acc, Assert<TFromKey<L, K>, TSchema>]> : Acc);
 type TFromIntersectRest<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TNever ? TFromIntersectRest<R, [...Acc]> : TFromIntersectRest<R, [...Acc, L]> : Acc);
 type TFromIntersect<T extends TSchema[], K extends PropertyKey> = (TIntersectEvaluated<TFromIntersectRest<TFromRest<T, K>>>);
@@ -27,6 +28,8 @@ type FromSchema<T extends TSchema, K extends PropertyKey[]> = (TUnionEvaluated<T
 declare function FromSchema<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): FromSchema<T, K>;
 export type TIndex<T extends TSchema, K extends PropertyKey[]> = (FromSchema<T, K>);
 /** `[Json]` Returns an Indexed property type for the given keys */
+export declare function Index<T extends TSchema, K extends TMappedResult>(T: T, K: K, options?: SchemaOptions): TIndexFromMappedResult<T, K>;
+/** `[Json]` Returns an Indexed property type for the given keys */
 export declare function Index<T extends TSchema, K extends TMappedKey>(T: T, K: K, options?: SchemaOptions): TIndexFromMappedKey<T, K>;
 /** `[Json]` Returns an Indexed property type for the given keys */
 export declare function Index<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TIndex<T, I>;

package/build/require/type/indexed/indexed.js

@@ -8,10 +8,10 @@ const index_3 = require("../union/index");
 const type_1 = require("../clone/type");
 const indexed_property_keys_1 = require("./indexed-property-keys");
 const indexed_from_mapped_key_1 = require("./indexed-from-mapped-key");
+const indexed_from_mapped_result_1 = require("./indexed-from-mapped-result");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 const type_2 = require("../guard/type");
 // prettier-ignore
 function FromRest(T, K, Acc = []) {
@@ -87,8 +87,9 @@ function FromSchema(T, K) {
 /** `[Json]` Returns an Indexed property type for the given keys */
 function Index(T, K, options = {}) {
     // prettier-ignore
-    return ((0, type_2.IsMappedKey)(K) ? (0, type_1.CloneType)((0, indexed_from_mapped_key_1.IndexFromMappedKey)(T, K, options)) :
-        (0, type_2.IsSchema)(K) ? (0, type_1.CloneType)(FromSchema(T, (0, indexed_property_keys_1.IndexPropertyKeys)(K)), options) :
-            (0, type_1.CloneType)(FromSchema(T, K), options));
+    return ((0, type_2.IsMappedResult)(K) ? (0, type_1.CloneType)((0, indexed_from_mapped_result_1.IndexFromMappedResult)(T, K, options)) :
+        (0, type_2.IsMappedKey)(K) ? (0, type_1.CloneType)((0, indexed_from_mapped_key_1.IndexFromMappedKey)(T, K, options)) :
+            (0, type_2.IsSchema)(K) ? (0, type_1.CloneType)(FromSchema(T, (0, indexed_property_keys_1.IndexPropertyKeys)(K)), options) :
+                (0, type_1.CloneType)(FromSchema(T, K), options));
 }
 exports.Index = Index;

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

@@ -26,7 +26,7 @@ type TFromUnionKeyLiteralNumber<K extends TLiteral<number>, T extends TSchema> =
     [_ in K['const']]: T;
 };
 type TFromUnionKeyRest<K extends TSchema[], T extends TSchema> = K extends [infer L extends TSchema, ...infer R extends TSchema[]] ? (L extends TUnion<infer S> ? TFromUnionKeyRest<S, T> & TFromUnionKeyRest<R, T> : L extends TLiteral<string> ? TFromUnionKeyLiteralString<L, T> & TFromUnionKeyRest<R, T> : L extends TLiteral<number> ? TFromUnionKeyLiteralNumber<L, T> & TFromUnionKeyRest<R, T> : {}) : {};
-type TFromUnionKey<K extends TSchema[], T extends TSchema, P extends TProperties = TFromUnionKeyRest<K, T>> = (Ensure<TObject<P>>);
+type TFromUnionKey<K extends TSchema[], T extends TSchema, P extends TProperties = TFromUnionKeyRest<K, T>> = (Ensure<TObject<Evaluate<P>>>);
 type TFromLiteralKey<K extends TLiteralValue, T extends TSchema> = (Ensure<TObject<{
     [_ in Assert<K, PropertyKey>]: T;
 }>>);

package/build/require/type/template-literal/finite.d.ts

@@ -1,3 +1,4 @@
+import { TypeBoxError } from '../error/index';
 import type { TTemplateLiteral, TTemplateLiteralKind } from './index';
 import type { TUnion } from '../union/index';
 import type { TString } from '../string/index';
@@ -7,7 +8,7 @@ import type { TInteger } from '../integer/index';
 import type { TBigInt } from '../bigint/index';
 import type { TLiteral } from '../literal/index';
 import type { Expression } from './parse';
-export declare class TemplateLiteralFiniteError extends Error {
+export declare class TemplateLiteralFiniteError extends TypeBoxError {
 }
 type TFromTemplateLiteralKind<T> = T extends TTemplateLiteral<infer U extends TTemplateLiteralKind[]> ? TFromTemplateLiteralKinds<U> : T extends TUnion<infer U extends TTemplateLiteralKind[]> ? TFromTemplateLiteralKinds<U> : T extends TString ? false : T extends TNumber ? false : T extends TInteger ? false : T extends TBigInt ? false : T extends TBoolean ? true : T extends TLiteral ? true : false;
 type TFromTemplateLiteralKinds<T extends TTemplateLiteralKind[]> = T extends [infer L extends TTemplateLiteralKind, ...infer R extends TTemplateLiteralKind[]] ? TFromTemplateLiteralKind<L> extends false ? false : TFromTemplateLiteralKinds<R> : true;

package/build/require/type/template-literal/finite.js

@@ -3,10 +3,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IsTemplateLiteralFinite = exports.IsTemplateLiteralExpressionFinite = exports.TemplateLiteralFiniteError = void 0;
 const parse_1 = require("./parse");
+const index_1 = require("../error/index");
 // ------------------------------------------------------------------
 // TemplateLiteralFiniteError
 // ------------------------------------------------------------------
-class TemplateLiteralFiniteError extends Error {
+class TemplateLiteralFiniteError extends index_1.TypeBoxError {
 }
 exports.TemplateLiteralFiniteError = TemplateLiteralFiniteError;
 // ------------------------------------------------------------------

package/build/require/type/template-literal/generate.d.ts

@@ -1,11 +1,12 @@
 import { TIsTemplateLiteralFinite } from './finite';
+import { TypeBoxError } from '../error/index';
 import type { Assert } from '../helpers/index';
 import type { TBoolean } from '../boolean/index';
 import type { TTemplateLiteral, TTemplateLiteralKind } from './index';
 import type { TLiteral, TLiteralValue } from '../literal/index';
 import type { Expression } from './parse';
 import type { TUnion } from '../union/index';
-export declare class TemplateLiteralGenerateError extends Error {
+export declare class TemplateLiteralGenerateError extends TypeBoxError {
 }
 type TStringReduceUnary<L extends string, R extends string[], Acc extends string[] = []> = R extends [infer A extends string, ...infer B extends string[]] ? TStringReduceUnary<L, B, [...Acc, `${L}${A}`]> : Acc;
 type TStringReduceBinary<L extends string[], R extends string[], Acc extends string[] = []> = L extends [infer A extends string, ...infer B extends string[]] ? TStringReduceBinary<B, R, [...Acc, ...TStringReduceUnary<A, R>]> : Acc;

package/build/require/type/template-literal/generate.js

@@ -4,10 +4,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TemplateLiteralGenerate = exports.TemplateLiteralExpressionGenerate = exports.TemplateLiteralGenerateError = void 0;
 const finite_1 = require("./finite");
 const parse_1 = require("./parse");
+const index_1 = require("../error/index");
 // ------------------------------------------------------------------
 // TemplateLiteralGenerateError
 // ------------------------------------------------------------------
-class TemplateLiteralGenerateError extends Error {
+class TemplateLiteralGenerateError extends index_1.TypeBoxError {
 }
 exports.TemplateLiteralGenerateError = TemplateLiteralGenerateError;
 // ------------------------------------------------------------------

package/build/require/type/template-literal/parse.d.ts

@@ -1,4 +1,5 @@
-export declare class TemplateLiteralParserError extends Error {
+import { TypeBoxError } from '../error/index';
+export declare class TemplateLiteralParserError extends TypeBoxError {
 }
 export type Expression = ExpressionAnd | ExpressionOr | ExpressionConst;
 export type ExpressionConst = {

package/build/require/type/template-literal/parse.js

@@ -1,11 +1,12 @@
 "use strict";
-
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TemplateLiteralParseExact = exports.TemplateLiteralParse = exports.TemplateLiteralParserError = void 0;
+
+const index_1 = require("../error/index");
 // ------------------------------------------------------------------
 // TemplateLiteralParserError
 // ------------------------------------------------------------------
-class TemplateLiteralParserError extends Error {
+class TemplateLiteralParserError extends index_1.TypeBoxError {
 }
 exports.TemplateLiteralParserError = TemplateLiteralParserError;
 // prettier-ignore

package/build/require/type/template-literal/pattern.d.ts

@@ -1,4 +1,5 @@
 import type { TTemplateLiteralKind } from './index';
-export declare class TemplateLiteralPatternError extends Error {
+import { TypeBoxError } from '../error/index';
+export declare class TemplateLiteralPatternError extends TypeBoxError {
 }
 export declare function TemplateLiteralPattern(kinds: TTemplateLiteralKind[]): string;

package/build/require/type/template-literal/pattern.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TemplateLiteralPattern = exports.TemplateLiteralPatternError = void 0;
 const index_1 = require("../patterns/index");
 const index_2 = require("../symbols/index");
+const index_3 = require("../error/index");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
@@ -12,7 +13,7 @@ const type_1 = require("../guard/type");
 // ------------------------------------------------------------------
 // TemplateLiteralPatternError
 // ------------------------------------------------------------------
-class TemplateLiteralPatternError extends Error {
+class TemplateLiteralPatternError extends index_3.TypeBoxError {
 }
 exports.TemplateLiteralPatternError = TemplateLiteralPatternError;
 // ------------------------------------------------------------------

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

@@ -8,7 +8,7 @@ import { type TEnum, type TEnumKey, type TEnumValue } from '../enum/index';
 import { type TExclude, type TExcludeFromMappedResult } from '../exclude/index';
 import { type TExtends, type TExtendsFromMappedKey, type TExtendsFromMappedResult } from '../extends/index';
 import { type TExtract, type TExtractFromMappedResult } from '../extract/index';
-import { TIndex, type TIndexPropertyKeys, type TIndexFromMappedKey } from '../indexed/index';
+import { TIndex, type TIndexPropertyKeys, type TIndexFromMappedKey, type TIndexFromMappedResult } from '../indexed/index';
 import { type IntegerOptions, type TInteger } from '../integer/index';
 import { Intersect, type IntersectOptions } from '../intersect/index';
 import { type TCapitalize, type TUncapitalize, type TLowercase, type TUppercase } from '../intrinsic/index';
@@ -93,6 +93,8 @@ export declare class JsonTypeBuilder {
     /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
     Extract<L extends TSchema, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtract<L, R>;
     /** `[Json]` Returns an Indexed property type for the given keys */
+    Index<T extends TSchema, K extends TMappedResult>(T: T, K: K, options?: SchemaOptions): TIndexFromMappedResult<T, K>;
+    /** `[Json]` Returns an Indexed property type for the given keys */
     Index<T extends TSchema, K extends TMappedKey>(T: T, K: K, options?: SchemaOptions): TIndexFromMappedKey<T, K>;
     /** `[Json]` Returns an Indexed property type for the given keys */
     Index<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TIndex<T, I>;

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

@@ -1,19 +1,20 @@
+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 Error {
+export declare class ValueCastArrayUniqueItemsTypeError extends TypeBoxError {
     readonly schema: TSchema;
     readonly value: unknown;
     constructor(schema: TSchema, value: unknown);
 }
-export declare class ValueCastNeverTypeError extends Error {
+export declare class ValueCastNeverTypeError extends TypeBoxError {
     readonly schema: TSchema;
     constructor(schema: TSchema);
 }
-export declare class ValueCastRecursiveTypeError extends Error {
+export declare class ValueCastRecursiveTypeError extends TypeBoxError {
     readonly schema: TSchema;
     constructor(schema: TSchema);
 }
-export declare class ValueCastUnknownTypeError extends Error {
+export declare class ValueCastUnknownTypeError extends TypeBoxError {
     readonly schema: TSchema;
     constructor(schema: TSchema);
 }

package/build/require/value/cast/cast.js

@@ -3,15 +3,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Cast = exports.ValueCastUnknownTypeError = exports.ValueCastRecursiveTypeError = exports.ValueCastNeverTypeError = exports.ValueCastArrayUniqueItemsTypeError = void 0;
 const index_1 = require("../guard/index");
-const index_2 = require("../../type/symbols/index");
-const index_3 = require("../create/index");
-const index_4 = require("../check/index");
-const index_5 = require("../clone/index");
-const index_6 = require("../deref/index");
+const index_2 = require("../../type/error/index");
+const index_3 = require("../../type/symbols/index");
+const index_4 = require("../create/index");
+const index_5 = require("../check/index");
+const index_6 = require("../clone/index");
+const index_7 = require("../deref/index");
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
-class ValueCastArrayUniqueItemsTypeError extends Error {
+class ValueCastArrayUniqueItemsTypeError extends index_2.TypeBoxError {
     constructor(schema, value) {
         super('Array cast produced invalid data due to uniqueItems constraint');
         this.schema = schema;
@@ -19,21 +20,21 @@ class ValueCastArrayUniqueItemsTypeError extends Error {
     }
 }
 exports.ValueCastArrayUniqueItemsTypeError = ValueCastArrayUniqueItemsTypeError;
-class ValueCastNeverTypeError extends Error {
+class ValueCastNeverTypeError extends index_2.TypeBoxError {
     constructor(schema) {
         super('Never types cannot be cast');
         this.schema = schema;
     }
 }
 exports.ValueCastNeverTypeError = ValueCastNeverTypeError;
-class ValueCastRecursiveTypeError extends Error {
+class ValueCastRecursiveTypeError extends index_2.TypeBoxError {
     constructor(schema) {
         super('Cannot cast recursive schemas');
         this.schema = schema;
     }
 }
 exports.ValueCastRecursiveTypeError = ValueCastRecursiveTypeError;
-class ValueCastUnknownTypeError extends Error {
+class ValueCastUnknownTypeError extends index_2.TypeBoxError {
     constructor(schema) {
         super('Unknown type');
         this.schema = schema;
@@ -49,20 +50,20 @@ exports.ValueCastUnknownTypeError = ValueCastUnknownTypeError;
 // used as union discriminator fields.
 // ------------------------------------------------------------------
 function ScoreUnion(schema, references, value) {
-    if (schema[index_2.Kind] === 'Object' && typeof value === 'object' && !(0, index_1.IsNull)(value)) {
+    if (schema[index_3.Kind] === 'Object' && typeof value === 'object' && !(0, index_1.IsNull)(value)) {
         const object = schema;
         const keys = Object.getOwnPropertyNames(value);
         const entries = Object.entries(object.properties);
         const [point, max] = [1 / entries.length, entries.length];
         return entries.reduce((acc, [key, schema]) => {
-            const literal = schema[index_2.Kind] === 'Literal' && schema.const === value[key] ? max : 0;
-            const checks = (0, index_4.Check)(schema, references, value[key]) ? point : 0;
+            const literal = schema[index_3.Kind] === 'Literal' && schema.const === value[key] ? max : 0;
+            const checks = (0, index_5.Check)(schema, references, value[key]) ? point : 0;
             const exists = keys.includes(key) ? point : 0;
             return acc + (literal + checks + exists);
         }, 0);
     }
     else {
-        return (0, index_4.Check)(schema, references, value) ? 1 : 0;
+        return (0, index_5.Check)(schema, references, value) ? 1 : 0;
     }
 }
 function SelectUnion(union, references, value) {
@@ -89,31 +90,31 @@ function CastUnion(union, references, value) {
 // Default
 // ------------------------------------------------------------------
 function DefaultClone(schema, references, value) {
-    return (0, index_4.Check)(schema, references, value) ? (0, index_5.Clone)(value) : (0, index_3.Create)(schema, references);
+    return (0, index_5.Check)(schema, references, value) ? (0, index_6.Clone)(value) : (0, index_4.Create)(schema, references);
 }
 function Default(schema, references, value) {
-    return (0, index_4.Check)(schema, references, value) ? value : (0, index_3.Create)(schema, references);
+    return (0, index_5.Check)(schema, references, value) ? value : (0, index_4.Create)(schema, references);
 }
 // ------------------------------------------------------------------
 // Cast
 // ------------------------------------------------------------------
 function FromArray(schema, references, value) {
-    if ((0, index_4.Check)(schema, references, value))
-        return (0, index_5.Clone)(value);
-    const created = (0, index_1.IsArray)(value) ? (0, index_5.Clone)(value) : (0, index_3.Create)(schema, references);
+    if ((0, index_5.Check)(schema, references, value))
+        return (0, index_6.Clone)(value);
+    const created = (0, index_1.IsArray)(value) ? (0, index_6.Clone)(value) : (0, index_4.Create)(schema, references);
     const minimum = (0, index_1.IsNumber)(schema.minItems) && created.length < schema.minItems ? [...created, ...Array.from({ length: schema.minItems - created.length }, () => null)] : created;
     const maximum = (0, index_1.IsNumber)(schema.maxItems) && minimum.length > schema.maxItems ? minimum.slice(0, schema.maxItems) : minimum;
     const casted = maximum.map((value) => Visit(schema.items, references, value));
     if (schema.uniqueItems !== true)
         return casted;
     const unique = [...new Set(casted)];
-    if (!(0, index_4.Check)(schema, references, unique))
+    if (!(0, index_5.Check)(schema, references, unique))
         throw new ValueCastArrayUniqueItemsTypeError(schema, unique);
     return unique;
 }
 function FromConstructor(schema, references, value) {
-    if ((0, index_4.Check)(schema, references, value))
-        return (0, index_3.Create)(schema, references);
+    if ((0, index_5.Check)(schema, references, value))
+        return (0, index_4.Create)(schema, references);
     const required = new Set(schema.returns.required || []);
     const result = function () { };
     for (const [key, property] of Object.entries(schema.returns.properties)) {
@@ -124,18 +125,18 @@ function FromConstructor(schema, references, value) {
     return result;
 }
 function FromIntersect(schema, references, value) {
-    const created = (0, index_3.Create)(schema, references);
+    const created = (0, index_4.Create)(schema, references);
     const mapped = (0, index_1.IsPlainObject)(created) && (0, index_1.IsPlainObject)(value) ? { ...created, ...value } : value;
-    return (0, index_4.Check)(schema, references, mapped) ? mapped : (0, index_3.Create)(schema, references);
+    return (0, index_5.Check)(schema, references, mapped) ? mapped : (0, index_4.Create)(schema, references);
 }
 function FromNever(schema, references, value) {
     throw new ValueCastNeverTypeError(schema);
 }
 function FromObject(schema, references, value) {
-    if ((0, index_4.Check)(schema, references, value))
+    if ((0, index_5.Check)(schema, references, value))
         return value;
     if (value === null || typeof value !== 'object')
-        return (0, index_3.Create)(schema, references);
+        return (0, index_4.Create)(schema, references);
     const required = new Set(schema.required || []);
     const result = {};
     for (const [key, property] of Object.entries(schema.properties)) {
@@ -155,10 +156,10 @@ function FromObject(schema, references, value) {
     return result;
 }
 function FromRecord(schema, references, value) {
-    if ((0, index_4.Check)(schema, references, value))
-        return (0, index_5.Clone)(value);
+    if ((0, index_5.Check)(schema, references, value))
+        return (0, index_6.Clone)(value);
     if (value === null || typeof value !== 'object' || Array.isArray(value) || value instanceof Date)
-        return (0, index_3.Create)(schema, references);
+        return (0, index_4.Create)(schema, references);
     const subschemaPropertyName = Object.getOwnPropertyNames(schema.patternProperties)[0];
     const subschema = schema.patternProperties[subschemaPropertyName];
     const result = {};
@@ -168,27 +169,27 @@ function FromRecord(schema, references, value) {
     return result;
 }
 function FromRef(schema, references, value) {
-    return Visit((0, index_6.Deref)(schema, references), references, value);
+    return Visit((0, index_7.Deref)(schema, references), references, value);
 }
 function FromThis(schema, references, value) {
-    return Visit((0, index_6.Deref)(schema, references), references, value);
+    return Visit((0, index_7.Deref)(schema, references), references, value);
 }
 function FromTuple(schema, references, value) {
-    if ((0, index_4.Check)(schema, references, value))
-        return (0, index_5.Clone)(value);
+    if ((0, index_5.Check)(schema, references, value))
+        return (0, index_6.Clone)(value);
     if (!(0, index_1.IsArray)(value))
-        return (0, index_3.Create)(schema, references);
+        return (0, index_4.Create)(schema, references);
     if (schema.items === undefined)
         return [];
     return schema.items.map((schema, index) => Visit(schema, references, value[index]));
 }
 function FromUnion(schema, references, value) {
-    return (0, index_4.Check)(schema, references, value) ? (0, index_5.Clone)(value) : CastUnion(schema, references, value);
+    return (0, index_5.Check)(schema, references, value) ? (0, index_6.Clone)(value) : CastUnion(schema, references, value);
 }
 function Visit(schema, references, value) {
     const references_ = (0, index_1.IsString)(schema.$id) ? [...references, schema] : references;
     const schema_ = schema;
-    switch (schema[index_2.Kind]) {
+    switch (schema[index_3.Kind]) {
         // --------------------------------------------------------------
         // Structural
         // --------------------------------------------------------------

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

@@ -1,6 +1,7 @@
+import { TypeBoxError } from '../../type/error/index';
 import type { TSchema } from '../../type/schema/index';
 import type { Static } from '../../type/static/index';
-export declare class ValueCheckUnknownTypeError extends Error {
+export declare class ValueCheckUnknownTypeError extends TypeBoxError {
     readonly schema: TSchema;
     constructor(schema: TSchema);
 }