@sinclair/typebox 0.32.0-dev-22 → 0.32.0-dev-24

package/build/import/value/hash/hash.mjs

@@ -1,8 +1,9 @@
 import { IsArray, IsBoolean, IsBigInt, IsDate, IsNull, IsNumber, IsPlainObject, IsString, IsSymbol, IsUint8Array, IsUndefined } from '../guard/index.mjs';
+import { TypeBoxError } from '../../type/error/index.mjs';
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
-export class ValueHashError extends Error {
+export class ValueHashError extends TypeBoxError {
     value;
     constructor(value) {
         super(`Unable to hash value`);

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

@@ -1,7 +1,8 @@
-export declare class ValueMutateTypeMismatchError extends Error {
+import { TypeBoxError } from '../../type/error/index.mjs';
+export declare class ValueMutateTypeMismatchError extends TypeBoxError {
     constructor();
 }
-export declare class ValueMutateInvalidRootMutationError extends Error {
+export declare class ValueMutateInvalidRootMutationError extends TypeBoxError {
     constructor();
 }
 export type Mutable = {

package/build/import/value/mutate/mutate.mjs

@@ -1,15 +1,16 @@
 import { IsPlainObject, IsArray, IsTypedArray, IsValueType } from '../guard/index.mjs';
 import { ValuePointer } from '../pointer/index.mjs';
 import { Clone } from '../clone/index.mjs';
+import { TypeBoxError } from '../../type/error/index.mjs';
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
-export class ValueMutateTypeMismatchError extends Error {
+export class ValueMutateTypeMismatchError extends TypeBoxError {
     constructor() {
         super('Cannot assign due type mismatch of assignable values');
     }
 }
-export class ValueMutateInvalidRootMutationError extends Error {
+export class ValueMutateInvalidRootMutationError extends TypeBoxError {
     constructor() {
         super('Only object and array types can be mutated at the root level');
     }

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

@@ -1,10 +1,11 @@
-export declare class ValuePointerRootSetError extends Error {
+import { TypeBoxError } from '../../type/error/index.mjs';
+export declare class ValuePointerRootSetError extends TypeBoxError {
     readonly value: unknown;
     readonly path: string;
     readonly update: unknown;
     constructor(value: unknown, path: string, update: unknown);
 }
-export declare class ValuePointerRootDeleteError extends Error {
+export declare class ValuePointerRootDeleteError extends TypeBoxError {
     readonly value: unknown;
     readonly path: string;
     constructor(value: unknown, path: string);

package/build/import/value/pointer/pointer.mjs

@@ -1,7 +1,8 @@
+import { TypeBoxError } from '../../type/error/index.mjs';
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
-export class ValuePointerRootSetError extends Error {
+export class ValuePointerRootSetError extends TypeBoxError {
     value;
     path;
     update;
@@ -12,7 +13,7 @@ export class ValuePointerRootSetError extends Error {
         this.update = update;
     }
 }
-export class ValuePointerRootDeleteError extends Error {
+export class ValuePointerRootDeleteError extends TypeBoxError {
     value;
     path;
     constructor(value, path) {

package/build/import/value/transform/decode.d.mts

@@ -1,12 +1,13 @@
+import { TypeBoxError } from '../../type/error/index.mjs';
 import { ValueError } from '../../errors/index.mjs';
 import type { TSchema } from '../../type/schema/index.mjs';
-export declare class TransformDecodeCheckError extends Error {
+export declare class TransformDecodeCheckError extends TypeBoxError {
     readonly schema: TSchema;
     readonly value: unknown;
     readonly error: ValueError;
     constructor(schema: TSchema, value: unknown, error: ValueError);
 }
-export declare class TransformDecodeError extends Error {
+export declare class TransformDecodeError extends TypeBoxError {
     readonly schema: TSchema;
     readonly value: unknown;
     constructor(schema: TSchema, value: unknown, error: any);

package/build/import/value/transform/decode.mjs

@@ -1,4 +1,5 @@
 import { Kind, TransformKind } from '../../type/symbols/index.mjs';
+import { TypeBoxError } from '../../type/error/index.mjs';
 import { KeyOfPropertyKeys } from '../../type/keyof/index.mjs';
 import { Index } from '../../type/indexed/index.mjs';
 import { Deref } from '../deref/index.mjs';
@@ -15,7 +16,7 @@ import { IsTransform, IsSchema } from '../../type/guard/type.mjs';
 // Errors
 // ------------------------------------------------------------------
 // thrown externally
-export class TransformDecodeCheckError extends Error {
+export class TransformDecodeCheckError extends TypeBoxError {
     schema;
     value;
     error;
@@ -26,7 +27,7 @@ export class TransformDecodeCheckError extends Error {
         this.error = error;
     }
 }
-export class TransformDecodeError extends Error {
+export class TransformDecodeError extends TypeBoxError {
     schema;
     value;
     constructor(schema, value, error) {

package/build/import/value/transform/encode.d.mts

@@ -1,12 +1,13 @@
+import { TypeBoxError } from '../../type/error/index.mjs';
 import { ValueError } from '../../errors/index.mjs';
 import type { TSchema } from '../../type/schema/index.mjs';
-export declare class TransformEncodeCheckError extends Error {
+export declare class TransformEncodeCheckError extends TypeBoxError {
     readonly schema: TSchema;
     readonly value: unknown;
     readonly error: ValueError;
     constructor(schema: TSchema, value: unknown, error: ValueError);
 }
-export declare class TransformEncodeError extends Error {
+export declare class TransformEncodeError extends TypeBoxError {
     readonly schema: TSchema;
     readonly value: unknown;
     constructor(schema: TSchema, value: unknown, error: any);

package/build/import/value/transform/encode.mjs

@@ -1,4 +1,5 @@
 import { Kind, TransformKind } from '../../type/symbols/index.mjs';
+import { TypeBoxError } from '../../type/error/index.mjs';
 import { KeyOfPropertyKeys } from '../../type/keyof/index.mjs';
 import { Index } from '../../type/indexed/index.mjs';
 import { Deref } from '../deref/index.mjs';
@@ -14,7 +15,7 @@ import { IsTransform, IsSchema } from '../../type/guard/type.mjs';
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
-export class TransformEncodeCheckError extends Error {
+export class TransformEncodeCheckError extends TypeBoxError {
     schema;
     value;
     error;
@@ -25,7 +26,7 @@ export class TransformEncodeCheckError extends Error {
         this.error = error;
     }
 }
-export class TransformEncodeError extends Error {
+export class TransformEncodeError extends TypeBoxError {
     schema;
     value;
     constructor(schema, value, error) {

package/build/require/compiler/compiler.d.ts

@@ -1,4 +1,5 @@
 import { ValueErrorIterator } from '../errors/index';
+import { TypeBoxError } from '../type/error/index';
 import type { TSchema } from '../type/schema/index';
 import type { Static, StaticDecode, StaticEncode } from '../type/static/index';
 export type CheckFunction = (value: unknown) => boolean;
@@ -20,11 +21,11 @@ export declare class TypeCheck<T extends TSchema> {
     /** Encodes a value or throws if error */
     Encode(value: unknown): StaticEncode<T>;
 }
-export declare class TypeCompilerUnknownTypeError extends Error {
+export declare class TypeCompilerUnknownTypeError extends TypeBoxError {
     readonly schema: TSchema;
     constructor(schema: TSchema);
 }
-export declare class TypeCompilerTypeGuardError extends Error {
+export declare class TypeCompilerTypeGuardError extends TypeBoxError {
     readonly schema: TSchema;
     constructor(schema: TSchema);
 }

package/build/require/compiler/compiler.js

@@ -5,17 +5,18 @@ exports.TypeCompiler = exports.Policy = exports.TypeCompilerTypeGuardError = exp
 const index_1 = require("../value/transform/index");
 const index_2 = require("../errors/index");
 const index_3 = require("../system/index");
-const index_4 = require("../value/deref/index");
-const index_5 = require("../value/hash/index");
-const index_6 = require("../type/symbols/index");
-const index_7 = require("../type/registry/index");
-const index_8 = require("../type/keyof/index");
+const index_4 = require("../type/error/index");
+const index_5 = require("../value/deref/index");
+const index_6 = require("../value/hash/index");
+const index_7 = require("../type/symbols/index");
+const index_8 = require("../type/registry/index");
+const index_9 = require("../type/keyof/index");
 const extends_undefined_1 = require("../type/extends/extends-undefined");
-const index_9 = require("../type/never/index");
+const index_10 = require("../type/never/index");
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
-const index_10 = require("../value/guard/index");
+const index_11 = require("../value/guard/index");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
@@ -142,14 +143,14 @@ var LiteralString;
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
-class TypeCompilerUnknownTypeError extends Error {
+class TypeCompilerUnknownTypeError extends index_4.TypeBoxError {
     constructor(schema) {
         super('Unknown type');
         this.schema = schema;
     }
 }
 exports.TypeCompilerUnknownTypeError = TypeCompilerUnknownTypeError;
-class TypeCompilerTypeGuardError extends Error {
+class TypeCompilerTypeGuardError extends index_4.TypeBoxError {
     constructor(schema) {
         super('Preflight validation check failed to guard for the given schema');
         this.schema = schema;
@@ -191,7 +192,7 @@ var TypeCompiler;
     // Guards
     // ----------------------------------------------------------------
     function IsAnyOrUnknown(schema) {
-        return schema[index_6.Kind] === 'Any' || schema[index_6.Kind] === 'Unknown';
+        return schema[index_7.Kind] === 'Any' || schema[index_7.Kind] === 'Unknown';
     }
     // ----------------------------------------------------------------
     // Types
@@ -202,17 +203,17 @@ var TypeCompiler;
     function* FromArray(schema, references, value) {
         yield `Array.isArray(${value})`;
         const [parameter, accumulator] = [CreateParameter('value', 'any'), CreateParameter('acc', 'number')];
-        if ((0, index_10.IsNumber)(schema.maxItems))
+        if ((0, index_11.IsNumber)(schema.maxItems))
             yield `${value}.length <= ${schema.maxItems}`;
-        if ((0, index_10.IsNumber)(schema.minItems))
+        if ((0, index_11.IsNumber)(schema.minItems))
             yield `${value}.length >= ${schema.minItems}`;
         const elementExpression = CreateExpression(schema.items, references, 'value');
         yield `${value}.every((${parameter}) => ${elementExpression})`;
-        if ((0, type_1.IsSchema)(schema.contains) || (0, index_10.IsNumber)(schema.minContains) || (0, index_10.IsNumber)(schema.maxContains)) {
-            const containsSchema = (0, type_1.IsSchema)(schema.contains) ? schema.contains : (0, index_9.Never)();
+        if ((0, type_1.IsSchema)(schema.contains) || (0, index_11.IsNumber)(schema.minContains) || (0, index_11.IsNumber)(schema.maxContains)) {
+            const containsSchema = (0, type_1.IsSchema)(schema.contains) ? schema.contains : (0, index_10.Never)();
             const checkExpression = CreateExpression(containsSchema, references, 'value');
-            const checkMinContains = (0, index_10.IsNumber)(schema.minContains) ? [`(count >= ${schema.minContains})`] : [];
-            const checkMaxContains = (0, index_10.IsNumber)(schema.maxContains) ? [`(count <= ${schema.maxContains})`] : [];
+            const checkMinContains = (0, index_11.IsNumber)(schema.minContains) ? [`(count >= ${schema.minContains})`] : [];
+            const checkMaxContains = (0, index_11.IsNumber)(schema.maxContains) ? [`(count <= ${schema.maxContains})`] : [];
             const checkCount = `const count = value.reduce((${accumulator}, ${parameter}) => ${checkExpression} ? acc + 1 : acc, 0)`;
             const check = [`(count > 0)`, ...checkMinContains, ...checkMaxContains].join(' && ');
             yield `((${parameter}) => { ${checkCount}; return ${check}})(${value})`;
@@ -228,15 +229,15 @@ var TypeCompiler;
     }
     function* FromBigInt(schema, references, value) {
         yield `(typeof ${value} === 'bigint')`;
-        if ((0, index_10.IsBigInt)(schema.exclusiveMaximum))
+        if ((0, index_11.IsBigInt)(schema.exclusiveMaximum))
             yield `${value} < BigInt(${schema.exclusiveMaximum})`;
-        if ((0, index_10.IsBigInt)(schema.exclusiveMinimum))
+        if ((0, index_11.IsBigInt)(schema.exclusiveMinimum))
             yield `${value} > BigInt(${schema.exclusiveMinimum})`;
-        if ((0, index_10.IsBigInt)(schema.maximum))
+        if ((0, index_11.IsBigInt)(schema.maximum))
             yield `${value} <= BigInt(${schema.maximum})`;
-        if ((0, index_10.IsBigInt)(schema.minimum))
+        if ((0, index_11.IsBigInt)(schema.minimum))
             yield `${value} >= BigInt(${schema.minimum})`;
-        if ((0, index_10.IsBigInt)(schema.multipleOf))
+        if ((0, index_11.IsBigInt)(schema.multipleOf))
             yield `(${value} % BigInt(${schema.multipleOf})) === 0`;
     }
     function* FromBoolean(schema, references, value) {
@@ -247,15 +248,15 @@ var TypeCompiler;
     }
     function* FromDate(schema, references, value) {
         yield `(${value} instanceof Date) && Number.isFinite(${value}.getTime())`;
-        if ((0, index_10.IsNumber)(schema.exclusiveMaximumTimestamp))
+        if ((0, index_11.IsNumber)(schema.exclusiveMaximumTimestamp))
             yield `${value}.getTime() < ${schema.exclusiveMaximumTimestamp}`;
-        if ((0, index_10.IsNumber)(schema.exclusiveMinimumTimestamp))
+        if ((0, index_11.IsNumber)(schema.exclusiveMinimumTimestamp))
             yield `${value}.getTime() > ${schema.exclusiveMinimumTimestamp}`;
-        if ((0, index_10.IsNumber)(schema.maximumTimestamp))
+        if ((0, index_11.IsNumber)(schema.maximumTimestamp))
             yield `${value}.getTime() <= ${schema.maximumTimestamp}`;
-        if ((0, index_10.IsNumber)(schema.minimumTimestamp))
+        if ((0, index_11.IsNumber)(schema.minimumTimestamp))
             yield `${value}.getTime() >= ${schema.minimumTimestamp}`;
-        if ((0, index_10.IsNumber)(schema.multipleOfTimestamp))
+        if ((0, index_11.IsNumber)(schema.multipleOfTimestamp))
             yield `(${value}.getTime() % ${schema.multipleOfTimestamp}) === 0`;
     }
     function* FromFunction(schema, references, value) {
@@ -263,26 +264,26 @@ var TypeCompiler;
     }
     function* FromInteger(schema, references, value) {
         yield `(typeof ${value} === 'number' && Number.isInteger(${value}))`;
-        if ((0, index_10.IsNumber)(schema.exclusiveMaximum))
+        if ((0, index_11.IsNumber)(schema.exclusiveMaximum))
             yield `${value} < ${schema.exclusiveMaximum}`;
-        if ((0, index_10.IsNumber)(schema.exclusiveMinimum))
+        if ((0, index_11.IsNumber)(schema.exclusiveMinimum))
             yield `${value} > ${schema.exclusiveMinimum}`;
-        if ((0, index_10.IsNumber)(schema.maximum))
+        if ((0, index_11.IsNumber)(schema.maximum))
             yield `${value} <= ${schema.maximum}`;
-        if ((0, index_10.IsNumber)(schema.minimum))
+        if ((0, index_11.IsNumber)(schema.minimum))
             yield `${value} >= ${schema.minimum}`;
-        if ((0, index_10.IsNumber)(schema.multipleOf))
+        if ((0, index_11.IsNumber)(schema.multipleOf))
             yield `(${value} % ${schema.multipleOf}) === 0`;
     }
     function* FromIntersect(schema, references, value) {
         const check1 = schema.allOf.map((schema) => CreateExpression(schema, references, value)).join(' && ');
         if (schema.unevaluatedProperties === false) {
-            const keyCheck = CreateVariable(`${new RegExp((0, index_8.KeyOfPattern)(schema))};`);
+            const keyCheck = CreateVariable(`${new RegExp((0, index_9.KeyOfPattern)(schema))};`);
             const check2 = `Object.getOwnPropertyNames(${value}).every(key => ${keyCheck}.test(key))`;
             yield `(${check1} && ${check2})`;
         }
         else if ((0, type_1.IsSchema)(schema.unevaluatedProperties)) {
-            const keyCheck = CreateVariable(`${new RegExp((0, index_8.KeyOfPattern)(schema))};`);
+            const keyCheck = CreateVariable(`${new RegExp((0, index_9.KeyOfPattern)(schema))};`);
             const check2 = `Object.getOwnPropertyNames(${value}).every(key => ${keyCheck}.test(key) || ${CreateExpression(schema.unevaluatedProperties, references, `${value}[key]`)})`;
             yield `(${check1} && ${check2})`;
         }
@@ -313,22 +314,22 @@ var TypeCompiler;
     }
     function* FromNumber(schema, references, value) {
         yield Policy.IsNumberLike(value);
-        if ((0, index_10.IsNumber)(schema.exclusiveMaximum))
+        if ((0, index_11.IsNumber)(schema.exclusiveMaximum))
             yield `${value} < ${schema.exclusiveMaximum}`;
-        if ((0, index_10.IsNumber)(schema.exclusiveMinimum))
+        if ((0, index_11.IsNumber)(schema.exclusiveMinimum))
             yield `${value} > ${schema.exclusiveMinimum}`;
-        if ((0, index_10.IsNumber)(schema.maximum))
+        if ((0, index_11.IsNumber)(schema.maximum))
             yield `${value} <= ${schema.maximum}`;
-        if ((0, index_10.IsNumber)(schema.minimum))
+        if ((0, index_11.IsNumber)(schema.minimum))
             yield `${value} >= ${schema.minimum}`;
-        if ((0, index_10.IsNumber)(schema.multipleOf))
+        if ((0, index_11.IsNumber)(schema.multipleOf))
             yield `(${value} % ${schema.multipleOf}) === 0`;
     }
     function* FromObject(schema, references, value) {
         yield Policy.IsObjectLike(value);
-        if ((0, index_10.IsNumber)(schema.minProperties))
+        if ((0, index_11.IsNumber)(schema.minProperties))
             yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`;
-        if ((0, index_10.IsNumber)(schema.maxProperties))
+        if ((0, index_11.IsNumber)(schema.maxProperties))
             yield `Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties}`;
         const knownKeys = Object.getOwnPropertyNames(schema.properties);
         for (const knownKey of knownKeys) {
@@ -364,9 +365,9 @@ var TypeCompiler;
     }
     function* FromRecord(schema, references, value) {
         yield Policy.IsRecordLike(value);
-        if ((0, index_10.IsNumber)(schema.minProperties))
+        if ((0, index_11.IsNumber)(schema.minProperties))
             yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`;
-        if ((0, index_10.IsNumber)(schema.maxProperties))
+        if ((0, index_11.IsNumber)(schema.maxProperties))
             yield `Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties}`;
         const [patternKey, patternSchema] = Object.entries(schema.patternProperties)[0];
         const variable = CreateVariable(`${new RegExp(patternKey)}`);
@@ -376,7 +377,7 @@ var TypeCompiler;
         yield `(Object.entries(${value}).every(([key, value]) => ${expression}))`;
     }
     function* FromRef(schema, references, value) {
-        const target = (0, index_4.Deref)(schema, references);
+        const target = (0, index_5.Deref)(schema, references);
         // Reference: If we have seen this reference before we can just yield and return the function call.
         // If this isn't the case we defer to visit to generate and set the function for subsequent passes.
         if (state.functions.has(schema.$ref))
@@ -385,9 +386,9 @@ var TypeCompiler;
     }
     function* FromString(schema, references, value) {
         yield `(typeof ${value} === 'string')`;
-        if ((0, index_10.IsNumber)(schema.maxLength))
+        if ((0, index_11.IsNumber)(schema.maxLength))
             yield `${value}.length <= ${schema.maxLength}`;
-        if ((0, index_10.IsNumber)(schema.minLength))
+        if ((0, index_11.IsNumber)(schema.minLength))
             yield `${value}.length >= ${schema.minLength}`;
         if (schema.pattern !== undefined) {
             const variable = CreateVariable(`${new RegExp(schema.pattern)};`);
@@ -428,9 +429,9 @@ var TypeCompiler;
     }
     function* FromUint8Array(schema, references, value) {
         yield `${value} instanceof Uint8Array`;
-        if ((0, index_10.IsNumber)(schema.maxByteLength))
+        if ((0, index_11.IsNumber)(schema.maxByteLength))
             yield `(${value}.length <= ${schema.maxByteLength})`;
-        if ((0, index_10.IsNumber)(schema.minByteLength))
+        if ((0, index_11.IsNumber)(schema.minByteLength))
             yield `(${value}.length >= ${schema.minByteLength})`;
     }
     function* FromUnknown(schema, references, value) {
@@ -442,15 +443,15 @@ var TypeCompiler;
     function* FromKind(schema, references, value) {
         const instance = state.instances.size;
         state.instances.set(instance, schema);
-        yield `kind('${schema[index_6.Kind]}', ${instance}, ${value})`;
+        yield `kind('${schema[index_7.Kind]}', ${instance}, ${value})`;
     }
     function* Visit(schema, references, value, useHoisting = true) {
-        const references_ = (0, index_10.IsString)(schema.$id) ? [...references, schema] : references;
+        const references_ = (0, index_11.IsString)(schema.$id) ? [...references, schema] : references;
         const schema_ = schema;
         // --------------------------------------------------------------
         // Hoisting
         // --------------------------------------------------------------
-        if (useHoisting && (0, index_10.IsString)(schema.$id)) {
+        if (useHoisting && (0, index_11.IsString)(schema.$id)) {
             const functionName = CreateFunctionName(schema.$id);
             if (state.functions.has(functionName)) {
                 return yield `${functionName}(${value})`;
@@ -461,7 +462,7 @@ var TypeCompiler;
                 return yield `${functionName}(${value})`;
             }
         }
-        switch (schema_[index_6.Kind]) {
+        switch (schema_[index_7.Kind]) {
             case 'Any':
                 return yield* FromAny(schema_, references_, value);
             case 'Array':
@@ -523,7 +524,7 @@ var TypeCompiler;
             case 'Void':
                 return yield* FromVoid(schema_, references_, value);
             default:
-                if (!index_7.TypeRegistry.Has(schema_[index_6.Kind]))
+                if (!index_8.TypeRegistry.Has(schema_[index_7.Kind]))
                     throw new TypeCompilerUnknownTypeError(schema);
                 return yield* FromKind(schema_, references_, value);
         }
@@ -576,7 +577,7 @@ var TypeCompiler;
         const functions = [...state.functions.values()];
         const variables = [...state.variables.values()];
         // prettier-ignore
-        const checkFunction = (0, index_10.IsString)(schema.$id) // ensure top level schemas with $id's are hoisted
+        const checkFunction = (0, index_11.IsString)(schema.$id) // ensure top level schemas with $id's are hoisted
             ? `return function check(${parameter})${returns} {\n  return ${CreateFunctionName(schema.$id)}(value)\n}`
             : `return ${functionCode}`;
         return [...variables, ...functions, checkFunction].join('\n');
@@ -585,8 +586,8 @@ var TypeCompiler;
     function Code(...args) {
         const defaults = { language: 'javascript' };
         // prettier-ignore
-        const [schema, references, options] = (args.length === 2 && (0, index_10.IsArray)(args[1]) ? [args[0], args[1], defaults] :
-            args.length === 2 && !(0, index_10.IsArray)(args[1]) ? [args[0], [], args[1]] :
+        const [schema, references, options] = (args.length === 2 && (0, index_11.IsArray)(args[1]) ? [args[0], args[1], defaults] :
+            args.length === 2 && !(0, index_11.IsArray)(args[1]) ? [args[0], [], args[1]] :
                 args.length === 3 ? [args[0], args[1], args[2]] :
                     args.length === 1 ? [args[0], [], defaults] :
                         [null, [], defaults]);
@@ -609,20 +610,20 @@ var TypeCompiler;
         const compiledFunction = globalThis.Function('kind', 'format', 'hash', generatedCode);
         const instances = new Map(state.instances);
         function typeRegistryFunction(kind, instance, value) {
-            if (!index_7.TypeRegistry.Has(kind) || !instances.has(instance))
+            if (!index_8.TypeRegistry.Has(kind) || !instances.has(instance))
                 return false;
-            const checkFunc = index_7.TypeRegistry.Get(kind);
+            const checkFunc = index_8.TypeRegistry.Get(kind);
             const schema = instances.get(instance);
             return checkFunc(schema, value);
         }
         function formatRegistryFunction(format, value) {
-            if (!index_7.FormatRegistry.Has(format))
+            if (!index_8.FormatRegistry.Has(format))
                 return false;
-            const checkFunc = index_7.FormatRegistry.Get(format);
+            const checkFunc = index_8.FormatRegistry.Get(format);
             return checkFunc(value);
         }
         function hashFunction(value) {
-            return (0, index_5.Hash)(value);
+            return (0, index_6.Hash)(value);
         }
         const checkFunction = compiledFunction(typeRegistryFunction, formatRegistryFunction, hashFunction);
         return new TypeCheck(schema, references, checkFunction, generatedCode);

package/build/require/errors/errors.d.ts

@@ -1,3 +1,4 @@
+import { TypeBoxError } from '../type/error/index';
 import type { TSchema } from '../type/schema/index';
 export declare enum ValueErrorType {
     ArrayContains = 0,
@@ -71,7 +72,7 @@ export interface ValueError {
     value: unknown;
     message: string;
 }
-export declare class ValueErrorsUnknownTypeError extends Error {
+export declare class ValueErrorsUnknownTypeError extends TypeBoxError {
     readonly schema: TSchema;
     constructor(schema: TSchema);
 }