@sinclair/typebox 0.24.23 → 0.24.26

package/guard/guard.js

@@ -32,11 +32,52 @@ const Types = require("../typebox");
 /** TypeGuard tests that values conform to a known TypeBox type specification */
 var TypeGuard;
 (function (TypeGuard) {
-    function IsObject(schema) {
-        return typeof schema === 'object' && schema !== null && !Array.isArray(schema);
+    function IsObject(value) {
+        return typeof value === 'object' && value !== null && !Array.isArray(value);
     }
-    function IsArray(schema) {
-        return typeof schema === 'object' && schema !== null && Array.isArray(schema);
+    function IsArray(value) {
+        return typeof value === 'object' && value !== null && Array.isArray(value);
+    }
+    function IsPattern(value) {
+        try {
+            new RegExp(value);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    function IsValidPropertyKey(value) {
+        if (typeof value !== 'string')
+            return false;
+        for (let i = 0; i < value.length; i++) {
+            const code = value.charCodeAt(i);
+            if ((code >= 7 && code <= 13) || code === 27 || code === 127) {
+                return false;
+            }
+        }
+        return true;
+    }
+    function IsString(value) {
+        return typeof value === 'string';
+    }
+    function IsNumber(value) {
+        return typeof value === 'number';
+    }
+    function IsBoolean(value) {
+        return typeof value === 'boolean';
+    }
+    function IsOptionalNumber(value) {
+        return value === undefined || (value !== undefined && IsNumber(value));
+    }
+    function IsOptionalBoolean(value) {
+        return value === undefined || (value !== undefined && IsBoolean(value));
+    }
+    function IsOptionalString(value) {
+        return value === undefined || (value !== undefined && IsString(value));
+    }
+    function IsOptionalPattern(value) {
+        return value === undefined || (value !== undefined && IsString(value) && IsPattern(value));
     }
     /** Returns true if the given schema is TAny */
     function TAny(schema) {
@@ -45,7 +86,7 @@ var TypeGuard;
     TypeGuard.TAny = TAny;
     /** Returns true if the given schema is TArray */
     function TArray(schema) {
-        return IsObject(schema) && schema[Types.Kind] === 'Array' && schema.type === 'array' && TSchema(schema.items);
+        return IsObject(schema) && schema[Types.Kind] === 'Array' && schema.type === 'array' && TSchema(schema.items) && IsOptionalNumber(schema.minItems) && IsOptionalNumber(schema.maxItems) && IsOptionalBoolean(schema.uniqueItems);
     }
     TypeGuard.TArray = TArray;
     /** Returns true if the given schema is TBoolean */
@@ -79,12 +120,19 @@ var TypeGuard;
     TypeGuard.TFunction = TFunction;
     /** Returns true if the given schema is TInteger */
     function TInteger(schema) {
-        return IsObject(schema) && schema[Types.Kind] === 'Integer' && schema.type === 'integer';
+        return (IsObject(schema) &&
+            schema[Types.Kind] === 'Integer' &&
+            schema.type === 'integer' &&
+            IsOptionalNumber(schema.multipleOf) &&
+            IsOptionalNumber(schema.minimum) &&
+            IsOptionalNumber(schema.maximum) &&
+            IsOptionalNumber(schema.exclusiveMinimum) &&
+            IsOptionalNumber(schema.exclusiveMaximum));
     }
     TypeGuard.TInteger = TInteger;
     /** Returns true if the given schema is TLiteral */
     function TLiteral(schema) {
-        return IsObject(schema) && schema[Types.Kind] === 'Literal' && (typeof schema.const === 'string' || typeof schema.const === 'number' || typeof schema.const === 'boolean');
+        return IsObject(schema) && schema[Types.Kind] === 'Literal' && (IsString(schema.const) || IsNumber(schema.const) || IsBoolean(schema.const));
     }
     TypeGuard.TLiteral = TLiteral;
     /** Returns true if the given schema is TNull */
@@ -94,16 +142,31 @@ var TypeGuard;
     TypeGuard.TNull = TNull;
     /** Returns true if the given schema is TNumber */
     function TNumber(schema) {
-        return IsObject(schema) && schema[Types.Kind] === 'Number' && schema.type === 'number';
+        return (IsObject(schema) &&
+            schema[Types.Kind] === 'Number' &&
+            schema.type === 'number' &&
+            IsOptionalNumber(schema.multipleOf) &&
+            IsOptionalNumber(schema.minimum) &&
+            IsOptionalNumber(schema.maximum) &&
+            IsOptionalNumber(schema.exclusiveMinimum) &&
+            IsOptionalNumber(schema.exclusiveMaximum));
     }
     TypeGuard.TNumber = TNumber;
     /** Returns true if the given schema is TObject */
     function TObject(schema) {
-        if (!(IsObject(schema) && schema[Types.Kind] === 'Object' && schema.type === 'object' && IsObject(schema.properties))) {
+        if (!(IsObject(schema) &&
+            schema[Types.Kind] === 'Object' &&
+            schema.type === 'object' &&
+            IsObject(schema.properties) &&
+            IsOptionalBoolean(schema.additionalProperties) &&
+            IsOptionalNumber(schema.minProperties) &&
+            IsOptionalNumber(schema.maxProperties))) {
             return false;
         }
-        for (const property of Object.values(schema.properties)) {
-            if (!TSchema(property))
+        for (const [key, value] of Object.entries(schema.properties)) {
+            if (!IsValidPropertyKey(key))
+                return false;
+            if (!TSchema(value))
                 return false;
         }
         return true;
@@ -116,13 +179,16 @@ var TypeGuard;
     TypeGuard.TPromise = TPromise;
     /** Returns true if the given schema is TRecord */
     function TRecord(schema) {
-        if (!(IsObject(schema) && schema[Types.Kind] === 'Record' && schema.type === 'object' && IsObject(schema.patternProperties))) {
+        if (!(IsObject(schema) && schema[Types.Kind] === 'Record' && schema.type === 'object' && schema.additionalProperties === false && IsObject(schema.patternProperties))) {
             return false;
         }
         const keys = Object.keys(schema.patternProperties);
         if (keys.length !== 1) {
             return false;
         }
+        if (!IsPattern(keys[0])) {
+            return false;
+        }
         if (!TSchema(schema.patternProperties[keys[0]])) {
             return false;
         }
@@ -131,22 +197,22 @@ var TypeGuard;
     TypeGuard.TRecord = TRecord;
     /** Returns true if the given schema is TSelf */
     function TSelf(schema) {
-        return IsObject(schema) && schema[Types.Kind] === 'Self' && typeof schema.$ref === 'string';
+        return IsObject(schema) && schema[Types.Kind] === 'Self' && IsString(schema.$ref);
     }
     TypeGuard.TSelf = TSelf;
     /** Returns true if the given schema is TRef */
     function TRef(schema) {
-        return IsObject(schema) && schema[Types.Kind] === 'Ref' && typeof schema.$ref === 'string';
+        return IsObject(schema) && schema[Types.Kind] === 'Ref' && IsString(schema.$ref);
     }
     TypeGuard.TRef = TRef;
     /** Returns true if the given schema is TString */
     function TString(schema) {
-        return IsObject(schema) && schema[Types.Kind] === 'String' && schema.type === 'string';
+        return IsObject(schema) && schema[Types.Kind] === 'String' && schema.type === 'string' && IsOptionalNumber(schema.minLength) && IsOptionalNumber(schema.maxLength) && IsOptionalPattern(schema.pattern) && IsOptionalString(schema.format);
     }
     TypeGuard.TString = TString;
     /** Returns true if the given schema is TTuple */
     function TTuple(schema) {
-        if (!(IsObject(schema) && schema[Types.Kind] === 'Tuple' && schema.type === 'array' && typeof schema.minItems === 'number' && typeof schema.maxItems === 'number' && schema.minItems === schema.maxItems)) {
+        if (!(IsObject(schema) && schema[Types.Kind] === 'Tuple' && schema.type === 'array' && IsNumber(schema.minItems) && IsNumber(schema.maxItems) && schema.minItems === schema.maxItems)) {
             return false;
         }
         if (schema.items === undefined && schema.additionalItems === undefined && schema.minItems === 0) {
@@ -181,7 +247,7 @@ var TypeGuard;
     TypeGuard.TUnion = TUnion;
     /** Returns true if the given schema is TUint8Array */
     function TUint8Array(schema) {
-        return IsObject(schema) && schema[Types.Kind] === 'Uint8Array' && schema.type === 'object' && schema.specialized === 'Uint8Array';
+        return IsObject(schema) && schema[Types.Kind] === 'Uint8Array' && schema.type === 'object' && schema.specialized === 'Uint8Array' && IsOptionalNumber(schema.minByteLength) && IsOptionalNumber(schema.maxByteLength);
     }
     TypeGuard.TUint8Array = TUint8Array;
     /** Returns true if the given schema is TUnknown */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.24.23",
+  "version": "0.24.26",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",

package/readme.md

@@ -818,19 +818,19 @@ const C = TypeCompiler.Compile(Type.Object({         // const C: TypeCheck<TObje
 const value = { }
 
 const errors = [...C.Errors(value)]                  // const errors = [{
-                                                     //   type: ValueErrorType.Number,
+                                                     //   type: 14,
                                                      //   schema: { type: 'number' },
                                                      //   path: '/x',
                                                      //   value: undefined,
                                                      //   message: 'Expected number'
                                                      // }, {
-                                                     //   type: ValueErrorType.Number,
+                                                     //   type: 14,
                                                      //   schema: { type: 'number' },
                                                      //   path: '/y',
                                                      //   value: undefined,
                                                      //   message: 'Expected number'
                                                      // }, {
-                                                     //   type: ValueErrorType.Number,
+                                                     //   type: 14,
                                                      //   schema: { type: 'number' },
                                                      //   path: '/z',
                                                      //   value: undefined,
@@ -858,76 +858,78 @@ This project maintains a set of benchmarks that measure Ajv and TypeCompiler com
 
 For additional comparative benchmarks, please refer to [typescript-runtime-type-benchmarks](https://moltar.github.io/typescript-runtime-type-benchmarks/).
 
-### Validate
+### Compile
 
-This benchmark measures validation performance for varying types. You can review this benchmark [here](https://github.com/sinclairzx81/typebox/blob/master/benchmark/check.ts).
+This benchmark measures compilation performance for varying types. You can review this benchmark [here](https://github.com/sinclairzx81/typebox/blob/master/benchmark/compile.ts).
 
 ```typescript
 ┌──────────────────┬────────────┬──────────────┬──────────────┬──────────────┐
 │     (index)      │ Iterations │     Ajv      │ TypeCompiler │ Performance  │
 ├──────────────────┼────────────┼──────────────┼──────────────┼──────────────┤
-│           Number │  4000000   │ '     17 ms' │ '     16 ms' │ '    1.06 x' │
-│           String │  4000000   │ '     74 ms' │ '     37 ms' │ '    2.00 x' │
-│          Boolean │  4000000   │ '     68 ms' │ '     36 ms' │ '    1.89 x' │
-│             Null │  4000000   │ '     68 ms' │ '     36 ms' │ '    1.89 x' │
-│            RegEx │  4000000   │ '    170 ms' │ '    143 ms' │ '    1.19 x' │
-│          ObjectA │  4000000   │ '    122 ms' │ '     84 ms' │ '    1.45 x' │
-│          ObjectB │  4000000   │ '    182 ms' │ '    137 ms' │ '    1.33 x' │
-│            Tuple │  4000000   │ '     82 ms' │ '     48 ms' │ '    1.71 x' │
-│            Union │  4000000   │ '     84 ms' │ '     52 ms' │ '    1.62 x' │
-│        Recursive │  4000000   │ '   1526 ms' │ '    631 ms' │ '    2.42 x' │
-│          Vector4 │  4000000   │ '     80 ms' │ '     42 ms' │ '    1.90 x' │
-│          Matrix4 │  4000000   │ '    157 ms' │ '    113 ms' │ '    1.39 x' │
-│   Literal_String │  4000000   │ '     69 ms' │ '     36 ms' │ '    1.92 x' │
-│   Literal_Number │  4000000   │ '     69 ms' │ '     35 ms' │ '    1.97 x' │
-│  Literal_Boolean │  4000000   │ '     68 ms' │ '     35 ms' │ '    1.94 x' │
-│     Array_Number │  4000000   │ '    119 ms' │ '     60 ms' │ '    1.98 x' │
-│     Array_String │  4000000   │ '    119 ms' │ '     76 ms' │ '    1.57 x' │
-│    Array_Boolean │  4000000   │ '    131 ms' │ '     88 ms' │ '    1.49 x' │
-│    Array_ObjectA │  4000000   │ '  10615 ms' │ '   7053 ms' │ '    1.51 x' │
-│    Array_ObjectB │  4000000   │ '  11305 ms' │ '   8128 ms' │ '    1.39 x' │
-│      Array_Tuple │  4000000   │ '    355 ms' │ '    271 ms' │ '    1.31 x' │
-│      Array_Union │  4000000   │ '    910 ms' │ '    340 ms' │ '    2.68 x' │
-│  Array_Recursive │  4000000   │ '  29101 ms' │ '  10837 ms' │ '    2.69 x' │
-│    Array_Vector4 │  4000000   │ '    381 ms' │ '    212 ms' │ '    1.80 x' │
-│    Array_Matrix4 │  4000000   │ '   1534 ms' │ '   1344 ms' │ '    1.14 x' │
+│           Number │    2000    │ '    382 ms' │ '      8 ms' │ '   47.75 x' │
+│           String │    2000    │ '    305 ms' │ '      7 ms' │ '   43.57 x' │
+│          Boolean │    2000    │ '    305 ms' │ '      5 ms' │ '   61.00 x' │
+│             Null │    2000    │ '    253 ms' │ '      5 ms' │ '   50.60 x' │
+│            RegEx │    2000    │ '    475 ms' │ '     10 ms' │ '   47.50 x' │
+│          ObjectA │    2000    │ '   2812 ms' │ '     44 ms' │ '   63.91 x' │
+│          ObjectB │    2000    │ '   3045 ms' │ '     34 ms' │ '   89.56 x' │
+│            Tuple │    2000    │ '   1324 ms' │ '     19 ms' │ '   69.68 x' │
+│            Union │    2000    │ '   1347 ms' │ '     26 ms' │ '   51.81 x' │
+│          Vector4 │    2000    │ '   1635 ms' │ '     18 ms' │ '   90.83 x' │
+│          Matrix4 │    2000    │ '    928 ms' │ '     10 ms' │ '   92.80 x' │
+│   Literal_String │    2000    │ '    349 ms' │ '      5 ms' │ '   69.80 x' │
+│   Literal_Number │    2000    │ '    379 ms' │ '      5 ms' │ '   75.80 x' │
+│  Literal_Boolean │    2000    │ '    376 ms' │ '      6 ms' │ '   62.67 x' │
+│     Array_Number │    2000    │ '    733 ms' │ '     10 ms' │ '   73.30 x' │
+│     Array_String │    2000    │ '    766 ms' │ '      8 ms' │ '   95.75 x' │
+│    Array_Boolean │    2000    │ '    860 ms' │ '     11 ms' │ '   78.18 x' │
+│    Array_ObjectA │    2000    │ '   3668 ms' │ '     42 ms' │ '   87.33 x' │
+│    Array_ObjectB │    2000    │ '   3809 ms' │ '     41 ms' │ '   92.90 x' │
+│      Array_Tuple │    2000    │ '   2219 ms' │ '     17 ms' │ '  130.53 x' │
+│      Array_Union │    2000    │ '   1709 ms' │ '     26 ms' │ '   65.73 x' │
+│    Array_Vector4 │    2000    │ '   2301 ms' │ '     18 ms' │ '  127.83 x' │
+│    Array_Matrix4 │    2000    │ '   1594 ms' │ '     12 ms' │ '  132.83 x' │
 └──────────────────┴────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
-### Compile
+### Validate
 
-This benchmark measures compilation performance for varying types. You can review this benchmark [here](https://github.com/sinclairzx81/typebox/blob/master/benchmark/compile.ts).
+This benchmark measures validation performance for varying types. You can review this benchmark [here](https://github.com/sinclairzx81/typebox/blob/master/benchmark/check.ts).
 
 ```typescript
 ┌──────────────────┬────────────┬──────────────┬──────────────┬──────────────┐
 │     (index)      │ Iterations │     Ajv      │ TypeCompiler │ Performance  │
 ├──────────────────┼────────────┼──────────────┼──────────────┼──────────────┤
-│           Number │    2000    │ '    384 ms' │ '      7 ms' │ '   54.86 x' │
-│           String │    2000    │ '    311 ms' │ '      6 ms' │ '   51.83 x' │
-│          Boolean │    2000    │ '    304 ms' │ '      5 ms' │ '   60.80 x' │
-│             Null │    2000    │ '    252 ms' │ '      5 ms' │ '   50.40 x' │
-│            RegEx │    2000    │ '    480 ms' │ '      7 ms' │ '   68.57 x' │
-│          ObjectA │    2000    │ '   2786 ms' │ '     27 ms' │ '  103.19 x' │
-│          ObjectB │    2000    │ '   2946 ms' │ '     22 ms' │ '  133.91 x' │
-│            Tuple │    2000    │ '   1277 ms' │ '     16 ms' │ '   79.81 x' │
-│            Union │    2000    │ '   1288 ms' │ '     16 ms' │ '   80.50 x' │
-│          Vector4 │    2000    │ '   1628 ms' │ '     12 ms' │ '  135.67 x' │
-│          Matrix4 │    2000    │ '    912 ms' │ '      7 ms' │ '  130.29 x' │
-│   Literal_String │    2000    │ '    344 ms' │ '      5 ms' │ '   68.80 x' │
-│   Literal_Number │    2000    │ '    432 ms' │ '      5 ms' │ '   86.40 x' │
-│  Literal_Boolean │    2000    │ '    407 ms' │ '      4 ms' │ '  101.75 x' │
-│     Array_Number │    2000    │ '    788 ms' │ '      9 ms' │ '   87.56 x' │
-│     Array_String │    2000    │ '    823 ms' │ '      7 ms' │ '  117.57 x' │
-│    Array_Boolean │    2000    │ '    816 ms' │ '      5 ms' │ '  163.20 x' │
-│    Array_ObjectA │    2000    │ '   4270 ms' │ '     24 ms' │ '  177.92 x' │
-│    Array_ObjectB │    2000    │ '   4008 ms' │ '     28 ms' │ '  143.14 x' │
-│      Array_Tuple │    2000    │ '   2243 ms' │ '     13 ms' │ '  172.54 x' │
-│      Array_Union │    2000    │ '   1734 ms' │ '     16 ms' │ '  108.38 x' │
-│    Array_Vector4 │    2000    │ '   2348 ms' │ '     14 ms' │ '  167.71 x' │
-│    Array_Matrix4 │    2000    │ '   1608 ms' │ '     11 ms' │ '  146.18 x' │
+│           Number │  4000000   │ '     18 ms' │ '     16 ms' │ '    1.13 x' │
+│           String │  4000000   │ '     74 ms' │ '     43 ms' │ '    1.72 x' │
+│          Boolean │  4000000   │ '     71 ms' │ '     37 ms' │ '    1.92 x' │
+│             Null │  4000000   │ '     70 ms' │ '     37 ms' │ '    1.89 x' │
+│            RegEx │  4000000   │ '    175 ms' │ '    153 ms' │ '    1.14 x' │
+│          ObjectA │  4000000   │ '    124 ms' │ '     87 ms' │ '    1.43 x' │
+│          ObjectB │  4000000   │ '    215 ms' │ '    143 ms' │ '    1.50 x' │
+│            Tuple │  4000000   │ '    101 ms' │ '     51 ms' │ '    1.98 x' │
+│            Union │  4000000   │ '    108 ms' │ '     51 ms' │ '    2.12 x' │
+│        Recursive │  4000000   │ '   1647 ms' │ '    626 ms' │ '    2.63 x' │
+│          Vector4 │  4000000   │ '     83 ms' │ '     41 ms' │ '    2.02 x' │
+│          Matrix4 │  4000000   │ '    154 ms' │ '    105 ms' │ '    1.47 x' │
+│   Literal_String │  4000000   │ '    101 ms' │ '     37 ms' │ '    2.73 x' │
+│   Literal_Number │  4000000   │ '     69 ms' │ '     35 ms' │ '    1.97 x' │
+│  Literal_Boolean │  4000000   │ '     71 ms' │ '     35 ms' │ '    2.03 x' │
+│     Array_Number │  4000000   │ '    117 ms' │ '     61 ms' │ '    1.92 x' │
+│     Array_String │  4000000   │ '    116 ms' │ '     73 ms' │ '    1.59 x' │
+│    Array_Boolean │  4000000   │ '    129 ms' │ '     89 ms' │ '    1.45 x' │
+│    Array_ObjectA │  4000000   │ '  10582 ms' │ '   6854 ms' │ '    1.54 x' │
+│    Array_ObjectB │  4000000   │ '  11539 ms' │ '   8224 ms' │ '    1.40 x' │
+│      Array_Tuple │  4000000   │ '    362 ms' │ '    282 ms' │ '    1.28 x' │
+│      Array_Union │  4000000   │ '    950 ms' │ '    355 ms' │ '    2.68 x' │
+│  Array_Recursive │  4000000   │ '  28047 ms' │ '   9567 ms' │ '    2.93 x' │
+│    Array_Vector4 │  4000000   │ '    372 ms' │ '    200 ms' │ '    1.86 x' │
+│    Array_Matrix4 │  4000000   │ '   1521 ms' │ '   1244 ms' │ '    1.22 x' │
 └──────────────────┴────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
+
+
 ## Contribute
 
 TypeBox is open to community contribution. Please ensure you submit an open issue before submitting your pull request. The TypeBox project preferences open community discussion prior to accepting new features.

package/value/cast.d.ts

@@ -1,4 +1,8 @@
 import * as Types from '../typebox';
+export declare class ValueCastInvalidTypeError extends Error {
+    readonly schema: Types.TSchema;
+    constructor(schema: Types.TSchema);
+}
 export declare namespace ValueCast {
     function Visit(schema: Types.TSchema, references: Types.TSchema[], value: any): any;
     function Cast<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: any): Types.Static<T>;

package/value/cast.js

@@ -27,8 +27,9 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueCast = void 0;
+exports.ValueCast = exports.ValueCastInvalidTypeError = void 0;
 const Types = require("../typebox");
+const index_1 = require("../guard/index");
 const create_1 = require("./create");
 const check_1 = require("./check");
 // --------------------------------------------------------------------------
@@ -71,6 +72,13 @@ var UnionValueCast;
     }
     UnionValueCast.Create = Create;
 })(UnionValueCast || (UnionValueCast = {}));
+class ValueCastInvalidTypeError extends Error {
+    constructor(schema) {
+        super('ValueCast: Invalid type');
+        this.schema = schema;
+    }
+}
+exports.ValueCastInvalidTypeError = ValueCastInvalidTypeError;
 var ValueCast;
 (function (ValueCast) {
     function Any(schema, references, value) {
@@ -189,57 +197,72 @@ var ValueCast;
         return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
     }
     function Visit(schema, references, value) {
-        const anyReferences = schema.$id === undefined ? references : [schema, ...references];
-        const anySchema = schema;
-        switch (schema[Types.Kind]) {
-            case 'Any':
-                return Any(anySchema, anyReferences, value);
-            case 'Array':
-                return Array(anySchema, anyReferences, value);
-            case 'Boolean':
-                return Boolean(anySchema, anyReferences, value);
-            case 'Constructor':
-                return Constructor(anySchema, anyReferences, value);
-            case 'Enum':
-                return Enum(anySchema, anyReferences, value);
-            case 'Function':
-                return Function(anySchema, anyReferences, value);
-            case 'Integer':
-                return Integer(anySchema, anyReferences, value);
-            case 'Literal':
-                return Literal(anySchema, anyReferences, value);
-            case 'Null':
-                return Null(anySchema, anyReferences, value);
-            case 'Number':
-                return Number(anySchema, anyReferences, value);
-            case 'Object':
-                return Object(anySchema, anyReferences, value);
-            case 'Promise':
-                return Promise(anySchema, anyReferences, value);
-            case 'Record':
-                return Record(anySchema, anyReferences, value);
-            case 'Rec':
-                return Recursive(anySchema, anyReferences, value);
-            case 'Ref':
-                return Ref(anySchema, anyReferences, value);
-            case 'Self':
-                return Self(anySchema, anyReferences, value);
-            case 'String':
-                return String(anySchema, anyReferences, value);
-            case 'Tuple':
-                return Tuple(anySchema, anyReferences, value);
-            case 'Undefined':
-                return Undefined(anySchema, anyReferences, value);
-            case 'Union':
-                return Union(anySchema, anyReferences, value);
-            case 'Uint8Array':
-                return Uint8Array(anySchema, anyReferences, value);
-            case 'Unknown':
-                return Unknown(anySchema, anyReferences, value);
-            case 'Void':
-                return Void(anySchema, anyReferences, value);
-            default:
-                throw Error(`ValueCast.Visit: Unknown schema kind '${schema[Types.Kind]}'`);
+        const refs = schema.$id === undefined ? references : [schema, ...references];
+        if (index_1.TypeGuard.TAny(schema)) {
+            return Any(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TArray(schema)) {
+            return Array(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TBoolean(schema)) {
+            return Boolean(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TConstructor(schema)) {
+            return Constructor(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TFunction(schema)) {
+            return Function(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TInteger(schema)) {
+            return Integer(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TLiteral(schema)) {
+            return Literal(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TNull(schema)) {
+            return Null(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TNumber(schema)) {
+            return Number(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TObject(schema)) {
+            return Object(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TPromise(schema)) {
+            return Promise(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TRecord(schema)) {
+            return Record(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TRef(schema)) {
+            return Ref(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TSelf(schema)) {
+            return Self(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TString(schema)) {
+            return String(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TTuple(schema)) {
+            return Tuple(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TUndefined(schema)) {
+            return Undefined(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TUnion(schema)) {
+            return Union(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TUint8Array(schema)) {
+            return Uint8Array(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TUnknown(schema)) {
+            return Unknown(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TVoid(schema)) {
+            return Void(schema, refs, value);
+        }
+        else {
+            throw new ValueCastInvalidTypeError(schema);
         }
     }
     ValueCast.Visit = Visit;

package/value/check.d.ts

@@ -1,4 +1,8 @@
 import * as Types from '../typebox';
+export declare class ValueCheckInvalidTypeError extends Error {
+    readonly schema: Types.TSchema;
+    constructor(schema: Types.TSchema);
+}
 export declare namespace ValueCheck {
     function Check<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: any): boolean;
 }