@sinclair/typebox 0.25.7 → 0.25.9

package/compiler/compiler.js

@@ -31,6 +31,7 @@ exports.TypeCompiler = exports.TypeCompilerUnknownTypeError = exports.Property =
 const index_1 = require("../errors/index");
 const index_2 = require("../guard/index");
 const index_3 = require("../format/index");
+const index_4 = require("../custom/index");
 const Types = require("../typebox");
 // -------------------------------------------------------------------
 // TypeCheck
@@ -291,6 +292,9 @@ var TypeCompiler;
     function* Void(schema, value) {
         yield `(${value} === null)`;
     }
+    function* Kind(schema, value) {
+        yield `(custom('${schema[Types.Kind]}', ${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
@@ -352,7 +356,9 @@ var TypeCompiler;
             case 'Void':
                 return yield* Void(anySchema, value);
             default:
-                throw new TypeCompilerUnknownTypeError(schema);
+                if (!index_4.Custom.Has(anySchema[Types.Kind]))
+                    throw new TypeCompilerUnknownTypeError(schema);
+                return yield* Kind(anySchema, value);
         }
     }
     // -------------------------------------------------------------------
@@ -410,14 +416,19 @@ var TypeCompiler;
     function Compile(schema, references = []) {
         index_2.TypeGuard.Assert(schema, references);
         const code = Build(schema, references);
-        const func1 = globalThis.Function('format', code);
-        const func2 = func1((format, value) => {
+        const compiledFunction = globalThis.Function('custom', 'format', code);
+        const checkFunction = compiledFunction((kind, value) => {
+            if (!index_4.Custom.Has(kind))
+                return false;
+            const func = index_4.Custom.Get(kind);
+            return func(value);
+        }, (format, value) => {
             if (!index_3.Format.Has(format))
                 return false;
             const func = index_3.Format.Get(format);
             return func(value);
         });
-        return new TypeCheck(schema, references, func2, code);
+        return new TypeCheck(schema, references, checkFunction, code);
     }
     TypeCompiler.Compile = Compile;
 })(TypeCompiler = exports.TypeCompiler || (exports.TypeCompiler = {}));

package/conditional/structural.js

@@ -49,14 +49,16 @@ var Structural;
     // ------------------------------------------------------------------------
     // Rules
     // ------------------------------------------------------------------------
-    function AnyOrUnknownRule(right) {
+    function AnyUnknownOrCustomRule(right) {
         // https://github.com/microsoft/TypeScript/issues/40049
-        if (right[Types.Kind] === 'Union' && right.anyOf.some((schema) => schema[Types.Kind] === 'Any' || schema[Types.Kind] === 'Unknown'))
+        if (guard_1.TypeGuard.TUnion(right) && right.anyOf.some((schema) => schema[Types.Kind] === 'Any' || schema[Types.Kind] === 'Unknown'))
             return true;
-        if (right[Types.Kind] === 'Unknown')
+        if (guard_1.TypeGuard.TUnknown(right))
             return true;
-        if (right[Types.Kind] === 'Any')
+        if (guard_1.TypeGuard.TAny(right))
             return true;
+        if (guard_1.TypeGuard.TCustom(right))
+            throw Error(`Structural: Cannot structurally compare custom type '${right[Types.Kind]}'`);
         return false;
     }
     function ObjectRightRule(left, right) {
@@ -132,10 +134,10 @@ var Structural;
     // Checks
     // ------------------------------------------------------------------------
     function Any(left, right) {
-        return AnyOrUnknownRule(right) ? StructuralResult.True : StructuralResult.Union;
+        return AnyUnknownOrCustomRule(right) ? StructuralResult.True : StructuralResult.Union;
     }
     function Array(left, right) {
-        if (AnyOrUnknownRule(right)) {
+        if (AnyUnknownOrCustomRule(right)) {
             return StructuralResult.True;
         }
         else if (guard_1.TypeGuard.TObject(right)) {
@@ -163,7 +165,7 @@ var Structural;
         }
     }
     function Boolean(left, right) {
-        if (AnyOrUnknownRule(right)) {
+        if (AnyUnknownOrCustomRule(right)) {
             return StructuralResult.True;
         }
         else if (guard_1.TypeGuard.TObject(right) && ObjectRightRule(left, right)) {
@@ -180,7 +182,7 @@ var Structural;
         }
     }
     function Constructor(left, right) {
-        if (AnyOrUnknownRule(right)) {
+        if (AnyUnknownOrCustomRule(right)) {
             return StructuralResult.True;
         }
         else if (guard_1.TypeGuard.TObject(right) && globalThis.Object.keys(right.properties).length === 0) {
@@ -205,7 +207,7 @@ var Structural;
         }
     }
     function Date(left, right) {
-        if (AnyOrUnknownRule(right)) {
+        if (AnyUnknownOrCustomRule(right)) {
             return StructuralResult.True;
         }
         else if (guard_1.TypeGuard.TObject(right) && ObjectRightRule(left, right)) {
@@ -225,7 +227,7 @@ var Structural;
         }
     }
     function Function(left, right) {
-        if (AnyOrUnknownRule(right)) {
+        if (AnyUnknownOrCustomRule(right)) {
             return StructuralResult.True;
         }
         else if (guard_1.TypeGuard.TObject(right)) {
@@ -254,7 +256,7 @@ var Structural;
         }
     }
     function Integer(left, right) {
-        if (AnyOrUnknownRule(right)) {
+        if (AnyUnknownOrCustomRule(right)) {
             return StructuralResult.True;
         }
         else if (guard_1.TypeGuard.TObject(right) && ObjectRightRule(left, right)) {
@@ -271,7 +273,7 @@ var Structural;
         }
     }
     function Literal(left, right) {
-        if (AnyOrUnknownRule(right)) {
+        if (AnyUnknownOrCustomRule(right)) {
             return StructuralResult.True;
         }
         else if (guard_1.TypeGuard.TObject(right) && ObjectRightRule(left, right)) {
@@ -308,7 +310,7 @@ var Structural;
         }
     }
     function Number(left, right) {
-        if (AnyOrUnknownRule(right)) {
+        if (AnyUnknownOrCustomRule(right)) {
             return StructuralResult.True;
         }
         else if (guard_1.TypeGuard.TObject(right) && ObjectRightRule(left, right)) {
@@ -328,7 +330,7 @@ var Structural;
         }
     }
     function Null(left, right) {
-        if (AnyOrUnknownRule(right)) {
+        if (AnyUnknownOrCustomRule(right)) {
             return StructuralResult.True;
         }
         else if (guard_1.TypeGuard.TNull(right)) {
@@ -356,7 +358,7 @@ var Structural;
         return StructuralResult.True;
     }
     function Object(left, right) {
-        if (AnyOrUnknownRule(right)) {
+        if (AnyUnknownOrCustomRule(right)) {
             return StructuralResult.True;
         }
         else if (guard_1.TypeGuard.TObject(right)) {
@@ -375,7 +377,7 @@ var Structural;
         }
     }
     function Promise(left, right) {
-        if (AnyOrUnknownRule(right)) {
+        if (AnyUnknownOrCustomRule(right)) {
             return StructuralResult.True;
         }
         else if (guard_1.TypeGuard.TObject(right)) {
@@ -395,7 +397,7 @@ var Structural;
         }
     }
     function Record(left, right) {
-        if (AnyOrUnknownRule(right)) {
+        if (AnyUnknownOrCustomRule(right)) {
             return StructuralResult.True;
         }
         else if (guard_1.TypeGuard.TObject(right)) {
@@ -444,7 +446,7 @@ var Structural;
         return Visit(resolved, right);
     }
     function String(left, right) {
-        if (AnyOrUnknownRule(right)) {
+        if (AnyUnknownOrCustomRule(right)) {
             return StructuralResult.True;
         }
         else if (guard_1.TypeGuard.TObject(right) && ObjectRightRule(left, right)) {
@@ -464,7 +466,7 @@ var Structural;
         }
     }
     function Tuple(left, right) {
-        if (AnyOrUnknownRule(right)) {
+        if (AnyUnknownOrCustomRule(right)) {
             return StructuralResult.True;
         }
         else if (guard_1.TypeGuard.TObject(right)) {
@@ -508,7 +510,7 @@ var Structural;
         return StructuralResult.True;
     }
     function Uint8Array(left, right) {
-        if (AnyOrUnknownRule(right)) {
+        if (AnyUnknownOrCustomRule(right)) {
             return StructuralResult.True;
         }
         else if (guard_1.TypeGuard.TObject(right) && ObjectRightRule(left, right)) {
@@ -528,7 +530,7 @@ var Structural;
         }
     }
     function Undefined(left, right) {
-        if (AnyOrUnknownRule(right)) {
+        if (AnyUnknownOrCustomRule(right)) {
             return StructuralResult.True;
         }
         else if (guard_1.TypeGuard.TUndefined(right)) {
@@ -666,6 +668,9 @@ var Structural;
         else if (guard_1.TypeGuard.TVoid(left)) {
             return Void(left, resolvedRight);
         }
+        else if (guard_1.TypeGuard.TCustom(left)) {
+            throw Error(`Structural: Cannot structurally compare custom type '${left[Types.Kind]}'`);
+        }
         else {
             throw Error(`Structural: Unknown left operand '${left[Types.Kind]}'`);
         }

package/custom/custom.d.ts

@@ -0,0 +1,12 @@
+export declare type CustomValidationFunction = (value: unknown) => boolean;
+/** Provides functions to create custom types */
+export declare namespace Custom {
+    /** Clears all custom types */
+    function Clear(): void;
+    /** Returns true if this kind 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;
+}

package/custom/custom.js

@@ -0,0 +1,55 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/custom
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Custom = void 0;
+/** Provides functions to create custom types */
+var Custom;
+(function (Custom) {
+    const customs = new Map();
+    /** Clears all custom types */
+    function Clear() {
+        return customs.clear();
+    }
+    Custom.Clear = Clear;
+    /** Returns true if this kind exists */
+    function Has(kind) {
+        return customs.has(kind);
+    }
+    Custom.Has = Has;
+    /** Sets a validation function for a custom kind */
+    function Set(kind, func) {
+        customs.set(kind, func);
+    }
+    Custom.Set = Set;
+    /** Gets a custom validation function */
+    function Get(kind) {
+        return customs.get(kind);
+    }
+    Custom.Get = Get;
+})(Custom = exports.Custom || (exports.Custom = {}));

package/custom/index.d.ts

@@ -0,0 +1 @@
+export * from './custom';

package/custom/index.js

@@ -0,0 +1,44 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/custom
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./custom"), exports);

package/errors/errors.d.ts

@@ -47,7 +47,8 @@ export declare enum ValueErrorType {
     Uint8Array = 44,
     Uint8ArrayMinByteLength = 45,
     Uint8ArrayMaxByteLength = 46,
-    Void = 47
+    Void = 47,
+    Custom = 48
 }
 export interface ValueError {
     type: ValueErrorType;

package/errors/errors.js

@@ -30,6 +30,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ValueErrors = exports.ValueErrorsUnknownTypeError = exports.ValueErrorType = void 0;
 const Types = require("../typebox");
 const index_1 = require("../format/index");
+const index_2 = require("../custom/index");
 // -------------------------------------------------------------------
 // ValueErrorType
 // -------------------------------------------------------------------
@@ -83,6 +84,7 @@ var ValueErrorType;
     ValueErrorType[ValueErrorType["Uint8ArrayMinByteLength"] = 45] = "Uint8ArrayMinByteLength";
     ValueErrorType[ValueErrorType["Uint8ArrayMaxByteLength"] = 46] = "Uint8ArrayMaxByteLength";
     ValueErrorType[ValueErrorType["Void"] = 47] = "Void";
+    ValueErrorType[ValueErrorType["Custom"] = 48] = "Custom";
 })(ValueErrorType = exports.ValueErrorType || (exports.ValueErrorType = {}));
 // -------------------------------------------------------------------
 // ValueErrors
@@ -365,6 +367,12 @@ var ValueErrors;
             return yield { type: ValueErrorType.Void, schema, path, value, message: `Expected null` };
         }
     }
+    function* CustomType(schema, references, path, value) {
+        const func = index_2.Custom.Get(schema[Types.Kind]);
+        if (!func(value)) {
+            return yield { type: ValueErrorType.Custom, schema, path, value, message: `Expected kind ${schema[Types.Kind]}` };
+        }
+    }
     function* Visit(schema, references, path, value) {
         const anyReferences = schema.$id === undefined ? references : [schema, ...references];
         const anySchema = schema;
@@ -416,7 +424,9 @@ var ValueErrors;
             case 'Void':
                 return yield* Void(anySchema, anyReferences, path, value);
             default:
-                throw new ValueErrorsUnknownTypeError(schema);
+                if (!index_2.Custom.Has(anySchema[Types.Kind]))
+                    throw new ValueErrorsUnknownTypeError(schema);
+                return yield* CustomType(anySchema, anyReferences, path, value);
         }
     }
     function* Errors(schema, references, value) {

package/guard/guard.d.ts

@@ -1,5 +1,5 @@
 import * as Types from '../typebox';
-export declare class TypeGuardInvalidTypeError extends Error {
+export declare class TypeGuardUnknownTypeError extends Error {
     readonly schema: unknown;
     constructor(schema: unknown);
 }
@@ -51,6 +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 TSchema */
     function TSchema(schema: unknown): schema is Types.TSchema;
     /** Asserts if this schema and associated references are valid. */

package/guard/guard.js

@@ -27,15 +27,16 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeGuard = exports.TypeGuardInvalidTypeError = void 0;
+exports.TypeGuard = exports.TypeGuardUnknownTypeError = void 0;
+const index_1 = require("../custom/index");
 const Types = require("../typebox");
-class TypeGuardInvalidTypeError extends Error {
+class TypeGuardUnknownTypeError extends Error {
     constructor(schema) {
-        super('TypeGuard: Invalid type');
+        super('TypeGuard: Unknown type');
         this.schema = schema;
     }
 }
-exports.TypeGuardInvalidTypeError = TypeGuardInvalidTypeError;
+exports.TypeGuardUnknownTypeError = TypeGuardUnknownTypeError;
 /** Provides functionality to test if values are TypeBox types */
 var TypeGuard;
 (function (TypeGuard) {
@@ -393,6 +394,11 @@ var TypeGuard;
             IsOptionalString(schema.$id));
     }
     TypeGuard.TVoid = TVoid;
+    /** Returns true if the given schema is a registered custom type */
+    function TCustom(schema) {
+        return IsObject(schema) && IsString(schema[Types.Kind]) && index_1.Custom.Has(schema[Types.Kind]);
+    }
+    TypeGuard.TCustom = TCustom;
     /** Returns true if the given schema is TSchema */
     function TSchema(schema) {
         return (TAny(schema) ||
@@ -417,16 +423,17 @@ var TypeGuard;
             TUnion(schema) ||
             TUint8Array(schema) ||
             TUnknown(schema) ||
-            TVoid(schema));
+            TVoid(schema) ||
+            TCustom(schema));
     }
     TypeGuard.TSchema = TSchema;
     /** Asserts if this schema and associated references are valid. */
     function Assert(schema, references = []) {
         if (!TSchema(schema))
-            throw new TypeGuardInvalidTypeError(schema);
+            throw new TypeGuardUnknownTypeError(schema);
         for (const schema of references) {
             if (!TSchema(schema))
-                throw new TypeGuardInvalidTypeError(schema);
+                throw new TypeGuardUnknownTypeError(schema);
         }
     }
     TypeGuard.Assert = Assert;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.25.7",
+  "version": "0.25.9",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
@@ -12,6 +12,16 @@
   "license": "MIT",
   "main": "./typebox.js",
   "types": "./typebox.d.ts",
+  "exports": {
+    "./compiler": "./compiler/index.js",
+    "./conditional": "./conditional/index.js",
+    "./custom": "./custom/index.js",
+    "./errors": "./errors/index.js",
+    "./format": "./format/index.js",
+    "./guard": "./guard/index.js",
+    "./value": "./value/index.js",
+    ".": "./typebox.js"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/sinclairzx81/typebox"

package/readme.md

@@ -19,28 +19,45 @@
 
 ## Install
 
-Node
-
+### npm
 ```bash
 $ npm install @sinclair/typebox --save
 ```
 
-Deno and ESM
+### deno
+```typescript
+import { Static, Type } from 'npm:@sinclair/typebox'
+```
+
+### esm
 
 ```typescript
 import { Static, Type } from 'https://esm.sh/@sinclair/typebox'
 ```
 
-## Example
+## Usage
 
 ```typescript
 import { Static, Type } from '@sinclair/typebox'
 
-const T = Type.String()     // const T = { type: 'string' }
+const T = Type.Object({                              // const T = {
+  x: Type.Number(),                                  //   type: 'object',
+  y: Type.Number(),                                  //   required: ['x', 'y', 'z'],
+  z: Type.Number()                                   //   properties: {
+})                                                   //     x: { type: 'number' },
+                                                     //     y: { type: 'number' },
+                                                     //     z: { type: 'number' }
+                                                     //   }
+                                                     // }
 
-type T = Static<typeof T>   // type T = string
+type T = Static<typeof T>                            // type T = {
+                                                     //   x: number,
+                                                     //   y: number,
+                                                     //   z: number
+                                                     // }
 ```
 
+
 <a name="Overview"></a>
 
 ## Overview
@@ -54,7 +71,7 @@ License MIT
 ## Contents
 - [Install](#install)
 - [Overview](#overview)
-- [Usage](#usage)
+- [Example](#Example)
 - [Types](#types)
   - [Standard Types](#types-standard)
   - [Extended Types](#types-extended)
@@ -80,6 +97,7 @@ License MIT
 - [TypeCheck](#typecheck)
   - [Ajv](#typecheck-ajv)
   - [TypeCompiler](#typecheck-typecompiler)
+  - [Custom](#typecheck-custom)
   - [Formats](#typecheck-formats)
 - [Benchmark](#benchmark)
   - [Compile](#benchmark-compile)
@@ -89,7 +107,7 @@ License MIT
 
 <a name="Example"></a>
 
-## Usage
+## Example
 
 The following demonstrates TypeBox's general usage.
 
@@ -1100,6 +1118,30 @@ console.log(C.Code())                                // return function check(va
                                                      // }
 ```
 
+<a name='typecheck-custom'></a>
+
+### Custom
+
+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.
+
+The custom module is an optional import.
+
+```typescript
+import { Custom } from '@sinclair/typebox/custom'
+```
+
+The following registers a BigInt custom type.
+
+```typescript
+import { Type, Kind } from '@sinclair/typebox'
+
+Custom.Set('BigInt', value => typeof value === 'bigint')
+
+const T = Type.Unsafe<bigint>({ [Kind]: 'BigInt' })  // const T = { [Kind]: 'BigInt' }
+
+const R = Value.Check(T, 65536n)                     // const R = true
+```
+
 <a name='typecheck-formats'></a>
 
 ### Formats
@@ -1146,29 +1188,29 @@ This benchmark measures compilation performance for varying types. You can revie
 ┌──────────────────┬────────────┬──────────────┬──────────────┬──────────────┐
 │     (index)      │ Iterations │     Ajv      │ TypeCompiler │ Performance  │
 ├──────────────────┼────────────┼──────────────┼──────────────┼──────────────┤
-│           Number │    2000    │ '    421 ms' │ '     11 ms' │ '   38.27 x' │
-│           String │    2000    │ '    332 ms' │ '     11 ms' │ '   30.18 x' │
-│          Boolean │    2000    │ '    291 ms' │ '     12 ms' │ '   24.25 x' │
-│             Null │    2000    │ '    266 ms' │ '      9 ms' │ '   29.56 x' │
-│            RegEx │    2000    │ '    486 ms' │ '     17 ms' │ '   28.59 x' │
-│          ObjectA │    2000    │ '   2791 ms' │ '     50 ms' │ '   55.82 x' │
-│          ObjectB │    2000    │ '   2896 ms' │ '     37 ms' │ '   78.27 x' │
-│            Tuple │    2000    │ '   1244 ms' │ '     21 ms' │ '   59.24 x' │
-│            Union │    2000    │ '   1258 ms' │ '     25 ms' │ '   50.32 x' │
-│          Vector4 │    2000    │ '   1513 ms' │ '     21 ms' │ '   72.05 x' │
-│          Matrix4 │    2000    │ '    850 ms' │ '     11 ms' │ '   77.27 x' │
-│   Literal_String │    2000    │ '    335 ms' │ '      7 ms' │ '   47.86 x' │
-│   Literal_Number │    2000    │ '    358 ms' │ '      7 ms' │ '   51.14 x' │
-│  Literal_Boolean │    2000    │ '    356 ms' │ '      7 ms' │ '   50.86 x' │
-│     Array_Number │    2000    │ '    689 ms' │ '      9 ms' │ '   76.56 x' │
-│     Array_String │    2000    │ '    728 ms' │ '     12 ms' │ '   60.67 x' │
-│    Array_Boolean │    2000    │ '    726 ms' │ '      7 ms' │ '  103.71 x' │
-│    Array_ObjectA │    2000    │ '   3631 ms' │ '     35 ms' │ '  103.74 x' │
-│    Array_ObjectB │    2000    │ '   3636 ms' │ '     40 ms' │ '   90.90 x' │
-│      Array_Tuple │    2000    │ '   2119 ms' │ '     31 ms' │ '   68.35 x' │
-│      Array_Union │    2000    │ '   1550 ms' │ '     23 ms' │ '   67.39 x' │
-│    Array_Vector4 │    2000    │ '   2200 ms' │ '     18 ms' │ '  122.22 x' │
-│    Array_Matrix4 │    2000    │ '   1494 ms' │ '     14 ms' │ '  106.71 x' │
+│           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' │
+│          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' │
 └──────────────────┴────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1182,31 +1224,31 @@ This benchmark measures validation performance for varying types. You can review
 ┌──────────────────┬────────────┬──────────────┬──────────────┬──────────────┬──────────────┐
 │     (index)      │ Iterations │  ValueCheck  │     Ajv      │ TypeCompiler │ Performance  │
 ├──────────────────┼────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
-│           Number │  1000000   │ '     28 ms' │ '      6 ms' │ '      6 ms' │ '    1.00 x' │
-│           String │  1000000   │ '     25 ms' │ '     20 ms' │ '     11 ms' │ '    1.82 x' │
-│          Boolean │  1000000   │ '     34 ms' │ '     22 ms' │ '     13 ms' │ '    1.69 x' │
-│             Null │  1000000   │ '     37 ms' │ '     28 ms' │ '     10 ms' │ '    2.80 x' │
-│            RegEx │  1000000   │ '    162 ms' │ '     50 ms' │ '     37 ms' │ '    1.35 x' │
-│          ObjectA │  1000000   │ '    550 ms' │ '     38 ms' │ '     22 ms' │ '    1.73 x' │
-│          ObjectB │  1000000   │ '   1033 ms' │ '     58 ms' │ '     38 ms' │ '    1.53 x' │
-│            Tuple │  1000000   │ '    126 ms' │ '     24 ms' │ '     14 ms' │ '    1.71 x' │
-│            Union │  1000000   │ '    326 ms' │ '     25 ms' │ '     16 ms' │ '    1.56 x' │
-│        Recursive │  1000000   │ '   3089 ms' │ '    436 ms' │ '    101 ms' │ '    4.32 x' │
-│          Vector4 │  1000000   │ '    155 ms' │ '     24 ms' │ '     12 ms' │ '    2.00 x' │
-│          Matrix4 │  1000000   │ '    579 ms' │ '     41 ms' │ '     28 ms' │ '    1.46 x' │
-│   Literal_String │  1000000   │ '     50 ms' │ '     21 ms' │ '     13 ms' │ '    1.62 x' │
-│   Literal_Number │  1000000   │ '     46 ms' │ '     22 ms' │ '     11 ms' │ '    2.00 x' │
+│           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   │ '    424 ms' │ '     32 ms' │ '     19 ms' │ '    1.68 x' │
-│     Array_String │  1000000   │ '    483 ms' │ '     34 ms' │ '     28 ms' │ '    1.21 x' │
-│    Array_Boolean │  1000000   │ '    432 ms' │ '     35 ms' │ '     26 ms' │ '    1.35 x' │
-│    Array_ObjectA │  1000000   │ '  13895 ms' │ '   2440 ms' │ '   1495 ms' │ '    1.63 x' │
-│    Array_ObjectB │  1000000   │ '  16261 ms' │ '   2633 ms' │ '   2011 ms' │ '    1.31 x' │
-│      Array_Tuple │  1000000   │ '   1741 ms' │ '     98 ms' │ '     66 ms' │ '    1.48 x' │
-│      Array_Union │  1000000   │ '   4825 ms' │ '    232 ms' │ '     87 ms' │ '    2.67 x' │
-│  Array_Recursive │  1000000   │ '  54158 ms' │ '   6966 ms' │ '   1173 ms' │ '    5.94 x' │
-│    Array_Vector4 │  1000000   │ '   2577 ms' │ '     99 ms' │ '     48 ms' │ '    2.06 x' │
-│    Array_Matrix4 │  1000000   │ '  12648 ms' │ '    397 ms' │ '    249 ms' │ '    1.59 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' │
 └──────────────────┴────────────┴──────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1220,11 +1262,12 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │       (index)        │  Compiled  │  Minified  │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '   54 kb' │ '   27 kb' │  '1.97 x'   │
-│ typebox/conditional  │ '   44 kb' │ '   17 kb' │  '2.45 x'   │
+│ typebox/compiler     │ '   55 kb' │ '   27 kb' │  '2.00 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        │ '   22 kb' │ '   11 kb' │  '2.05 x'   │
-│ typebox/value        │ '   78 kb' │ '   36 kb' │  '2.13 x'   │
+│ typebox/guard        │ '   23 kb' │ '   11 kb' │  '2.07 x'   │
+│ typebox/value        │ '   80 kb' │ '   37 kb' │  '2.15 x'   │
 │ typebox              │ '   12 kb' │ '    6 kb' │  '1.89 x'   │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```

package/value/cast.js

@@ -32,6 +32,7 @@ const Types = require("../typebox");
 const create_1 = require("./create");
 const check_1 = require("./check");
 const clone_1 = require("./clone");
+const index_1 = require("../custom/index");
 // ----------------------------------------------------------------------------------------------
 // Errors
 // ----------------------------------------------------------------------------------------------
@@ -306,6 +307,9 @@ 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) {
+        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
+    }
     function Visit(schema, references, value) {
         const anyReferences = schema.$id === undefined ? references : [schema, ...references];
         const anySchema = schema;
@@ -359,7 +363,9 @@ var ValueCast;
             case 'Void':
                 return Void(anySchema, anyReferences, value);
             default:
-                throw new ValueCastUnknownTypeError(anySchema);
+                if (!index_1.Custom.Has(anySchema[Types.Kind]))
+                    throw new ValueCastUnknownTypeError(anySchema);
+                return Kind(anySchema, anyReferences, value);
         }
     }
     ValueCast.Visit = Visit;

package/value/check.js

@@ -29,7 +29,8 @@ THE SOFTWARE.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ValueCheck = exports.ValueCheckUnknownTypeError = void 0;
 const Types = require("../typebox");
-const format_1 = require("../format");
+const index_1 = require("../format/index");
+const index_2 = require("../custom/index");
 class ValueCheckUnknownTypeError extends Error {
     constructor(schema) {
         super('ValueCheck: Unknown type');
@@ -240,9 +241,9 @@ var ValueCheck;
                 return false;
         }
         if (schema.format !== undefined) {
-            if (!format_1.Format.Has(schema.format))
+            if (!index_1.Format.Has(schema.format))
                 return false;
-            const func = format_1.Format.Get(schema.format);
+            const func = index_1.Format.Get(schema.format);
             return func(value);
         }
         return true;
@@ -290,6 +291,12 @@ var ValueCheck;
     function Void(schema, references, value) {
         return value === null;
     }
+    function Kind(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);
+    }
     function Visit(schema, references, value) {
         const anyReferences = schema.$id === undefined ? references : [schema, ...references];
         const anySchema = schema;
@@ -341,7 +348,9 @@ var ValueCheck;
             case 'Void':
                 return Void(anySchema, anyReferences, value);
             default:
-                throw new ValueCheckUnknownTypeError(anySchema);
+                if (!index_2.Custom.Has(anySchema[Types.Kind]))
+                    throw new ValueCheckUnknownTypeError(anySchema);
+                return Kind(anySchema, anyReferences, value);
         }
     }
     // -------------------------------------------------------------------------

package/value/create.js

@@ -29,6 +29,7 @@ THE SOFTWARE.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ValueCreate = exports.ValueCreateNeverTypeError = exports.ValueCreateUnknownTypeError = void 0;
 const Types = require("../typebox");
+const index_1 = require("../custom/index");
 class ValueCreateUnknownTypeError extends Error {
     constructor(schema) {
         super('ValueCreate: Unknown type');
@@ -292,6 +293,14 @@ var ValueCreate;
     function Void(schema, references) {
         return null;
     }
+    function Kind(schema, references) {
+        if (schema.default !== undefined) {
+            return schema.default;
+        }
+        else {
+            throw new Error('ValueCreate.Kind: Custom 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. */
     function Visit(schema, references) {
         const anyReferences = schema.$id === undefined ? references : [schema, ...references];
@@ -346,7 +355,9 @@ var ValueCreate;
             case 'Void':
                 return Void(anySchema, anyReferences);
             default:
-                throw new ValueCreateUnknownTypeError(anySchema);
+                if (!index_1.Custom.Has(anySchema[Types.Kind]))
+                    throw new ValueCreateUnknownTypeError(anySchema);
+                return Kind(anySchema, anyReferences);
         }
     }
     ValueCreate.Visit = Visit;