@sinclair/typebox 0.24.25 → 0.24.28

package/guard/guard.js

@@ -27,8 +27,15 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeGuard = void 0;
+exports.TypeGuard = exports.TypeGuardInvalidTypeError = void 0;
 const Types = require("../typebox");
+class TypeGuardInvalidTypeError extends Error {
+    constructor(schema) {
+        super('TypeGuard: Invalid type');
+        this.schema = schema;
+    }
+}
+exports.TypeGuardInvalidTypeError = TypeGuardInvalidTypeError;
 /** TypeGuard tests that values conform to a known TypeBox type specification */
 var TypeGuard;
 (function (TypeGuard) {
@@ -47,6 +54,17 @@ var TypeGuard;
             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';
     }
@@ -66,26 +84,33 @@ var TypeGuard;
         return value === undefined || (value !== undefined && IsString(value));
     }
     function IsOptionalPattern(value) {
-        return value === undefined || (value !== undefined && IsPattern(value));
+        return value === undefined || (value !== undefined && IsString(value) && IsPattern(value));
     }
     /** Returns true if the given schema is TAny */
     function TAny(schema) {
-        return IsObject(schema) && schema[Types.Kind] === 'Any';
+        return IsObject(schema) && schema[Types.Kind] === 'Any' && IsOptionalString(schema.$id);
     }
     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) && IsOptionalNumber(schema.minItems) && IsOptionalNumber(schema.maxItems);
