@sinclair/typebox 0.24.27 → 0.24.30

package/compiler/compiler.js

@@ -30,6 +30,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypeCompiler = exports.TypeCompilerUnknownTypeError = exports.Property = exports.TypeCheck = void 0;
 const index_1 = require("../errors/index");
 const index_2 = require("../guard/index");
+const index_3 = require("../format/index");
 const Types = require("../typebox");
 // -------------------------------------------------------------------
 // TypeCheck
@@ -174,7 +175,7 @@ var TypeCompiler;
             yield `(Object.keys(${value}).length <= ${schema.maxProperties})`;
         const propertyKeys = globalThis.Object.keys(schema.properties);
         if (schema.additionalProperties === false) {
-            // optimization: If the property key length matches the required keys length
+            // Optimization: If the property key length matches the required keys length
             // then we only need check that the values property key length matches that
             // of the property key length. This is because exhaustive testing for values
             // will occur in subsequent property tests.
@@ -210,6 +211,11 @@ var TypeCompiler;
         yield `(Object.values(${value}).every(value => ${expression}))`;
     }
     function* Ref(schema, value) {
+        // Reference: If we have seen this reference before we can just yield and return
+        // the function call. If this isn't the case we defer to visit to generate and
+        // set the function for subsequent passes. Consider for refactor.
+        if (names.has(schema.$ref))
+            return yield `(${CreateFunctionName(schema.$ref)}(${value}))`;
         if (!referenceMap.has(schema.$ref))
             throw Error(`TypeCompiler.Ref: Cannot de-reference schema with $id '${schema.$ref}'`);
         const reference = referenceMap.get(schema.$ref);
@@ -231,6 +237,9 @@ var TypeCompiler;
             const local = PushLocal(`new RegExp(/${schema.pattern}/);`);
             yield `(${local}.test(${value}))`;
         }
+        if (schema.format !== undefined) {
+            yield `(format('${schema.format}', ${value}))`;
+        }
     }
     function* Tuple(schema, value) {
         yield `(Array.isArray(${value}))`;
@@ -263,9 +272,9 @@ var TypeCompiler;
         yield `(${value} === null)`;
     }
     function* Visit(schema, value) {
-        // reference: referenced schemas can originate from either additional
-        // schemas or inline in the schema itself. Ideally the recursive
-        // path should align to reference path. Consider for review.
+        // Reference: Referenced schemas can originate from either additional schemas
+        // or inline in the schema itself. Ideally the recursive path should align to
+        // reference path. Consider for refactor.
         if (schema.$id && !names.has(schema.$id)) {
             names.add(schema.$id);
             const name = CreateFunctionName(schema.$id);
@@ -377,8 +386,14 @@ var TypeCompiler;
     function Compile(schema, references = []) {
         index_2.TypeGuard.Assert(schema, references);
         const code = Build(schema, references);
-        const func = globalThis.Function(code);
-        return new TypeCheck(schema, references, func(), code);
+        const func1 = globalThis.Function('format', code);
+        const func2 = func1((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);
     }
     TypeCompiler.Compile = Compile;
 })(TypeCompiler = exports.TypeCompiler || (exports.TypeCompiler = {}));

package/format/format.d.ts

@@ -0,0 +1,12 @@
+export declare type FormatValidationFunction = (value: string) => boolean;
+/** Shared string formats used by the TypeCompiler and Value modules */
+export declare namespace Format {
+    /** Clears all formats */
+    function Clear(format: string): void;
+    /** Returns true if the string format exists */
+    function Has(format: string): boolean;
+    /** Sets a string format validation function */
+    function Set(format: string, func: FormatValidationFunction): void;
+    /** Gets a string format validation function */
+    function Get(format: string): FormatValidationFunction | undefined;
+}

package/format/format.js

@@ -0,0 +1,55 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/format
+
+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.Format = void 0;
+/** Shared string formats used by the TypeCompiler and Value modules */
+var Format;
+(function (Format) {
+    const formats = new Map();
+    /** Clears all formats */
+    function Clear(format) {
+        return formats.clear();
+    }
+    Format.Clear = Clear;
+    /** Returns true if the string format exists */
+    function Has(format) {
+        return formats.has(format);
+    }
+    Format.Has = Has;
+    /** Sets a string format validation function */
+    function Set(format, func) {
+        formats.set(format, func);
+    }
+    Format.Set = Set;
+    /** Gets a string format validation function */
+    function Get(format) {
+        return formats.get(format);
+    }
+    Format.Get = Get;
+})(Format = exports.Format || (exports.Format = {}));

package/format/index.d.ts

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

package/format/index.js

@@ -0,0 +1,44 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/format
+
+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("./format"), exports);

