@sinclair/typebox 0.25.9 → 0.25.10

package/compiler/compiler.d.ts

@@ -1,6 +1,6 @@
 import { ValueError } from '../errors/index';
 import * as Types from '../typebox';
-export declare type CheckFunction = (value: unknown) => boolean;
+export type CheckFunction = (value: unknown) => boolean;
 export declare class TypeCheck<T extends Types.TSchema> {
     private readonly schema;
     private readonly references;

package/compiler/compiler.js

@@ -237,11 +237,11 @@ var TypeCompiler;
         // 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. Consider for refactor.
-        if (names.has(schema.$ref))
+        if (state_local_function_names.has(schema.$ref))
             return yield `(${CreateFunctionName(schema.$ref)}(${value}))`;
-        if (!referenceMap.has(schema.$ref))
+        if (!state_reference_map.has(schema.$ref))
             throw Error(`TypeCompiler.Ref: Cannot de-reference schema with $id '${schema.$ref}'`);
-        const reference = referenceMap.get(schema.$ref);
+        const reference = state_reference_map.get(schema.$ref);
         yield* Visit(reference, value);
     }
     function* Self(schema, value) {
@@ -292,15 +292,17 @@ var TypeCompiler;
     function* Void(schema, value) {
         yield `(${value} === null)`;
     }
-    function* Kind(schema, value) {
-        yield `(custom('${schema[Types.Kind]}', ${value}))`;
+    function* UserDefined(schema, value) {
+        const schema_key = `schema_key_${state_remote_custom_types.size}`;
+        state_remote_custom_types.set(schema_key, schema);
+        yield `(custom('${schema[Types.Kind]}', '${schema_key}', ${value}))`;
     }
     function* Visit(schema, value) {
         // Reference: Referenced schemas can originate from either additional schemas
         // or inline in the schema itself. Ideally the recursive path should align to
         // reference path. Consider for refactor.
-        if (schema.$id && !names.has(schema.$id)) {
-            names.add(schema.$id);
+        if (schema.$id && !state_local_function_names.has(schema.$id)) {
+            state_local_function_names.add(schema.$id);
             const name = CreateFunctionName(schema.$id);
             const body = CreateFunction(name, schema, 'value');
             PushFunction(body);
@@ -358,27 +360,29 @@ var TypeCompiler;
             default:
                 if (!index_4.Custom.Has(anySchema[Types.Kind]))
                     throw new TypeCompilerUnknownTypeError(schema);
-                return yield* Kind(anySchema, value);
+                return yield* UserDefined(anySchema, value);
         }
     }
     // -------------------------------------------------------------------
-    // Compile State
+    // Compiler State
     // -------------------------------------------------------------------
-    const referenceMap = new Map();
-    const locals = new Set(); // local variables and functions
-    const names = new Set(); // cache of local functions
+    const state_reference_map = new Map(); // tracks schemas with identifiers
+    const state_local_variables = new Set(); // local variables and functions
+    const state_local_function_names = new Set(); // local function names used call ref validators
+    const state_remote_custom_types = new Map(); // remote custom types used during compilation
     function ResetCompiler() {
-        referenceMap.clear();
-        locals.clear();
-        names.clear();
+        state_reference_map.clear();
+        state_local_variables.clear();
+        state_local_function_names.clear();
+        state_remote_custom_types.clear();
     }
     function AddReferences(schemas = []) {
         for (const schema of schemas) {
             if (!schema.$id)
                 throw new Error(`TypeCompiler: Referenced schemas must specify an $id.`);
-            if (referenceMap.has(schema.$id))
+            if (state_reference_map.has(schema.$id))
                 throw new Error(`TypeCompiler: Duplicate schema $id found for '${schema.$id}'`);
-            referenceMap.set(schema.$id, schema);
+            state_reference_map.set(schema.$id, schema);
         }
     }
     function CreateExpression(schema, value) {
@@ -392,15 +396,15 @@ var TypeCompiler;
         return `function ${name}(value) {\n  return (\n${expression}\n )\n}`;
     }
     function PushFunction(functionBody) {
-        locals.add(functionBody);
+        state_local_variables.add(functionBody);
     }
     function PushLocal(expression) {
-        const local = `local_${locals.size}`;
-        locals.add(`const ${local} = ${expression}`);
+        const local = `local_${state_local_variables.size}`;
+        state_local_variables.add(`const ${local} = ${expression}`);
         return local;
     }
     function GetLocals() {
-        return [...locals.values()];
+        return [...state_local_variables.values()];
     }
     // -------------------------------------------------------------------
     // Compile
@@ -416,12 +420,14 @@ var TypeCompiler;
     function Compile(schema, references = []) {
         index_2.TypeGuard.Assert(schema, references);
         const code = Build(schema, references);
+        const custom_schemas = new Map(state_remote_custom_types);
         const compiledFunction = globalThis.Function('custom', 'format', code);
-        const checkFunction = compiledFunction((kind, value) => {
-            if (!index_4.Custom.Has(kind))
+        const checkFunction = compiledFunction((kind, schema_key, value) => {
+            if (!index_4.Custom.Has(kind) || !custom_schemas.has(schema_key))
                 return false;
+            const schema = custom_schemas.get(schema_key);
             const func = index_4.Custom.Get(kind);
-            return func(value);
+            return func(schema, value);
         }, (format, value) => {
             if (!index_3.Format.Has(format))
                 return false;

package/conditional/conditional.d.ts

@@ -1,5 +1,5 @@
 import * as Types from '../typebox';
-export declare type TExtends<L extends Types.TSchema, R extends Types.TSchema, T extends Types.TSchema, U extends Types.TSchema> = Types.Static<L> extends Types.Static<R> ? T : U;
+export type TExtends<L extends Types.TSchema, R extends Types.TSchema, T extends Types.TSchema, U extends Types.TSchema> = Types.Static<L> extends Types.Static<R> ? T : U;
 export interface TExclude<T extends Types.TUnion, U extends Types.TUnion> extends Types.TUnion<any[]> {
     static: Exclude<Types.Static<T, this['params']>, Types.Static<U, this['params']>>;
 }

package/conditional/structural.js

@@ -57,7 +57,7 @@ var Structural;
             return true;
         if (guard_1.TypeGuard.TAny(right))
             return true;
-        if (guard_1.TypeGuard.TCustom(right))
+        if (guard_1.TypeGuard.TUserDefined(right))
             throw Error(`Structural: Cannot structurally compare custom type '${right[Types.Kind]}'`);
         return false;
     }
@@ -668,7 +668,7 @@ var Structural;
         else if (guard_1.TypeGuard.TVoid(left)) {
             return Void(left, resolvedRight);
         }
-        else if (guard_1.TypeGuard.TCustom(left)) {
+        else if (guard_1.TypeGuard.TUserDefined(left)) {
             throw Error(`Structural: Cannot structurally compare custom type '${left[Types.Kind]}'`);
         }
         else {

package/custom/custom.d.ts

@@ -1,12 +1,12 @@
-export declare type CustomValidationFunction = (value: unknown) => boolean;
-/** Provides functions to create custom types */
+export type CustomValidationFunction<TSchema> = (schema: TSchema, value: unknown) => boolean;
+/** Provides functions to create user defined types */
 export declare namespace Custom {
-    /** Clears all custom types */
+    /** Clears all user defined types */
     function Clear(): void;
-    /** Returns true if this kind exists */
+    /** Returns true if this user defined type exists */
     function Has(kind: string): boolean;
-    /** Sets a validation function for a custom kind */
-    function Set(kind: string, func: CustomValidationFunction): void;
-    /** Gets a custom validation function */
-    function Get(kind: string): CustomValidationFunction | undefined;
+    /** Sets a validation function for a user defined type */
+    function Set<TSchema = unknown>(kind: string, func: CustomValidationFunction<TSchema>): void;
+    /** Gets a custom validation function for a user defined type */
+    function Get(kind: string): CustomValidationFunction<any> | undefined;
 }

package/custom/custom.js

@@ -28,26 +28,26 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Custom = void 0;
-/** Provides functions to create custom types */
+/** Provides functions to create user defined types */
 var Custom;
 (function (Custom) {
     const customs = new Map();
-    /** Clears all custom types */
+    /** Clears all user defined types */
     function Clear() {
         return customs.clear();
     }
     Custom.Clear = Clear;
-    /** Returns true if this kind exists */
+    /** Returns true if this user defined type exists */
     function Has(kind) {
         return customs.has(kind);
     }
     Custom.Has = Has;
-    /** Sets a validation function for a custom kind */
+    /** Sets a validation function for a user defined type */
     function Set(kind, func) {
         customs.set(kind, func);
     }
     Custom.Set = Set;
-    /** Gets a custom validation function */
+    /** Gets a custom validation function for a user defined type */
     function Get(kind) {
         return customs.get(kind);
     }

package/errors/errors.js

@@ -367,9 +367,9 @@ var ValueErrors;
             return yield { type: ValueErrorType.Void, schema, path, value, message: `Expected null` };
         }
     }
-    function* CustomType(schema, references, path, value) {
+    function* UserDefined(schema, references, path, value) {
         const func = index_2.Custom.Get(schema[Types.Kind]);
-        if (!func(value)) {
+        if (!func(schema, value)) {
             return yield { type: ValueErrorType.Custom, schema, path, value, message: `Expected kind ${schema[Types.Kind]}` };
         }
     }
@@ -426,7 +426,7 @@ var ValueErrors;
             default:
                 if (!index_2.Custom.Has(anySchema[Types.Kind]))
                     throw new ValueErrorsUnknownTypeError(schema);
-                return yield* CustomType(anySchema, anyReferences, path, value);
+                return yield* UserDefined(anySchema, anyReferences, path, value);
         }
     }
     function* Errors(schema, references, value) {

package/format/format.d.ts

@@ -1,12 +1,12 @@
-export declare type FormatValidationFunction = (value: string) => boolean;
-/** Provides functions to create custom string formats */
+export type FormatValidationFunction = (value: string) => boolean;
+/** Provides functions to create user defined string formats */
 export declare namespace Format {
-    /** Clears all formats */
+    /** Clears all user defined string formats */
     function Clear(): void;
-    /** Returns true if the string format exists */
+    /** Returns true if the user defined string format exists */
     function Has(format: string): boolean;
-    /** Sets a string format validation function */
+    /** Sets a validation function for a user defined string format */
     function Set(format: string, func: FormatValidationFunction): void;
-    /** Gets a string format validation function */
+    /** Gets a validation function for a user defined string format */
     function Get(format: string): FormatValidationFunction | undefined;
 }

package/format/format.js

@@ -28,26 +28,26 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Format = void 0;
-/** Provides functions to create custom string formats */
+/** Provides functions to create user defined string formats */
 var Format;
 (function (Format) {
     const formats = new Map();
-    /** Clears all formats */
+    /** Clears all user defined string formats */
     function Clear() {
         return formats.clear();
     }
     Format.Clear = Clear;
-    /** Returns true if the string format exists */
+    /** Returns true if the user defined string format exists */
     function Has(format) {
         return formats.has(format);
     }
     Format.Has = Has;
-    /** Sets a string format validation function */
+    /** Sets a validation function for a user defined string format */
     function Set(format, func) {
         formats.set(format, func);
     }
     Format.Set = Set;
-    /** Gets a string format validation function */
+    /** Gets a validation function for a user defined string format */
     function Get(format) {
         return formats.get(format);
     }

package/guard/guard.d.ts

@@ -51,8 +51,8 @@ export declare namespace TypeGuard {
     function TUnknown(schema: unknown): schema is Types.TUnknown;
     /** Returns true if the given schema is TVoid */
     function TVoid(schema: unknown): schema is Types.TVoid;
-    /** Returns true if the given schema is a registered custom type */
-    function TCustom(schema: unknown): schema is Types.TSchema;
+    /** Returns true if the given schema is a registered user defined type */
+    function TUserDefined(schema: unknown): schema is Types.TSchema;
     /** Returns true if the given schema is TSchema */
     function TSchema(schema: unknown): schema is Types.TSchema;
     /** Asserts if this schema and associated references are valid. */

package/guard/guard.js

@@ -394,11 +394,11 @@ var TypeGuard;
             IsOptionalString(schema.$id));
     }
     TypeGuard.TVoid = TVoid;
-    /** Returns true if the given schema is a registered custom type */
-    function TCustom(schema) {
+    /** Returns true if the given schema is a registered user defined type */
+    function TUserDefined(schema) {
         return IsObject(schema) && IsString(schema[Types.Kind]) && index_1.Custom.Has(schema[Types.Kind]);
     }
-    TypeGuard.TCustom = TCustom;
+    TypeGuard.TUserDefined = TUserDefined;
     /** Returns true if the given schema is TSchema */
     function TSchema(schema) {
         return (TAny(schema) ||
@@ -424,7 +424,7 @@ var TypeGuard;
             TUint8Array(schema) ||
             TUnknown(schema) ||
             TVoid(schema) ||
-            TCustom(schema));
+            TUserDefined(schema));
     }
     TypeGuard.TSchema = TSchema;
     /** Asserts if this schema and associated references are valid. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.25.9",
+  "version": "0.25.10",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
@@ -39,12 +39,12 @@
     "@sinclair/hammer": "^0.17.1",
     "@types/chai": "^4.3.3",
     "@types/mocha": "^9.1.1",
-    "@types/node": "^18.7.13",
-    "ajv": "^8.11.0",
+    "@types/node": "^18.11.9",
+    "ajv": "^8.11.2",
     "ajv-formats": "^2.1.1",
     "chai": "^4.3.6",
     "mocha": "^9.2.2",
     "prettier": "^2.7.1",
-    "typescript": "^4.8.2"
+    "typescript": "^4.9.3"
   }
 }

package/readme.md

@@ -97,8 +97,8 @@ License MIT
 - [TypeCheck](#typecheck)
   - [Ajv](#typecheck-ajv)
   - [TypeCompiler](#typecheck-typecompiler)
-  - [Custom](#typecheck-custom)
-  - [Formats](#typecheck-formats)
+  - [Custom Types](#typecheck-custom-types)
+  - [Custom Formats](#typecheck-custom-formats)
 - [Benchmark](#benchmark)
   - [Compile](#benchmark-compile)
   - [Validate](#benchmark-validate)
@@ -1118,11 +1118,11 @@ console.log(C.Code())                                // return function check(va
                                                      // }
 ```
 
-<a name='typecheck-custom'></a>
+<a name='typecheck-custom-types'></a>
 
-### Custom
+### Custom Types
 
-Use custom module to create a custom types. When creating a custom type you must specify a `Kind` symbol property on the types schema. The `Kind` symbol property should match the name used to register the type. Custom types are used by the Value and TypeCompiler modules only.
+Use the custom module to create user defined types. User defined types require a `[Kind]` symbol property which is used to match the schema against a registered type. Custom types are specific to TypeBox and can only be used with the TypeCompiler and Value modules.
 
 The custom module is an optional import.
 
@@ -1130,23 +1130,27 @@ The custom module is an optional import.
 import { Custom } from '@sinclair/typebox/custom'
 ```
 
-The following registers a BigInt custom type.
+The following creates a `BigInt` type.
 
 ```typescript
 import { Type, Kind } from '@sinclair/typebox'
 
-Custom.Set('BigInt', value => typeof value === 'bigint')
-
+Custom.Set('BigInt', (schema, value) => typeof value === 'bigint')
+//            │
+//            └────────────────────────────┐         The [Kind] is used to match registered type
+//                                         │
 const T = Type.Unsafe<bigint>({ [Kind]: 'BigInt' })  // const T = { [Kind]: 'BigInt' }
 
-const R = Value.Check(T, 65536n)                     // const R = true
+const A = TypeCompiler.Compile(T).Check(65536)       // const A = false
+
+const B = Value.Check(T, 65536n)                     // const B = true
 ```
 
-<a name='typecheck-formats'></a>
+<a name='typecheck-custom-formats'></a>
 
-### Formats
+### Custom Formats
 
-Use the format module to create user defined string formats. The format module is used by the Value and TypeCompiler modules only. If using Ajv, please refer to the official Ajv format documentation located [here](https://ajv.js.org/guide/formats.html).
+Use the format module to create user defined string formats. If using Ajv, please refer to the official Ajv format documentation located [here](https://ajv.js.org/guide/formats.html). The format module is specific to TypeBox can only be used with the TypeCompiler and Value modules.
 
 The format module is an optional import.
 
@@ -1154,7 +1158,7 @@ The format module is an optional import.
 import { Format } from '@sinclair/typebox/format'
 ```
 
-The following creates a `palindrome` string format.
+The following creates a palindrome string format.
 
 ```typescript
 Format.Set('palindrome', value => value === value.split('').reverse().join(''))
@@ -1174,7 +1178,7 @@ const B = Value.Check(T, 'kayak')                    // const B = true
 
 ## Benchmark
 
-This project maintains a set of benchmarks that measure Ajv, Value and TypeCompiler compilation and validation performance. These benchmarks can be run locally by cloning this repository and running `npm run benchmark`. The results below show for Ajv version 8.11.0. 
+This project maintains a set of benchmarks that measure Ajv, Value and TypeCompiler compilation and validation performance. These benchmarks can be run locally by cloning this repository and running `npm run benchmark`. The results below show for Ajv version 8.11.2. 
 
 For additional comparative benchmarks, please refer to [typescript-runtime-type-benchmarks](https://moltar.github.io/typescript-runtime-type-benchmarks/).
 
@@ -1188,29 +1192,29 @@ This benchmark measures compilation performance for varying types. You can revie
 ┌──────────────────┬────────────┬──────────────┬──────────────┬──────────────┐
 │     (index)      │ Iterations │     Ajv      │ TypeCompiler │ Performance  │
 ├──────────────────┼────────────┼──────────────┼──────────────┼──────────────┤
-│           Number │    2000    │ '    427 ms' │ '     13 ms' │ '   32.85 x' │
-│           String │    2000    │ '    367 ms' │ '     12 ms' │ '   30.58 x' │
-│          Boolean │    2000    │ '    297 ms' │ '     13 ms' │ '   22.85 x' │
-│             Null │    2000    │ '    255 ms' │ '      9 ms' │ '   28.33 x' │
-│            RegEx │    2000    │ '    487 ms' │ '     17 ms' │ '   28.65 x' │
-│          ObjectA │    2000    │ '   2718 ms' │ '     53 ms' │ '   51.28 x' │
-│          ObjectB │    2000    │ '   2874 ms' │ '     36 ms' │ '   79.83 x' │
-│            Tuple │    2000    │ '   1221 ms' │ '     22 ms' │ '   55.50 x' │
-│            Union │    2000    │ '   1223 ms' │ '     24 ms' │ '   50.96 x' │
-│          Vector4 │    2000    │ '   1517 ms' │ '     21 ms' │ '   72.24 x' │
+│           Number │    2000    │ '    414 ms' │ '     14 ms' │ '   29.57 x' │
+│           String │    2000    │ '    326 ms' │ '     12 ms' │ '   27.17 x' │
+│          Boolean │    2000    │ '    301 ms' │ '     11 ms' │ '   27.36 x' │
+│             Null │    2000    │ '    253 ms' │ '      8 ms' │ '   31.63 x' │
+│            RegEx │    2000    │ '    480 ms' │ '     18 ms' │ '   26.67 x' │
+│          ObjectA │    2000    │ '   2704 ms' │ '     53 ms' │ '   51.02 x' │
+│          ObjectB │    2000    │ '   2846 ms' │ '     35 ms' │ '   81.31 x' │
+│            Tuple │    2000    │ '   1244 ms' │ '     23 ms' │ '   54.09 x' │
+│            Union │    2000    │ '   1222 ms' │ '     26 ms' │ '   47.00 x' │
+│          Vector4 │    2000    │ '   1522 ms' │ '     22 ms' │ '   69.18 x' │
 │          Matrix4 │    2000    │ '    830 ms' │ '     10 ms' │ '   83.00 x' │
-│   Literal_String │    2000    │ '    334 ms' │ '      8 ms' │ '   41.75 x' │
-│   Literal_Number │    2000    │ '    357 ms' │ '      6 ms' │ '   59.50 x' │
-│  Literal_Boolean │    2000    │ '    353 ms' │ '      7 ms' │ '   50.43 x' │
-│     Array_Number │    2000    │ '    679 ms' │ '     11 ms' │ '   61.73 x' │
-│     Array_String │    2000    │ '    713 ms' │ '     10 ms' │ '   71.30 x' │
-│    Array_Boolean │    2000    │ '    710 ms' │ '      7 ms' │ '  101.43 x' │
-│    Array_ObjectA │    2000    │ '   3571 ms' │ '     35 ms' │ '  102.03 x' │
-│    Array_ObjectB │    2000    │ '   3567 ms' │ '     41 ms' │ '   87.00 x' │
-│      Array_Tuple │    2000    │ '   2083 ms' │ '     19 ms' │ '  109.63 x' │
-│      Array_Union │    2000    │ '   1559 ms' │ '     23 ms' │ '   67.78 x' │
-│    Array_Vector4 │    2000    │ '   2156 ms' │ '     19 ms' │ '  113.47 x' │
-│    Array_Matrix4 │    2000    │ '   1483 ms' │ '     13 ms' │ '  114.08 x' │
+│   Literal_String │    2000    │ '    348 ms' │ '      9 ms' │ '   38.67 x' │
+│   Literal_Number │    2000    │ '    356 ms' │ '      9 ms' │ '   39.56 x' │
+│  Literal_Boolean │    2000    │ '    353 ms' │ '      6 ms' │ '   58.83 x' │
+│     Array_Number │    2000    │ '    686 ms' │ '     11 ms' │ '   62.36 x' │
+│     Array_String │    2000    │ '    722 ms' │ '     11 ms' │ '   65.64 x' │
+│    Array_Boolean │    2000    │ '    724 ms' │ '      9 ms' │ '   80.44 x' │
+│    Array_ObjectA │    2000    │ '   3706 ms' │ '     36 ms' │ '  102.94 x' │
+│    Array_ObjectB │    2000    │ '   3678 ms' │ '     38 ms' │ '   96.79 x' │
+│      Array_Tuple │    2000    │ '   2217 ms' │ '     23 ms' │ '   96.39 x' │
+│      Array_Union │    2000    │ '   1654 ms' │ '     24 ms' │ '   68.92 x' │
+│    Array_Vector4 │    2000    │ '   2283 ms' │ '     20 ms' │ '  114.15 x' │
+│    Array_Matrix4 │    2000    │ '   1567 ms' │ '     19 ms' │ '   82.47 x' │
 └──────────────────┴────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1224,31 +1228,31 @@ This benchmark measures validation performance for varying types. You can review
 ┌──────────────────┬────────────┬──────────────┬──────────────┬──────────────┬──────────────┐
 │     (index)      │ Iterations │  ValueCheck  │     Ajv      │ TypeCompiler │ Performance  │
 ├──────────────────┼────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
-│           Number │  1000000   │ '     25 ms' │ '      6 ms' │ '      5 ms' │ '    1.20 x' │
-│           String │  1000000   │ '     22 ms' │ '     20 ms' │ '     11 ms' │ '    1.82 x' │
-│          Boolean │  1000000   │ '     21 ms' │ '     20 ms' │ '     10 ms' │ '    2.00 x' │
-│             Null │  1000000   │ '     24 ms' │ '     21 ms' │ '      9 ms' │ '    2.33 x' │
-│            RegEx │  1000000   │ '    158 ms' │ '     46 ms' │ '     37 ms' │ '    1.24 x' │
-│          ObjectA │  1000000   │ '    566 ms' │ '     36 ms' │ '     24 ms' │ '    1.50 x' │
-│          ObjectB │  1000000   │ '   1026 ms' │ '     52 ms' │ '     40 ms' │ '    1.30 x' │
-│            Tuple │  1000000   │ '    121 ms' │ '     23 ms' │ '     14 ms' │ '    1.64 x' │
-│            Union │  1000000   │ '    299 ms' │ '     26 ms' │ '     16 ms' │ '    1.63 x' │
-│        Recursive │  1000000   │ '   3168 ms' │ '    414 ms' │ '     97 ms' │ '    4.27 x' │
-│          Vector4 │  1000000   │ '    147 ms' │ '     22 ms' │ '     11 ms' │ '    2.00 x' │
-│          Matrix4 │  1000000   │ '    573 ms' │ '     40 ms' │ '     29 ms' │ '    1.38 x' │
-│   Literal_String │  1000000   │ '     48 ms' │ '     19 ms' │ '     10 ms' │ '    1.90 x' │
-│   Literal_Number │  1000000   │ '     46 ms' │ '     20 ms' │ '     10 ms' │ '    2.00 x' │
-│  Literal_Boolean │  1000000   │ '     48 ms' │ '     20 ms' │ '     10 ms' │ '    2.00 x' │
-│     Array_Number │  1000000   │ '    454 ms' │ '     32 ms' │ '     18 ms' │ '    1.78 x' │
-│     Array_String │  1000000   │ '    481 ms' │ '     32 ms' │ '     22 ms' │ '    1.45 x' │
-│    Array_Boolean │  1000000   │ '    448 ms' │ '     34 ms' │ '     27 ms' │ '    1.26 x' │
-│    Array_ObjectA │  1000000   │ '  13709 ms' │ '   2360 ms' │ '   1548 ms' │ '    1.52 x' │
-│    Array_ObjectB │  1000000   │ '  16602 ms' │ '   2585 ms' │ '   1904 ms' │ '    1.36 x' │
-│      Array_Tuple │  1000000   │ '   1831 ms' │ '     96 ms' │ '     63 ms' │ '    1.52 x' │
-│      Array_Union │  1000000   │ '   4958 ms' │ '    234 ms' │ '     86 ms' │ '    2.72 x' │
-│  Array_Recursive │  1000000   │ '  55876 ms' │ '   7160 ms' │ '   1138 ms' │ '    6.29 x' │
-│    Array_Vector4 │  1000000   │ '   2381 ms' │ '     99 ms' │ '     47 ms' │ '    2.11 x' │
-│    Array_Matrix4 │  1000000   │ '  11670 ms' │ '    383 ms' │ '    228 ms' │ '    1.68 x' │
+│           Number │  1000000   │ '     33 ms' │ '      6 ms' │ '      5 ms' │ '    1.20 x' │
+│           String │  1000000   │ '     26 ms' │ '     24 ms' │ '     12 ms' │ '    2.00 x' │
+│          Boolean │  1000000   │ '     24 ms' │ '     22 ms' │ '     11 ms' │ '    2.00 x' │
+│             Null │  1000000   │ '     28 ms' │ '     24 ms' │ '     11 ms' │ '    2.18 x' │
+│            RegEx │  1000000   │ '    171 ms' │ '     56 ms' │ '     41 ms' │ '    1.37 x' │
+│          ObjectA │  1000000   │ '    614 ms' │ '     42 ms' │ '     24 ms' │ '    1.75 x' │
+│          ObjectB │  1000000   │ '   1109 ms' │ '     59 ms' │ '     45 ms' │ '    1.31 x' │
+│            Tuple │  1000000   │ '    122 ms' │ '     25 ms' │ '     13 ms' │ '    1.92 x' │
+│            Union │  1000000   │ '    316 ms' │ '     26 ms' │ '     16 ms' │ '    1.63 x' │
+│        Recursive │  1000000   │ '   3219 ms' │ '    453 ms' │ '    128 ms' │ '    3.54 x' │
+│          Vector4 │  1000000   │ '    145 ms' │ '     26 ms' │ '     13 ms' │ '    2.00 x' │
+│          Matrix4 │  1000000   │ '    537 ms' │ '     42 ms' │ '     28 ms' │ '    1.50 x' │
+│   Literal_String │  1000000   │ '     51 ms' │ '     21 ms' │ '     11 ms' │ '    1.91 x' │
+│   Literal_Number │  1000000   │ '     48 ms' │ '     20 ms' │ '     11 ms' │ '    1.82 x' │
+│  Literal_Boolean │  1000000   │ '     49 ms' │ '     20 ms' │ '     11 ms' │ '    1.82 x' │
+│     Array_Number │  1000000   │ '    438 ms' │ '     35 ms' │ '     19 ms' │ '    1.84 x' │
+│     Array_String │  1000000   │ '    468 ms' │ '     33 ms' │ '     23 ms' │ '    1.43 x' │
+│    Array_Boolean │  1000000   │ '    448 ms' │ '     36 ms' │ '     29 ms' │ '    1.24 x' │
+│    Array_ObjectA │  1000000   │ '  13904 ms' │ '   2536 ms' │ '   1530 ms' │ '    1.66 x' │
+│    Array_ObjectB │  1000000   │ '  16188 ms' │ '   2724 ms' │ '   1834 ms' │ '    1.49 x' │
+│      Array_Tuple │  1000000   │ '   1725 ms' │ '     98 ms' │ '     64 ms' │ '    1.53 x' │
+│      Array_Union │  1000000   │ '   4762 ms' │ '    237 ms' │ '     87 ms' │ '    2.72 x' │
+│  Array_Recursive │  1000000   │ '  54754 ms' │ '   7707 ms' │ '   1152 ms' │ '    6.69 x' │
+│    Array_Vector4 │  1000000   │ '   2485 ms' │ '    100 ms' │ '     48 ms' │ '    2.08 x' │
+│    Array_Matrix4 │  1000000   │ '  13116 ms' │ '    387 ms' │ '    232 ms' │ '    1.67 x' │
 └──────────────────┴────────────┴──────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1262,12 +1266,12 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │       (index)        │  Compiled  │  Minified  │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '   55 kb' │ '   27 kb' │  '2.00 x'   │
+│ typebox/compiler     │ '   56 kb' │ '   28 kb' │  '2.01 x'   │
 │ typebox/conditional  │ '   45 kb' │ '   18 kb' │  '2.44 x'   │
 │ typebox/custom       │ '    0 kb' │ '    0 kb' │  '2.61 x'   │
 │ typebox/format       │ '    0 kb' │ '    0 kb' │  '2.66 x'   │
 │ typebox/guard        │ '   23 kb' │ '   11 kb' │  '2.07 x'   │
-│ typebox/value        │ '   80 kb' │ '   37 kb' │  '2.15 x'   │
+│ typebox/value        │ '   80 kb' │ '   37 kb' │  '2.16 x'   │
 │ typebox              │ '   12 kb' │ '    6 kb' │  '1.89 x'   │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```

package/typebox.d.ts

@@ -1,14 +1,14 @@
 export declare const Kind: unique symbol;
 export declare const Hint: unique symbol;
 export declare const Modifier: unique symbol;
-export declare type TModifier = TReadonlyOptional<TSchema> | TOptional<TSchema> | TReadonly<TSchema>;
-export declare type TReadonly<T extends TSchema> = T & {
+export type TModifier = TReadonlyOptional<TSchema> | TOptional<TSchema> | TReadonly<TSchema>;
+export type TReadonly<T extends TSchema> = T & {
     [Modifier]: 'Readonly';
 };
-export declare type TOptional<T extends TSchema> = T & {
+export type TOptional<T extends TSchema> = T & {
     [Modifier]: 'Optional';
 };
-export declare type TReadonlyOptional<T extends TSchema> = T & {
+export type TReadonlyOptional<T extends TSchema> = T & {
     [Modifier]: 'ReadonlyOptional';
 };
 export interface SchemaOptions {
@@ -32,7 +32,7 @@ export interface TSchema extends SchemaOptions {
     params: unknown[];
     static: unknown;
 }
-export declare type TAnySchema = TSchema | TAny | TArray | TBoolean | TConstructor | TDate | TEnum | TFunction | TInteger | TLiteral | TNull | TNumber | TObject | TPromise | TRecord | TSelf | TRef | TString | TTuple | TUndefined | TUnion | TUint8Array | TUnknown | TVoid;
+export type TAnySchema = TSchema | TAny | TArray | TBoolean | TConstructor | TDate | TEnum | TFunction | TInteger | TLiteral | TNull | TNumber | TObject | TPromise | TRecord | TSelf | TRef | TString | TTuple | TUndefined | TUnion | TUint8Array | TUnknown | TVoid;
 export interface NumericOptions extends SchemaOptions {
     exclusiveMaximum?: number;
     exclusiveMinimum?: number;
@@ -40,7 +40,7 @@ export interface NumericOptions extends SchemaOptions {
     minimum?: number;
     multipleOf?: number;
 }
-export declare type TNumeric = TInteger | TNumber;
+export type TNumeric = TInteger | TNumber;
 export interface TAny extends TSchema {
     [Kind]: 'Any';
     static: any;
@@ -61,9 +61,9 @@ export interface TBoolean extends TSchema {
     static: boolean;
     type: 'boolean';
 }
-export declare type TConstructorParameters<T extends TConstructor<TSchema[], TSchema>> = TTuple<T['parameters']>;
-export declare type TInstanceType<T extends TConstructor<TSchema[], TSchema>> = T['returns'];
-export declare type StaticContructorParameters<T extends readonly TSchema[], P extends unknown[]> = [...{
+export type TConstructorParameters<T extends TConstructor<TSchema[], TSchema>> = TTuple<T['parameters']>;
+export type TInstanceType<T extends TConstructor<TSchema[], TSchema>> = T['returns'];
+export type StaticContructorParameters<T extends readonly TSchema[], P extends unknown[]> = [...{
     [K in keyof T]: T[K] extends TSchema ? Static<T[K], P> : never;
 }];
 export interface TConstructor<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
@@ -95,9 +95,9 @@ export interface TEnum<T extends Record<string, string | number> = Record<string
     static: T[keyof T];
     anyOf: TLiteral<string | number>[];
 }
-export declare type TParameters<T extends TFunction> = TTuple<T['parameters']>;
-export declare type TReturnType<T extends TFunction> = T['returns'];
-export declare type StaticFunctionParameters<T extends readonly TSchema[], P extends unknown[]> = [...{
+export type TParameters<T extends TFunction> = TTuple<T['parameters']>;
+export type TReturnType<T extends TFunction> = T['returns'];
+export type StaticFunctionParameters<T extends readonly TSchema[], P extends unknown[]> = [...{
     [K in keyof T]: T[K] extends TSchema ? Static<T[K], P> : never;
 }];
 export interface TFunction<T extends readonly TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
@@ -113,29 +113,29 @@ export interface TInteger extends TSchema, NumericOptions {
     static: number;
     type: 'integer';
 }
-export declare type IntersectReduce<I extends unknown, T extends readonly any[]> = T extends [infer A, ...infer B] ? IntersectReduce<I & A, B> : I extends object ? I : {};
-export declare type IntersectEvaluate<T extends readonly TSchema[], P extends unknown[]> = {
+export type IntersectReduce<I extends unknown, T extends readonly any[]> = T extends [infer A, ...infer B] ? IntersectReduce<I & A, B> : I extends object ? I : {};
+export type IntersectEvaluate<T extends readonly TSchema[], P extends unknown[]> = {
     [K in keyof T]: T[K] extends TSchema ? Static<T[K], P> : never;
 };
-export declare type IntersectProperties<T extends readonly TObject[]> = {
+export type IntersectProperties<T extends readonly TObject[]> = {
     [K in keyof T]: T[K] extends TObject<infer P> ? P : {};
 };
 export interface TIntersect<T extends TObject[] = TObject[]> extends TObject {
     static: IntersectReduce<unknown, IntersectEvaluate<T, this['params']>>;
     properties: IntersectReduce<unknown, IntersectProperties<T>>;
 }
-export declare type UnionToIntersect<U> = (U extends unknown ? (arg: U) => 0 : never) extends (arg: infer I) => 0 ? I : never;
-export declare type UnionLast<U> = UnionToIntersect<U extends unknown ? (x: U) => 0 : never> extends (x: infer L) => 0 ? L : never;
-export declare type UnionToTuple<U, L = UnionLast<U>> = [U] extends [never] ? [] : [...UnionToTuple<Exclude<U, L>>, L];
-export declare type UnionStringLiteralToTuple<T> = T extends TUnion<infer L> ? {
+export type UnionToIntersect<U> = (U extends unknown ? (arg: U) => 0 : never) extends (arg: infer I) => 0 ? I : never;
+export type UnionLast<U> = UnionToIntersect<U extends unknown ? (x: U) => 0 : never> extends (x: infer L) => 0 ? L : never;
+export type UnionToTuple<U, L = UnionLast<U>> = [U] extends [never] ? [] : [...UnionToTuple<Exclude<U, L>>, L];
+export type UnionStringLiteralToTuple<T> = T extends TUnion<infer L> ? {
     [I in keyof L]: L[I] extends TLiteral<infer C> ? C : never;
 } : never;
-export declare type UnionLiteralsFromObject<T extends TObject> = {
+export type UnionLiteralsFromObject<T extends TObject> = {
     [K in ObjectPropertyKeys<T>]: TLiteral<K>;
 } extends infer R ? UnionToTuple<R[keyof R]> : never;
 export interface TKeyOf<T extends TObject> extends TUnion<UnionLiteralsFromObject<T>> {
 }
-export declare type TLiteralValue = string | number | boolean;
+export type TLiteralValue = string | number | boolean;
 export interface TLiteral<T extends TLiteralValue = TLiteralValue> extends TSchema {
     [Kind]: 'Literal';
     static: T;
@@ -162,17 +162,17 @@ export interface TNumber extends TSchema, NumericOptions {
     static: number;
     type: 'number';
 }
-export declare type ReadonlyOptionalPropertyKeys<T extends TProperties> = {
+export type ReadonlyOptionalPropertyKeys<T extends TProperties> = {
     [K in keyof T]: T[K] extends TReadonlyOptional<TSchema> ? K : never;
 }[keyof T];
-export declare type ReadonlyPropertyKeys<T extends TProperties> = {
+export type ReadonlyPropertyKeys<T extends TProperties> = {
     [K in keyof T]: T[K] extends TReadonly<TSchema> ? K : never;
 }[keyof T];
-export declare type OptionalPropertyKeys<T extends TProperties> = {
+export type OptionalPropertyKeys<T extends TProperties> = {
     [K in keyof T]: T[K] extends TOptional<TSchema> ? K : never;
 }[keyof T];
-export declare type RequiredPropertyKeys<T extends TProperties> = keyof Omit<T, ReadonlyOptionalPropertyKeys<T> | ReadonlyPropertyKeys<T> | OptionalPropertyKeys<T>>;
-export declare type PropertiesReduce<T extends TProperties, P extends unknown[]> = {
+export type RequiredPropertyKeys<T extends TProperties> = keyof Omit<T, ReadonlyOptionalPropertyKeys<T> | ReadonlyPropertyKeys<T> | OptionalPropertyKeys<T>>;
+export type PropertiesReduce<T extends TProperties, P extends unknown[]> = {
     readonly [K in ReadonlyOptionalPropertyKeys<T>]?: Static<T[K], P>;
 } & {
     readonly [K in ReadonlyPropertyKeys<T>]: Static<T[K], P>;
@@ -183,15 +183,15 @@ export declare type PropertiesReduce<T extends TProperties, P extends unknown[]>
 } extends infer R ? {
     [K in keyof R]: R[K];
 } : never;
-export declare type TRecordProperties<K extends TUnion<TLiteral[]>, T extends TSchema> = Static<K> extends string ? {
+export type TRecordProperties<K extends TUnion<TLiteral[]>, T extends TSchema> = Static<K> extends string ? {
     [X in Static<K>]: T;
 } : never;
 export interface TProperties {
     [key: string]: TSchema;
 }
-export declare type ObjectProperties<T> = T extends TObject<infer U> ? U : never;
-export declare type ObjectPropertyKeys<T> = T extends TObject<infer U> ? keyof U : never;
-export declare type TAdditionalProperties = undefined | TSchema | boolean;
+export type ObjectProperties<T> = T extends TObject<infer U> ? U : never;
+export type ObjectPropertyKeys<T> = T extends TObject<infer U> ? keyof U : never;
+export type TAdditionalProperties = undefined | TSchema | boolean;
 export interface ObjectOptions extends SchemaOptions {
     additionalProperties?: TAdditionalProperties;
     minProperties?: number;
@@ -215,7 +215,7 @@ export interface TPartial<T extends TObject> extends TObject {
         [K in keyof T['properties']]: T['properties'][K] extends TReadonlyOptional<infer U> ? TReadonlyOptional<U> : T['properties'][K] extends TReadonly<infer U> ? TReadonlyOptional<U> : T['properties'][K] extends TOptional<infer U> ? TOptional<U> : TOptional<T['properties'][K]>;
     };
 }
-export declare type TPick<T extends TObject, Properties extends ObjectPropertyKeys<T>[]> = TObject<{
+export type TPick<T extends TObject, Properties extends ObjectPropertyKeys<T>[]> = TObject<{
     [K in Properties[number]]: T['properties'][K];
 }>;
 export interface TPromise<T extends TSchema = TSchema> extends TSchema {
@@ -225,7 +225,7 @@ export interface TPromise<T extends TSchema = TSchema> extends TSchema {
     instanceOf: 'Promise';
     item: TSchema;
 }
-export declare type TRecordKey = TString | TNumeric | TUnion<TLiteral<any>[]>;
+export type TRecordKey = TString | TNumeric | TUnion<TLiteral<any>[]>;
 export interface TRecord<K extends TRecordKey = TRecordKey, T extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Record';
     static: Record<Static<K>, Static<T, this['params']>>;
@@ -240,7 +240,7 @@ export interface TSelf extends TSchema {
     static: this['params'][0];
     $ref: string;
 }
-export declare type TRecursiveReduce<T extends TSchema> = Static<T, [TRecursiveReduce<T>]>;
+export type TRecursiveReduce<T extends TSchema> = Static<T, [TRecursiveReduce<T>]>;
 export interface TRecursive<T extends TSchema> extends TSchema {
     static: TRecursiveReduce<T>;
 }
@@ -255,7 +255,7 @@ export interface TRequired<T extends TObject | TRef<TObject>> extends TObject {
         [K in keyof T['properties']]: T['properties'][K] extends TReadonlyOptional<infer U> ? TReadonly<U> : T['properties'][K] extends TReadonly<infer U> ? TReadonly<U> : T['properties'][K] extends TOptional<infer U> ? U : T['properties'][K];
     };
 }
-export declare type StringFormatOption = 'date-time' | 'time' | 'date' | 'email' | 'idn-email' | 'hostname' | 'idn-hostname' | 'ipv4' | 'ipv6' | 'uri' | 'uri-reference' | 'iri' | 'uuid' | 'iri-reference' | 'uri-template' | 'json-pointer' | 'relative-json-pointer' | 'regex';
+export type StringFormatOption = 'date-time' | 'time' | 'date' | 'email' | 'idn-email' | 'hostname' | 'idn-hostname' | 'ipv4' | 'ipv6' | 'uri' | 'uri-reference' | 'iri' | 'uuid' | 'iri-reference' | 'uri-template' | 'json-pointer' | 'relative-json-pointer' | 'regex';
 export interface StringOptions<Format extends string> extends SchemaOptions {
     minLength?: number;
     maxLength?: number;
@@ -269,7 +269,7 @@ export interface TString<Format extends string = string> extends TSchema, String
     static: string;
     type: 'string';
 }
-export declare type TupleToArray<T extends TTuple<TSchema[]>> = T extends TTuple<infer R> ? R : never;
+export type TupleToArray<T extends TTuple<TSchema[]>> = T extends TTuple<infer R> ? R : never;
 export interface TTuple<T extends TSchema[] = TSchema[]> extends TSchema {
     [Kind]: 'Tuple';
     static: {
@@ -322,7 +322,7 @@ export interface TVoid extends TSchema {
     typeOf: 'Void';
 }
 /** Creates a static type from a TypeBox type */
-export declare type Static<T extends TSchema, P extends unknown[] = []> = (T & {
+export type Static<T extends TSchema, P extends unknown[] = []> = (T & {
     params: P;
 })['static'];
 export declare class TypeBuilder {

package/value/cast.js

@@ -307,7 +307,7 @@ var ValueCast;
     function Void(schema, references, value) {
         return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
     }
-    function Kind(schema, references, value) {
+    function UserDefined(schema, references, value) {
         return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
     }
     function Visit(schema, references, value) {
@@ -365,7 +365,7 @@ var ValueCast;
             default:
                 if (!index_1.Custom.Has(anySchema[Types.Kind]))
                     throw new ValueCastUnknownTypeError(anySchema);
-                return Kind(anySchema, anyReferences, value);
+                return UserDefined(anySchema, anyReferences, value);
         }
     }
     ValueCast.Visit = Visit;

package/value/check.js

@@ -33,7 +33,7 @@ const index_1 = require("../format/index");
 const index_2 = require("../custom/index");
 class ValueCheckUnknownTypeError extends Error {
     constructor(schema) {
-        super('ValueCheck: Unknown type');
+        super(`ValueCheck: ${schema[Types.Kind] ? `Unknown type '${schema[Types.Kind]}'` : 'Unknown type'}`);
         this.schema = schema;
     }
 }
@@ -291,11 +291,11 @@ var ValueCheck;
     function Void(schema, references, value) {
         return value === null;
     }
-    function Kind(schema, references, value) {
+    function UserDefined(schema, references, value) {
         if (!index_2.Custom.Has(schema[Types.Kind]))
             return false;
         const func = index_2.Custom.Get(schema[Types.Kind]);
-        return func(value);
+        return func(schema, value);
     }
     function Visit(schema, references, value) {
         const anyReferences = schema.$id === undefined ? references : [schema, ...references];
@@ -350,7 +350,7 @@ var ValueCheck;
             default:
                 if (!index_2.Custom.Has(anySchema[Types.Kind]))
                     throw new ValueCheckUnknownTypeError(anySchema);
-                return Kind(anySchema, anyReferences, value);
+                return UserDefined(anySchema, anyReferences, value);
         }
     }
     // -------------------------------------------------------------------------

package/value/create.js

@@ -293,12 +293,12 @@ var ValueCreate;
     function Void(schema, references) {
         return null;
     }
-    function Kind(schema, references) {
+    function UserDefined(schema, references) {
         if (schema.default !== undefined) {
             return schema.default;
         }
         else {
-            throw new Error('ValueCreate.Kind: Custom types must specify a default value');
+            throw new Error('ValueCreate.UserDefined: User defined types must specify a default value');
         }
     }
     /** Creates a value from the given schema. If the schema specifies a default value, then that value is returned. */
@@ -357,7 +357,7 @@ var ValueCreate;
             default:
                 if (!index_1.Custom.Has(anySchema[Types.Kind]))
                     throw new ValueCreateUnknownTypeError(anySchema);
-                return Kind(anySchema, anyReferences);
+                return UserDefined(anySchema, anyReferences);
         }
     }
     ValueCreate.Visit = Visit;

package/value/delta.d.ts

@@ -1,22 +1,22 @@
 import { Static } from '../typebox';
-export declare type Insert = Static<typeof Insert>;
+export type Insert = Static<typeof Insert>;
 export declare const Insert: import("../typebox").TObject<{
     type: import("../typebox").TLiteral<"insert">;
     path: import("../typebox").TString<string>;
     value: import("../typebox").TUnknown;
 }>;
-export declare type Update = Static<typeof Update>;
+export type Update = Static<typeof Update>;
 export declare const Update: import("../typebox").TObject<{
     type: import("../typebox").TLiteral<"update">;
     path: import("../typebox").TString<string>;
     value: import("../typebox").TUnknown;
 }>;
-export declare type Delete = Static<typeof Delete>;
+export type Delete = Static<typeof Delete>;
 export declare const Delete: import("../typebox").TObject<{
     type: import("../typebox").TLiteral<"delete">;
     path: import("../typebox").TString<string>;
 }>;
-export declare type Edit = Static<typeof Edit>;
+export type Edit = Static<typeof Edit>;
 export declare const Edit: import("../typebox").TUnion<[import("../typebox").TObject<{
     type: import("../typebox").TLiteral<"insert">;
     path: import("../typebox").TString<string>;

package/value/is.d.ts

@@ -1,7 +1,7 @@
-export declare type ValueType = null | undefined | Function | symbol | bigint | number | boolean | string;
-export declare type ObjectType = Record<string | number | symbol, unknown>;
-export declare type TypedArrayType = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
-export declare type ArrayType = unknown[];
+export type ValueType = null | undefined | Function | symbol | bigint | number | boolean | string;
+export type ObjectType = Record<string | number | symbol, unknown>;
+export type TypedArrayType = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
+export type ArrayType = unknown[];
 export declare namespace Is {
     function Object(value: unknown): value is ObjectType;
     function Date(value: unknown): value is Date;