+        return (IsObject(schema) &&
+            schema[Types.Kind] === 'Array' &&
+            schema.type === 'array' &&
+            IsOptionalString(schema.$id) &&
+            TSchema(schema.items) &&
+            IsOptionalNumber(schema.minItems) &&
+            IsOptionalNumber(schema.maxItems) &&
+            IsOptionalBoolean(schema.uniqueItems));
     }
     TypeGuard.TArray = TArray;
     /** Returns true if the given schema is TBoolean */
     function TBoolean(schema) {
-        return IsObject(schema) && schema[Types.Kind] === 'Boolean' && schema.type === 'boolean';
+        return IsObject(schema) && schema[Types.Kind] === 'Boolean' && schema.type === 'boolean' && IsOptionalString(schema.$id);
     }
     TypeGuard.TBoolean = TBoolean;
     /** Returns true if the given schema is TConstructor */
     function TConstructor(schema) {
-        if (!(IsObject(schema) && schema[Types.Kind] === 'Constructor' && schema.type === 'constructor' && IsArray(schema.parameters) && TSchema(schema.returns))) {
+        if (!(IsObject(schema) && schema[Types.Kind] === 'Constructor' && schema.type === 'constructor' && IsOptionalString(schema.$id) && IsArray(schema.parameters) && TSchema(schema.returns))) {
             return false;
         }
         for (const parameter of schema.parameters) {
@@ -97,7 +122,7 @@ var TypeGuard;
     TypeGuard.TConstructor = TConstructor;
     /** Returns true if the given schema is TFunction */
     function TFunction(schema) {
-        if (!(IsObject(schema) && schema[Types.Kind] === 'Function' && schema.type === 'function' && IsArray(schema.parameters) && TSchema(schema.returns))) {
+        if (!(IsObject(schema) && schema[Types.Kind] === 'Function' && schema.type === 'function' && IsOptionalString(schema.$id) && IsArray(schema.parameters) && TSchema(schema.returns))) {
             return false;
         }
         for (const parameter of schema.parameters) {
@@ -112,6 +137,7 @@ var TypeGuard;
         return (IsObject(schema) &&
             schema[Types.Kind] === 'Integer' &&
             schema.type === 'integer' &&
+            IsOptionalString(schema.$id) &&
             IsOptionalNumber(schema.multipleOf) &&
             IsOptionalNumber(schema.minimum) &&
             IsOptionalNumber(schema.maximum) &&
@@ -121,12 +147,12 @@ var TypeGuard;
     TypeGuard.TInteger = TInteger;
     /** Returns true if the given schema is TLiteral */
     function TLiteral(schema) {
-        return IsObject(schema) && schema[Types.Kind] === 'Literal' && (IsString(schema.const) || IsNumber(schema.const) || IsBoolean(schema.const));
+        return IsObject(schema) && schema[Types.Kind] === 'Literal' && IsOptionalString(schema.$id) && (IsString(schema.const) || IsNumber(schema.const) || IsBoolean(schema.const));
     }
     TypeGuard.TLiteral = TLiteral;
     /** Returns true if the given schema is TNull */
     function TNull(schema) {
-        return IsObject(schema) && schema[Types.Kind] === 'Null' && schema.type === 'null';
+        return IsObject(schema) && schema[Types.Kind] === 'Null' && schema.type === 'null' && IsOptionalString(schema.$id);
     }
     TypeGuard.TNull = TNull;
     /** Returns true if the given schema is TNumber */
@@ -134,6 +160,7 @@ var TypeGuard;
         return (IsObject(schema) &&
             schema[Types.Kind] === 'Number' &&
             schema.type === 'number' &&
+            IsOptionalString(schema.$id) &&
             IsOptionalNumber(schema.multipleOf) &&
             IsOptionalNumber(schema.minimum) &&
             IsOptionalNumber(schema.maximum) &&
@@ -146,14 +173,17 @@ var TypeGuard;
         if (!(IsObject(schema) &&
             schema[Types.Kind] === 'Object' &&
             schema.type === 'object' &&
+            IsOptionalString(schema.$id) &&
             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;
@@ -161,12 +191,12 @@ var TypeGuard;
     TypeGuard.TObject = TObject;
     /** Returns true if the given schema is TPromise */
     function TPromise(schema) {
-        return IsObject(schema) && schema[Types.Kind] === 'Promise' && schema.type === 'promise' && TSchema(schema.item);
+        return IsObject(schema) && schema[Types.Kind] === 'Promise' && schema.type === 'promise' && IsOptionalString(schema.$id) && TSchema(schema.item);
     }
     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' && IsOptionalString(schema.$id) && schema.additionalProperties === false && IsObject(schema.patternProperties))) {
             return false;
         }
         const keys = Object.keys(schema.patternProperties);
@@ -184,22 +214,29 @@ var TypeGuard;
     TypeGuard.TRecord = TRecord;
     /** Returns true if the given schema is TSelf */
     function TSelf(schema) {
-        return IsObject(schema) && schema[Types.Kind] === 'Self' && IsString(schema.$ref);
+        return IsObject(schema) && schema[Types.Kind] === 'Self' && IsOptionalString(schema.$id) && IsString(schema.$ref);
     }
     TypeGuard.TSelf = TSelf;
     /** Returns true if the given schema is TRef */
     function TRef(schema) {
-        return IsObject(schema) && schema[Types.Kind] === 'Ref' && IsString(schema.$ref);
+        return IsObject(schema) && schema[Types.Kind] === 'Ref' && IsOptionalString(schema.$id) && 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' && IsOptionalNumber(schema.minLength) && IsOptionalNumber(schema.maxLength) && IsOptionalPattern(schema.pattern) && IsOptionalString(schema.format);
+        return (IsObject(schema) &&
+            schema[Types.Kind] === 'String' &&
+            schema.type === 'string' &&
+            IsOptionalString(schema.$id) &&
+            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' && IsNumber(schema.minItems) && IsNumber(schema.maxItems) && schema.minItems === schema.maxItems)) {
+        if (!(IsObject(schema) && schema[Types.Kind] === 'Tuple' && schema.type === 'array' && IsOptionalString(schema.$id) && IsNumber(schema.minItems) && IsNumber(schema.maxItems) && schema.minItems === schema.maxItems)) {
             return false;
         }
         if (schema.items === undefined && schema.additionalItems === undefined && schema.minItems === 0) {
@@ -217,12 +254,12 @@ var TypeGuard;
     TypeGuard.TTuple = TTuple;
     /** Returns true if the given schema is TUndefined */
     function TUndefined(schema) {
-        return IsObject(schema) && schema[Types.Kind] === 'Undefined' && schema.type === 'object' && schema.specialized === 'Undefined';
+        return IsObject(schema) && schema[Types.Kind] === 'Undefined' && schema.type === 'object' && IsOptionalString(schema.$id) && schema.specialized === 'Undefined';
     }
     TypeGuard.TUndefined = TUndefined;
     /** Returns true if the given schema is TUnion */
     function TUnion(schema) {
-        if (!(IsObject(schema) && schema[Types.Kind] === 'Union' && IsArray(schema.anyOf))) {
+        if (!(IsObject(schema) && schema[Types.Kind] === 'Union' && IsArray(schema.anyOf) && IsOptionalString(schema.$id))) {
             return false;
         }
         for (const inner of schema.anyOf) {
@@ -234,17 +271,23 @@ 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' && IsOptionalNumber(schema.minByteLength) && IsOptionalNumber(schema.maxByteLength);
+        return (IsObject(schema) &&
+            schema[Types.Kind] === 'Uint8Array' &&
+            schema.type === 'object' &&
+            IsOptionalString(schema.$id) &&
+            schema.specialized === 'Uint8Array' &&
+            IsOptionalNumber(schema.minByteLength) &&
+            IsOptionalNumber(schema.maxByteLength));
     }
     TypeGuard.TUint8Array = TUint8Array;
     /** Returns true if the given schema is TUnknown */
     function TUnknown(schema) {
-        return IsObject(schema) && schema[Types.Kind] === 'Unknown';
+        return IsObject(schema) && schema[Types.Kind] === 'Unknown' && IsOptionalString(schema.$id);
     }
     TypeGuard.TUnknown = TUnknown;
     /** Returns true if the given schema is TVoid */
     function TVoid(schema) {
-        return IsObject(schema) && schema[Types.Kind] === 'Void' && schema.type === 'null';
+        return IsObject(schema) && schema[Types.Kind] === 'Void' && schema.type === 'null' && IsOptionalString(schema.$id);
     }
     TypeGuard.TVoid = TVoid;
     /** Returns true if the given schema is TSchema */
@@ -272,4 +315,14 @@ var TypeGuard;
             TVoid(schema));
     }
     TypeGuard.TSchema = TSchema;
+    /** Asserts if this schema and associated references are valid. */
+    function Assert(schema, references = []) {
+        if (!TSchema(schema))
+            throw new TypeGuardInvalidTypeError(schema);
+        for (const schema of references) {
+            if (!TSchema(schema))
+                throw new TypeGuardInvalidTypeError(schema);
+        }
+    }
+    TypeGuard.Assert = Assert;
 })(TypeGuard = exports.TypeGuard || (exports.TypeGuard = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.24.25",
+  "version": "0.24.28",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
@@ -26,7 +26,7 @@
     "publish": "hammer task publish"
   },
   "devDependencies": {
-    "@sinclair/hammer": "^0.16.3",
+    "@sinclair/hammer": "^0.17.0",
     "@types/chai": "^4.3.0",
     "@types/mocha": "^9.1.0",
     "@types/node": "^17.0.12",

package/readme.md

@@ -19,16 +19,16 @@
 
 ## Install
 
-#### Node
+Node
 
 ```bash
 $ npm install @sinclair/typebox --save
 ```
 
-#### Deno
+Deno and ESM
 
 ```typescript
-import { Static, Type } from 'https://deno.land/x/typebox/src/typebox.ts'
+import { Static, Type } from 'https://esm.sh/@sinclair/typebox'
 ```
 
 ## Example
@@ -45,9 +45,9 @@ type T = Static<typeof T>   // type T = string
 
 ## Overview
 
-TypeBox is a type builder library that creates in-memory JSON Schema objects that can be statically inferred as TypeScript types. The schemas produced by this library are designed to match the static type checking rules of the TypeScript compiler. TypeBox enables one to create unified types that can be statically checked by TypeScript and runtime asserted using standard JSON Schema validation.
+TypeBox is a type builder library that creates in-memory JSON Schema objects that can be statically inferred as TypeScript types. The schemas produced by this library are designed to match the static type checking rules of the TypeScript compiler. TypeBox enables one to create a unified type that can be statically checked by TypeScript and runtime asserted using standard JSON Schema validation.
 
-TypeBox can be used as a simple tool to build up complex schemas or integrated into RPC or REST services to help validate JSON data received over the wire.
+TypeBox is designed to enable JSON schema to compose with the same flexibility as TypeScript's type system. It can be used either as a simple tool to build up complex schemas or integrated into REST and RPC services to help validate data received over the wire. 
 
 License MIT
 
@@ -194,7 +194,7 @@ The following table outlines the TypeBox mappings between TypeScript and JSON sc
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Literal(42)     │ type T = 42                 │ const T = {                    │
-│                                │                             │    const: 42                   │
+│                                │                             │    const: 42,                  │
 │                                │                             │    type: 'number'              │
 │                                │                             │ }                              │
 │                                │                             │                                │
@@ -506,9 +506,8 @@ type Node = Static<typeof Node>                      // type Node = {
                                                      // }
 
 function test(node: Node) {
-  const id = node.nodes[0].nodes[0].nodes[0]         // id is string
-                 .nodes[0].nodes[0].nodes[0]
-                 .nodes[0].nodes[0].nodes[0]
+  const id = node.nodes[0].nodes[0]                  // id is string
+                 .nodes[0].nodes[0]
                  .id
 }
 ```
@@ -555,7 +554,7 @@ const T = Type.Unsafe<string>({ type: 'number' })    // const T = {
 type T = Static<typeof T>                            // type T = string
 ```
 
-The `Type.Unsafe(...)` function can be used to create schemas for validators that require specific schema representations. An example of this would be OpenAPI's `nullable` and `enum` schemas which are not provided by TypeBox. The following demonstrates using `Type.Unsafe(...)` to create these types.
+This function can be used to create custom schemas for validators that require specific schema representations. An example of this might be OpenAPI's `nullable` and `enum` schemas which are not provided by TypeBox. The following demonstrates using `Type.Unsafe(...)` to create these types.
 
 ```typescript
 import { Type, Static, TSchema } from '@sinclair/typebox'
@@ -577,6 +576,7 @@ const T = Nullable(Type.String())                    // const T = {
 
 type T = Static<typeof T>                            // type T = string | null
 
+
 //--------------------------------------------------------------------------------------------
 //
 // StringEnum<string[]>
@@ -596,7 +596,9 @@ type T = Static<typeof T>                            // type T = 'A' | 'B' | 'C'
 
 ## Conditional Types
 
-Use `Conditional.Extends(...)` to create conditional mapped types.
+Use the conditional module to create [Conditional Types](https://www.typescriptlang.org/docs/handbook/2/conditional-types.html). This module implements TypeScript's structural equivalence checks to enable TypeBox types to be conditionally inferred at runtime. This module also provides the [Extract](https://www.typescriptlang.org/docs/handbook/utility-types.html#extracttype-union) and [Exclude](https://www.typescriptlang.org/docs/handbook/utility-types.html#excludeuniontype-excludedmembers) utility types which are expressed as conditional types in TypeScript. 
+
+The conditional module is provided as an optional import.
 
 ```typescript
 import { Conditional } from '@sinclair/typebox/conditional'
@@ -645,46 +647,56 @@ The following table shows the TypeBox mappings between TypeScript and JSON schem
 
 ## Values
 
-Use `Value.Create(...)` to generate values from types.
+Use the value module to perform common type operations on values. This module provides functionality to create, check and cast values into a given type. Note that this module internally uses dynamic type checking to perform these operations. For faster type checking performance, consider using either Ajv or the TypeBox [TypeCompiler](#compiler).
+
+ The value module is provided as an optional import.
 
 ```typescript
 import { Value } from '@sinclair/typebox/value'
-import { Type } from '@sinclair/typebox'
-
-const T = Type.Object({
-  x: Type.Number({ default: 1 }),
-  y: Type.Number()
-})
-
-const V = Value.Create(T)                            // const V = {
-                                                     //   x: 1,
-                                                     //   y: 0
-                                                     // }
 ```
-Use `Value.Cast(...)` to cast a value into a given type.
+The following demonstrates its use.
 ```typescript
-import { Value } from '@sinclair/typebox/value'
-import { Type } from '@sinclair/typebox'
 
-const T = Type.Object({
-  x: Type.Number(),
-  y: Type.Number()
-})
 
-const A = Value.Cast(T, null)                          // const A = { x: 0, y: 0 }
+const T = Type.Object({ x: Type.Number(), y: Type.Number() }, { additionalProperties: false })
+
+//--------------------------------------------------------------------------------------------
+//
+// Use Value.Create(T) to create a value from T.
+//
+//--------------------------------------------------------------------------------------------
+
+const V = Value.Create(T)                            // const V = { x: 0, y: 0 }
+
+//--------------------------------------------------------------------------------------------
+//
+// Use Value.Check(T, ...) to check if a value is of type T.
+//
+//--------------------------------------------------------------------------------------------
+
+const R = Value.Check(T, { x: 1 })                   // const R = false
+
+//--------------------------------------------------------------------------------------------
+//
+// Use Value.Cast(T, ...) to immutably cast a value into T.
+//
+//--------------------------------------------------------------------------------------------
+
+const A = Value.Cast(T, null)                        // const A = { x: 0, y: 0 }
+
+const B = Value.Cast(T, { x: 1 })                    // const B = { x: 1, y: 0 }
+
+const C = Value.Cast(T, { x: 1, y: 2, z: 3 })        // const C = { x: 1, y: 2 }
 
-const B = Value.Cast(T, { x: 1 })                      // const B = { x: 1, y: 0 }
 
-const C = Value.Cast(T, { x: 1, y: 2, z: 3 })          // const C = { x: 1, y: 2 }
 ```
 
 ## Guards
 
-Use a `TypeGuard` to test if a value meets a TypeBox type specification. Guards can be helpful when reflecting types.
+Use the guard module to test if values are TypeBox types.
 
 ```typescript
 import { TypeGuard } from '@sinclair/typebox/guard'
-import { Type }  from '@sinclair/typebox'
 
 const T = Type.String()
 
@@ -692,7 +704,6 @@ if(TypeGuard.TString(T)) {
     
   // T is TString
 }
-
 ```
 
 ## Strict
@@ -789,14 +800,17 @@ Please refer to the official Ajv [documentation](https://ajv.js.org/guide/gettin
 
 ## Compiler
 
-TypeBox provides an optional high performance runtime type checker that can be used in applications that require extremely fast validation. This type checker is optimized for TypeBox types only whose schematics are known in advance. If defining custom schemas with `Type.Unsafe<T>` please consider Ajv.
+TypeBox provides an optional high performance just-in-time (JIT) compiler and type checker that can be used in applications that require extremely fast validation. Note that this compiler is optimized for TypeBox types only where the schematics are known in advance. If defining custom types with `Type.Unsafe<T>` please consider Ajv.
 
-The following demonstrates its use.
+The compiler module is provided as an optional import.
 
 ```typescript
 import { TypeCompiler } from '@sinclair/typebox/compiler'
-import { Type } from '@sinclair/typebox'
+```
+
+Use the `Compile(...)` function to compile a type.
 
+```typescript
 const C = TypeCompiler.Compile(Type.Object({         // const C: TypeCheck<TObject<{
   x: Type.Number(),                                  //     x: TNumber;
   y: Type.Number(),                                  //     y: TNumber;
@@ -818,19 +832,16 @@ const C = TypeCompiler.Compile(Type.Object({         // const C: TypeCheck<TObje
 const value = { }
 
 const errors = [...C.Errors(value)]                  // const errors = [{
-                                                     //   type: 14,
                                                      //   schema: { type: 'number' },
                                                      //   path: '/x',
                                                      //   value: undefined,
                                                      //   message: 'Expected number'
                                                      // }, {
-                                                     //   type: 14,
                                                      //   schema: { type: 'number' },
                                                      //   path: '/y',
                                                      //   value: undefined,
                                                      //   message: 'Expected number'
                                                      // }, {
-                                                     //   type: 14,
                                                      //   schema: { type: 'number' },
                                                      //   path: '/z',
                                                      //   value: undefined,
@@ -854,81 +865,95 @@ console.log(C.Code())                                // return function check(va
 
 ## Benchmark
 
-This project maintains a set of benchmarks that measure Ajv 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.0. 
 
 For additional comparative benchmarks, please refer to [typescript-runtime-type-benchmarks](https://moltar.github.io/typescript-runtime-type-benchmarks/).
 
 ### Compile
 
-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 compilation performance for varying types. You can review this benchmark [here](https://github.com/sinclairzx81/typebox/blob/master/benchmark/measurement/module/compile.ts).
 
 ```typescript
 ┌──────────────────┬────────────┬──────────────┬──────────────┬──────────────┐
 │     (index)      │ Iterations │     Ajv      │ TypeCompiler │ Performance  │
 ├──────────────────┼────────────┼──────────────┼──────────────┼──────────────┤
-│           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' │
+│           Number │    2000    │ '    399 ms' │ '      9 ms' │ '   44.33 x' │
+│           String │    2000    │ '    306 ms' │ '      8 ms' │ '   38.25 x' │
+│          Boolean │    2000    │ '    315 ms' │ '      5 ms' │ '   63.00 x' │
+│             Null │    2000    │ '    255 ms' │ '      6 ms' │ '   42.50 x' │
+│            RegEx │    2000    │ '    478 ms' │ '     10 ms' │ '   47.80 x' │
+│          ObjectA │    2000    │ '   2850 ms' │ '     39 ms' │ '   73.08 x' │
+│          ObjectB │    2000    │ '   3027 ms' │ '     34 ms' │ '   89.03 x' │
+│            Tuple │    2000    │ '   1374 ms' │ '     27 ms' │ '   50.89 x' │
+│            Union │    2000    │ '   1307 ms' │ '     22 ms' │ '   59.41 x' │
+│          Vector4 │    2000    │ '   1568 ms' │ '     17 ms' │ '   92.24 x' │
+│          Matrix4 │    2000    │ '    911 ms' │ '     11 ms' │ '   82.82 x' │
+│   Literal_String │    2000    │ '    332 ms' │ '      8 ms' │ '   41.50 x' │
+│   Literal_Number │    2000    │ '    363 ms' │ '      8 ms' │ '   45.38 x' │
+│  Literal_Boolean │    2000    │ '    360 ms' │ '      5 ms' │ '   72.00 x' │
+│     Array_Number │    2000    │ '    704 ms' │ '      6 ms' │ '  117.33 x' │
+│     Array_String │    2000    │ '    745 ms' │ '     11 ms' │ '   67.73 x' │
+│    Array_Boolean │    2000    │ '    781 ms' │ '      7 ms' │ '  111.57 x' │
+│    Array_ObjectA │    2000    │ '   3552 ms' │ '     31 ms' │ '  114.58 x' │
+│    Array_ObjectB │    2000    │ '   3738 ms' │ '     33 ms' │ '  113.27 x' │
+│      Array_Tuple │    2000    │ '   2336 ms' │ '     16 ms' │ '  146.00 x' │
+│      Array_Union │    2000    │ '   1758 ms' │ '     20 ms' │ '   87.90 x' │
+│    Array_Vector4 │    2000    │ '   2305 ms' │ '     16 ms' │ '  144.06 x' │
+│    Array_Matrix4 │    2000    │ '   1635 ms' │ '     11 ms' │ '  148.64 x' │
 └──────────────────┴────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
 ### Validate
 
-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 validation performance for varying types. You can review this benchmark [here](https://github.com/sinclairzx81/typebox/blob/master/benchmark/measurement/module/check.ts).
 
 ```typescript
-┌──────────────────┬────────────┬──────────────┬──────────────┬──────────────┐
-│     (index)      │ Iterations │     Ajv      │ TypeCompiler │ Performance  │
-├──────────────────┼────────────┼──────────────┼──────────────┼──────────────┤
-│           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' │
-└──────────────────┴────────────┴──────────────┴──────────────┴──────────────┘
+┌──────────────────┬────────────┬──────────────┬──────────────┬──────────────┬──────────────┐
+│     (index)      │ Iterations │  ValueCheck  │     Ajv      │ TypeCompiler │ Performance  │
+├──────────────────┼────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
+│           Number │  1000000   │ '     31 ms' │ '      6 ms' │ '      5 ms' │ '    1.20 x' │
+│           String │  1000000   │ '     26 ms' │ '     22 ms' │ '     12 ms' │ '    1.83 x' │
+│          Boolean │  1000000   │ '     21 ms' │ '     22 ms' │ '     11 ms' │ '    2.00 x' │
+│             Null │  1000000   │ '     25 ms' │ '     24 ms' │ '      9 ms' │ '    2.67 x' │
+│            RegEx │  1000000   │ '    166 ms' │ '     45 ms' │ '     38 ms' │ '    1.18 x' │
+│          ObjectA │  1000000   │ '    535 ms' │ '     36 ms' │ '     22 ms' │ '    1.64 x' │
+│          ObjectB │  1000000   │ '    957 ms' │ '     49 ms' │ '     37 ms' │ '    1.32 x' │
+│            Tuple │  1000000   │ '    112 ms' │ '     24 ms' │ '     14 ms' │ '    1.71 x' │
+│            Union │  1000000   │ '    304 ms' │ '     25 ms' │ '     14 ms' │ '    1.79 x' │
+│        Recursive │  1000000   │ '   2986 ms' │ '    391 ms' │ '    164 ms' │ '    2.38 x' │
+│          Vector4 │  1000000   │ '    145 ms' │ '     22 ms' │ '     13 ms' │ '    1.69 x' │
+│          Matrix4 │  1000000   │ '    575 ms' │ '     39 ms' │ '     29 ms' │ '    1.34 x' │
+│   Literal_String │  1000000   │ '     44 ms' │ '     18 ms' │ '     10 ms' │ '    1.80 x' │
+│   Literal_Number │  1000000   │ '     46 ms' │ '     19 ms' │ '      9 ms' │ '    2.11 x' │
+│  Literal_Boolean │  1000000   │ '     47 ms' │ '     19 ms' │ '      9 ms' │ '    2.11 x' │
+│     Array_Number │  1000000   │ '    398 ms' │ '     30 ms' │ '     17 ms' │ '    1.76 x' │
+│     Array_String │  1000000   │ '    438 ms' │ '     30 ms' │ '     20 ms' │ '    1.50 x' │
+│    Array_Boolean │  1000000   │ '    443 ms' │ '     37 ms' │ '     24 ms' │ '    1.54 x' │
+│    Array_ObjectA │  1000000   │ '  13702 ms' │ '   2649 ms' │ '   1673 ms' │ '    1.58 x' │
+│    Array_ObjectB │  1000000   │ '  16091 ms' │ '   2964 ms' │ '   2032 ms' │ '    1.46 x' │
+│      Array_Tuple │  1000000   │ '   1665 ms' │ '     92 ms' │ '     70 ms' │ '    1.31 x' │
+│      Array_Union │  1000000   │ '   4631 ms' │ '    220 ms' │ '     88 ms' │ '    2.50 x' │
+│  Array_Recursive │  1000000   │ '  53745 ms' │ '   6891 ms' │ '   2744 ms' │ '    2.51 x' │
+│    Array_Vector4 │  1000000   │ '   2156 ms' │ '    105 ms' │ '     55 ms' │ '    1.91 x' │
+│    Array_Matrix4 │  1000000   │ '  11686 ms' │ '    388 ms' │ '    330 ms' │ '    1.18 x' │
+└──────────────────┴────────────┴──────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
+### Compression
+
+The following table lists esbuild compiled and minified sizes for each TypeBox module.
 
+```typescript
+┌──────────────────────┬────────────┬────────────┬─────────────┐
+│       (index)        │  Compiled  │  Minified  │ Compression │
+├──────────────────────┼────────────┼────────────┼─────────────┤
+│ typebox/compiler     │ '   47 kb' │ '   23 kb' │  '1.99 x'   │
+│ typebox/conditional  │ '   41 kb' │ '   16 kb' │  '2.47 x'   │
+│ typebox/guard        │ '   20 kb' │ '    9 kb' │  '2.08 x'   │
+│ typebox/value        │ '   55 kb' │ '   25 kb' │  '2.15 x'   │
+│ typebox              │ '   11 kb' │ '    5 kb' │  '1.91 x'   │
+└──────────────────────┴────────────┴────────────┴─────────────┘
+```
 
 ## Contribute