package/guard/guard.js

@@ -54,7 +54,7 @@ var TypeGuard;
             return false;
         }
     }
-    function IsValidPropertyKey(value) {
+    function IsControlCharacterFree(value) {
         if (typeof value !== 'string')
             return false;
         for (let i = 0; i < value.length; i++) {
@@ -84,7 +84,10 @@ var TypeGuard;
         return value === undefined || (value !== undefined && IsString(value));
     }
     function IsOptionalPattern(value) {
-        return value === undefined || (value !== undefined && IsString(value) && IsPattern(value));
+        return value === undefined || (value !== undefined && IsString(value) && IsControlCharacterFree(value) && IsPattern(value));
+    }
+    function IsOptionalFormat(value) {
+        return value === undefined || (value !== undefined && IsString(value) && IsControlCharacterFree(value));
     }
     /** Returns true if the given schema is TAny */
     function TAny(schema) {
@@ -181,7 +184,7 @@ var TypeGuard;
             return false;
         }
         for (const [key, value] of Object.entries(schema.properties)) {
-            if (!IsValidPropertyKey(key))
+            if (!IsControlCharacterFree(key))
                 return false;
             if (!TSchema(value))
                 return false;
@@ -231,7 +234,7 @@ var TypeGuard;
             IsOptionalNumber(schema.minLength) &&
             IsOptionalNumber(schema.maxLength) &&
             IsOptionalPattern(schema.pattern) &&
-            IsOptionalString(schema.format));
+            IsOptionalFormat(schema.format));
     }
     TypeGuard.TString = TString;
     /** Returns true if the given schema is TTuple */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.24.27",
+  "version": "0.24.30",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
@@ -26,15 +26,15 @@
     "publish": "hammer task publish"
   },
   "devDependencies": {
-    "@sinclair/hammer": "^0.16.3",
-    "@types/chai": "^4.3.0",
-    "@types/mocha": "^9.1.0",
-    "@types/node": "^17.0.12",
+    "@sinclair/hammer": "^0.17.1",
+    "@types/chai": "^4.3.3",
+    "@types/mocha": "^9.1.1",
+    "@types/node": "^18.7.13",
     "ajv": "^8.11.0",
     "ajv-formats": "^2.1.1",
-    "chai": "^4.3.5",
-    "mocha": "^9.2.0",
+    "chai": "^4.3.6",
+    "mocha": "^9.2.2",
     "prettier": "^2.7.1",
-    "typescript": "^4.7.4"
+    "typescript": "^4.8.2"
   }
 }

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
 
@@ -69,6 +69,7 @@ License MIT
 - [Strict](#strict)
 - [Validation](#validation)
 - [Compiler](#compiler)
+- [Formats](#formats)
 - [Benchmark](#benchmark)
 - [Contribute](#contribute)
 
@@ -554,7 +555,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'
@@ -596,7 +597,9 @@ type T = Static<typeof T>                            // type T = 'A' | 'B' | 'C'
 
 ## Conditional Types
 
-Use the `Conditional` module to create conditionally 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,12 +648,18 @@ The following table shows the TypeBox mappings between TypeScript and JSON schem
 
 ## Values
 
-Use the `Value` module to perform type operations on values.
+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'
+```
+The following demonstrates its use.
+```typescript
 
-const T = Type.Object({ x: Type.Number(), y: Type.Number() })
+
+const T = Type.Object({ x: Type.Number(), y: Type.Number() }, { additionalProperties: false })
 
 //--------------------------------------------------------------------------------------------
 //
@@ -685,7 +694,7 @@ const C = Value.Cast(T, { x: 1, y: 2, z: 3 })        // const C = { x: 1, y: 2 }
 
 ## Guards
 
-Use the `TypeGuard` module to test if values are valid TypeBox types.
+Use the guard module to test if values are TypeBox types.
 
 ```typescript
 import { TypeGuard } from '@sinclair/typebox/guard'
@@ -792,7 +801,9 @@ Please refer to the official Ajv [documentation](https://ajv.js.org/guide/gettin
 
 ## Compiler
 
-TypeBox provides an optional high performance runtime compiler and type checker that can be used in applications that require extremely fast validation. This compiler is optimized for TypeBox types whose schematics are known in advance. If defining custom types 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 compiler module is provided as an optional import.
 
 ```typescript
 import { TypeCompiler } from '@sinclair/typebox/compiler'
@@ -851,11 +862,41 @@ console.log(C.Code())                                // return function check(va
                                                      // }
 ```
 
+## Formats
+
+Use the `Format` module to define custom string formats.
+
+```typescript
+import { Format } from '@sinclair/typebox/format'
+```
+
+Formats are shared between `Value` and the `TypeCompiler` modules.
+
+```typescript
+//--------------------------------------------------------------------------------------------
+//
+// Use Format.Set(...) to define a format
+//
+//--------------------------------------------------------------------------------------------
+
+Format.Set('ObjectId', value => /^[0-9a-fA-F]{24}$/.test(value))
 
+//--------------------------------------------------------------------------------------------
+//
+// The format is now available to TypeCompiler and Value modules
+//
+//--------------------------------------------------------------------------------------------
+
+const T = Type.String({ format: 'ObjectId' })
+
+const R1 = TypeCompiler.Compile(T).Check('507f1f77bcf86cd799439011')
+
+const R2 = Value.Check(T, '507f1f77bcf86cd799439011')                
+```
 
 ## 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/).
 
@@ -867,29 +908,29 @@ This benchmark measures compilation performance for varying types. You can revie
 ┌──────────────────┬────────────┬──────────────┬──────────────┬──────────────┐
 │     (index)      │ Iterations │     Ajv      │ TypeCompiler │ Performance  │
 ├──────────────────┼────────────┼──────────────┼──────────────┼──────────────┤
-│           Number │    2000    │ '    394 ms' │ '      9 ms' │ '   43.78 x' │
-│           String │    2000    │ '    320 ms' │ '      9 ms' │ '   35.56 x' │
-│          Boolean │    2000    │ '    326 ms' │ '      6 ms' │ '   54.33 x' │
-│             Null │    2000    │ '    256 ms' │ '      6 ms' │ '   42.67 x' │
-│            RegEx │    2000    │ '    494 ms' │ '     12 ms' │ '   41.17 x' │
-│          ObjectA │    2000    │ '   2813 ms' │ '     41 ms' │ '   68.61 x' │
-│          ObjectB │    2000    │ '   2949 ms' │ '     30 ms' │ '   98.30 x' │
-│            Tuple │    2000    │ '   1258 ms' │ '     19 ms' │ '   66.21 x' │
-│            Union │    2000    │ '   1308 ms' │ '     22 ms' │ '   59.45 x' │
-│          Vector4 │    2000    │ '   1589 ms' │ '     17 ms' │ '   93.47 x' │
-│          Matrix4 │    2000    │ '    932 ms' │ '     11 ms' │ '   84.73 x' │
-│   Literal_String │    2000    │ '    343 ms' │ '      6 ms' │ '   57.17 x' │
-│   Literal_Number │    2000    │ '    380 ms' │ '      6 ms' │ '   63.33 x' │
-│  Literal_Boolean │    2000    │ '    369 ms' │ '      4 ms' │ '   92.25 x' │
-│     Array_Number │    2000    │ '    730 ms' │ '      6 ms' │ '  121.67 x' │
-│     Array_String │    2000    │ '    764 ms' │ '      7 ms' │ '  109.14 x' │
-│    Array_Boolean │    2000    │ '    791 ms' │ '      8 ms' │ '   98.88 x' │
-│    Array_ObjectA │    2000    │ '   3550 ms' │ '     33 ms' │ '  107.58 x' │
-│    Array_ObjectB │    2000    │ '   3709 ms' │ '     33 ms' │ '  112.39 x' │
-│      Array_Tuple │    2000    │ '   2209 ms' │ '     15 ms' │ '  147.27 x' │
-│      Array_Union │    2000    │ '   1733 ms' │ '     18 ms' │ '   96.28 x' │
-│    Array_Vector4 │    2000    │ '   2279 ms' │ '     16 ms' │ '  142.44 x' │
-│    Array_Matrix4 │    2000    │ '   1587 ms' │ '     11 ms' │ '  144.27 x' │
+│           Number │    2000    │ '    402 ms' │ '      8 ms' │ '   50.25 x' │
+│           String │    2000    │ '    316 ms' │ '      8 ms' │ '   39.50 x' │
+│          Boolean │    2000    │ '    308 ms' │ '      6 ms' │ '   51.33 x' │
+│             Null │    2000    │ '    259 ms' │ '      5 ms' │ '   51.80 x' │
+│            RegEx │    2000    │ '    479 ms' │ '     11 ms' │ '   43.55 x' │
+│          ObjectA │    2000    │ '   2766 ms' │ '     41 ms' │ '   67.46 x' │
+│          ObjectB │    2000    │ '   3062 ms' │ '     29 ms' │ '  105.59 x' │
+│            Tuple │    2000    │ '   1258 ms' │ '     21 ms' │ '   59.90 x' │
+│            Union │    2000    │ '   1449 ms' │ '     29 ms' │ '   49.97 x' │
+│          Vector4 │    2000    │ '   1616 ms' │ '     16 ms' │ '  101.00 x' │
+│          Matrix4 │    2000    │ '    975 ms' │ '      8 ms' │ '  121.88 x' │
+│   Literal_String │    2000    │ '    350 ms' │ '      6 ms' │ '   58.33 x' │
+│   Literal_Number │    2000    │ '    386 ms' │ '      5 ms' │ '   77.20 x' │
+│  Literal_Boolean │    2000    │ '    377 ms' │ '      4 ms' │ '   94.25 x' │
+│     Array_Number │    2000    │ '    737 ms' │ '      7 ms' │ '  105.29 x' │
+│     Array_String │    2000    │ '    765 ms' │ '      7 ms' │ '  109.29 x' │
+│    Array_Boolean │    2000    │ '    783 ms' │ '      8 ms' │ '   97.88 x' │
+│    Array_ObjectA │    2000    │ '   3578 ms' │ '     31 ms' │ '  115.42 x' │
+│    Array_ObjectB │    2000    │ '   3718 ms' │ '     33 ms' │ '  112.67 x' │
+│      Array_Tuple │    2000    │ '   2259 ms' │ '     14 ms' │ '  161.36 x' │
+│      Array_Union │    2000    │ '   1704 ms' │ '     20 ms' │ '   85.20 x' │
+│    Array_Vector4 │    2000    │ '   2293 ms' │ '     17 ms' │ '  134.88 x' │
+│    Array_Matrix4 │    2000    │ '   1575 ms' │ '     12 ms' │ '  131.25 x' │
 └──────────────────┴────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -901,47 +942,48 @@ This benchmark measures validation performance for varying types. You can review
 ┌──────────────────┬────────────┬──────────────┬──────────────┬──────────────┬──────────────┐
 │     (index)      │ Iterations │  ValueCheck  │     Ajv      │ TypeCompiler │ Performance  │
 ├──────────────────┼────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
-│           Number │  1000000   │ '     27 ms' │ '      6 ms' │ '      4 ms' │ '    1.50 x' │
-│           String │  1000000   │ '     23 ms' │ '     20 ms' │ '     11 ms' │ '    1.82 x' │
-│          Boolean │  1000000   │ '     21 ms' │ '     19 ms' │ '     10 ms' │ '    1.90 x' │
-│             Null │  1000000   │ '     24 ms' │ '     18 ms' │ '     10 ms' │ '    1.80 x' │
-│            RegEx │  1000000   │ '    170 ms' │ '     43 ms' │ '     36 ms' │ '    1.19 x' │
-│          ObjectA │  1000000   │ '    567 ms' │ '     34 ms' │ '     23 ms' │ '    1.48 x' │
-│          ObjectB │  1000000   │ '    985 ms' │ '     50 ms' │ '     36 ms' │ '    1.39 x' │
-│            Tuple │  1000000   │ '    119 ms' │ '     24 ms' │ '     14 ms' │ '    1.71 x' │
-│            Union │  1000000   │ '    302 ms' │ '     26 ms' │ '     14 ms' │ '    1.86 x' │
-│        Recursive │  1000000   │ '   3071 ms' │ '    397 ms' │ '    177 ms' │ '    2.24 x' │
-│          Vector4 │  1000000   │ '    135 ms' │ '     24 ms' │ '     11 ms' │ '    2.18 x' │
-│          Matrix4 │  1000000   │ '    632 ms' │ '     41 ms' │ '     30 ms' │ '    1.37 x' │
-│   Literal_String │  1000000   │ '     49 ms' │ '     19 ms' │ '      9 ms' │ '    2.11 x' │
-│   Literal_Number │  1000000   │ '     56 ms' │ '     18 ms' │ '      9 ms' │ '    2.00 x' │
-│  Literal_Boolean │  1000000   │ '     56 ms' │ '     19 ms' │ '      9 ms' │ '    2.11 x' │
-│     Array_Number │  1000000   │ '    408 ms' │ '     31 ms' │ '     17 ms' │ '    1.82 x' │
-│     Array_String │  1000000   │ '    458 ms' │ '     32 ms' │ '     20 ms' │ '    1.60 x' │
-│    Array_Boolean │  1000000   │ '    431 ms' │ '     34 ms' │ '     24 ms' │ '    1.42 x' │
-│    Array_ObjectA │  1000000   │ '  13322 ms' │ '   2549 ms' │ '   1636 ms' │ '    1.56 x' │
-│    Array_ObjectB │  1000000   │ '  16341 ms' │ '   2865 ms' │ '   2074 ms' │ '    1.38 x' │
-│      Array_Tuple │  1000000   │ '   1640 ms' │ '     92 ms' │ '     71 ms' │ '    1.30 x' │
-│      Array_Union │  1000000   │ '   4803 ms' │ '    237 ms' │ '     89 ms' │ '    2.66 x' │
-│  Array_Recursive │  1000000   │ '  53759 ms' │ '   7694 ms' │ '   2600 ms' │ '    2.96 x' │
-│    Array_Vector4 │  1000000   │ '   2099 ms' │ '     96 ms' │ '     52 ms' │ '    1.85 x' │
-│    Array_Matrix4 │  1000000   │ '  11436 ms' │ '    384 ms' │ '    310 ms' │ '    1.24 x' │
+│           Number │  1000000   │ '     38 ms' │ '      6 ms' │ '      5 ms' │ '    1.20 x' │
+│           String │  1000000   │ '     26 ms' │ '     23 ms' │ '     12 ms' │ '    1.92 x' │
+│          Boolean │  1000000   │ '     26 ms' │ '     23 ms' │ '     11 ms' │ '    2.09 x' │
+│             Null │  1000000   │ '     29 ms' │ '     24 ms' │ '     12 ms' │ '    2.00 x' │
+│            RegEx │  1000000   │ '    169 ms' │ '     47 ms' │ '     37 ms' │ '    1.27 x' │
+│          ObjectA │  1000000   │ '    551 ms' │ '     45 ms' │ '     23 ms' │ '    1.96 x' │
+│          ObjectB │  1000000   │ '    995 ms' │ '     49 ms' │ '     39 ms' │ '    1.26 x' │
+│            Tuple │  1000000   │ '    115 ms' │ '     30 ms' │ '     14 ms' │ '    2.14 x' │
+│            Union │  1000000   │ '    294 ms' │ '     30 ms' │ '     14 ms' │ '    2.14 x' │
+│        Recursive │  1000000   │ '   3308 ms' │ '    429 ms' │ '    174 ms' │ '    2.47 x' │
+│          Vector4 │  1000000   │ '    145 ms' │ '     25 ms' │ '     13 ms' │ '    1.92 x' │
+│          Matrix4 │  1000000   │ '    663 ms' │ '     42 ms' │ '     34 ms' │ '    1.24 x' │
+│   Literal_String │  1000000   │ '     46 ms' │ '     21 ms' │ '     11 ms' │ '    1.91 x' │
+│   Literal_Number │  1000000   │ '     50 ms' │ '     26 ms' │ '     11 ms' │ '    2.36 x' │
+│  Literal_Boolean │  1000000   │ '     45 ms' │ '     24 ms' │ '     11 ms' │ '    2.18 x' │
+│     Array_Number │  1000000   │ '    411 ms' │ '     35 ms' │ '     19 ms' │ '    1.84 x' │
+│     Array_String │  1000000   │ '    438 ms' │ '     33 ms' │ '     20 ms' │ '    1.65 x' │
+│    Array_Boolean │  1000000   │ '    444 ms' │ '     38 ms' │ '     24 ms' │ '    1.58 x' │
+│    Array_ObjectA │  1000000   │ '  13714 ms' │ '   2819 ms' │ '   1791 ms' │ '    1.57 x' │
+│    Array_ObjectB │  1000000   │ '  15855 ms' │ '   2965 ms' │ '   2066 ms' │ '    1.44 x' │
+│      Array_Tuple │  1000000   │ '   1682 ms' │ '     94 ms' │ '     71 ms' │ '    1.32 x' │
+│      Array_Union │  1000000   │ '   4575 ms' │ '    239 ms' │ '     86 ms' │ '    2.78 x' │
+│  Array_Recursive │  1000000   │ '  51970 ms' │ '   7192 ms' │ '   2617 ms' │ '    2.75 x' │
+│    Array_Vector4 │  1000000   │ '   2097 ms' │ '    100 ms' │ '     54 ms' │ '    1.85 x' │
+│    Array_Matrix4 │  1000000   │ '  11596 ms' │ '    381 ms' │ '    327 ms' │ '    1.17 x' │
 └──────────────────┴────────────┴──────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
 ### Compression
 
-The following table lists esbuild compiled and minified sizes for each TypeBox import.
+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.46 x'   │
-│ typebox/guard        │ '   20 kb' │ '    9 kb' │  '2.06 x'   │
-│ typebox/value        │ '   54 kb' │ '   25 kb' │  '2.14 x'   │
-│ typebox              │ '   11 kb' │ '    5 kb' │  '1.89 x'   │
+│ typebox/compiler     │ '   48 kb' │ '   24 kb' │  '2.00 x'   │
+│ typebox/conditional  │ '   41 kb' │ '   16 kb' │  '2.47 x'   │
+│ typebox/format       │ '    0 kb' │ '    0 kb' │  '2.68 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'   │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```
 

package/value/check.js

@@ -29,6 +29,7 @@ THE SOFTWARE.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ValueCheck = exports.ValueCheckUnknownTypeError = void 0;
 const Types = require("../typebox");
+const format_1 = require("../format");
 class ValueCheckUnknownTypeError extends Error {
     constructor(schema) {
         super('ValueCheck: Unknown type');
@@ -205,6 +206,12 @@ var ValueCheck;
             if (!regex.test(value))
                 return false;
         }
+        if (schema.format !== undefined) {
+            if (!format_1.Format.Has(schema.format))
+                return false;
+            const func = format_1.Format.Get(schema.format);
+            return func(value);
+        }
         return true;
     }
     function Tuple(schema, references, value) {

package/value/create.js

@@ -213,6 +213,14 @@ var ValueCreate;
                 return schema.default;
             }
         }
+        else if (schema.format !== undefined) {
+            if (schema.default === undefined) {
+                throw new Error('ValueCreate.String: String types with formats must specify a default value');
+            }
+            else {
+                return schema.default;
+            }
+        }
         else {
             if (schema.default !== undefined) {
                 return schema.default;

package/value/value.d.ts

@@ -6,9 +6,9 @@ export declare namespace Value {
     function Create<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R]): Types.Static<T>;
     /** Creates a value from the given type */
     function Create<T extends Types.TSchema>(schema: T): Types.Static<T>;
-    /** Checks a value matches the given type */
+    /** Returns true if the value matches the given type. */
     function Check<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: unknown): value is Types.Static<T>;
-    /** Checks a value matches the given type */
+    /** Returns true if the value matches the given type. */
     function Check<T extends Types.TSchema>(schema: T, value: unknown): value is Types.Static<T>;
     /** Casts a value into a structure matching the given type. The result will be a new value that retains as much information of the original value as possible. */
     function Cast<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: unknown): Types.Static<T>;