@sinclair/typebox 0.32.0-dev-14 → 0.32.0-dev-16

package/readme.md

@@ -52,9 +52,9 @@ type T = Static<typeof T>                            // type T = {
 
 ## Overview
 
-TypeBox is a runtime type builder 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 assertion 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 is a runtime type builder 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.
 
-This library is designed to enable JSON schema to compose with the same flexibility as TypeScript's type system. It can be used as a simple tool to build up complex schemas or integrated into REST or RPC services to help validate data received over the wire.
+This library enables Json Schema to compose with the same flexibility as TypeScript's type system. It can be used as a simple tool to build up complex schemas or integrated into REST or RPC services to help validate data received over the wire.
 
 License MIT
 
@@ -65,9 +65,9 @@ License MIT
 - [Types](#types)
   - [Json](#types-json)
   - [JavaScript](#types-javascript)
+  - [Modules](#types-modules)
   - [Options](#types-options)
   - [Properties](#types-properties)
-  - [Imports](#types-imports)
   - [Generics](#types-generics)
   - [References](#types-references)
   - [Recursive](#types-recursive)
@@ -644,6 +644,28 @@ TypeBox provides an extended type set that can be used to create schematics for
 └────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
 ```
 
+<a name='types-modules'></a>
+
+### Type Modules
+
+TypeBox uses a modular type system and supports selective type imports. Using selective imports can be useful in resource constrained environments as the technique allows modern bundlers to tree shake unused types. This can reduce overall bundle sizes.
+
+```typescript
+import { Object, Number, String, Boolean, type Static } from '@sinclair/typebox'
+
+const T = Object({                                   // const T: TObject<{
+  x: Number(),                                       //  x: TNumber,
+  y: String(),                                       //  y: TString,
+  z: Boolean()                                       //  z: TBoolean
+})                                                   // }>
+
+type T = Static<typeof T>                            // type T = { 
+                                                     //   x: number, 
+                                                     //   y: string, 
+                                                     //   z: boolean 
+                                                     // }
+```
+
 <a name='types-options'></a>
 
 ### Options
@@ -717,31 +739,6 @@ Object properties can be modified with Readonly and Optional. The following tabl
 └────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
 ```
 
-<a name='types-imports'></a>
-
-### Import Types
-
-TypeBox supports a modular type system. For most users, importing the full type system is generally recommended as it offers the best overall user experience as well as enabling easier discovery of available types.
-
-```typescript
-import { Type } from '@sinclair/typebox'             // 34.9 kb minified
-
-const T = Type.Object({
-  x: Type.Number(),
-  y: Type.Number()
-})
-```
-For developers building for resource constrained environments, selective imports can allow bundle optimizers to tree shake unused types. This can dramatically reduce bundle output sizes.
-```typescript
-import { Object, Number } from '@sinclair/typebox'   // 6.4 kb minified
-
-const T = Object({
-  x: Number(),
-  y: Number()
-})
-```
-For additional information on bundle optimizations, refer to the documentation provided by your bundler of choice.
-
 <a name='types-generics'></a>
 
 ### Generic Types
@@ -811,7 +808,7 @@ type VectorRef = Static<typeof VectorRef>            // type VectorRef = {
                                                      //    y: number
                                                      // }
 ```
-Use Type.Deref to dereference a type. This type will recursively reconstruct interior referenced types.
+Use Type.Deref to dereference a type. This will replace any `$ref` with the target type.
 ```typescript
 const Vertex = Type.Object({                         // const Vertex = {
   position: VectorRef,                               //   type: 'object',
@@ -890,7 +887,7 @@ function test(node: Node) {
 
 ### Conditional Types
 
-TypeBox supports runtime Conditional Types with Type.Extends. This type runs a structural assignability check against the first and second arguments and will return either the third (`true`) or fourth (`false`) argument based on the result. Additionally, the conditional backed types Exclude and Extract are also supported. The following shows both TypeScript and TypeBox examples of this feature.
+TypeBox supports runtime Conditional types with Type.Extends. This type runs a structural assignability check against the first and second arguments and will return either the third (`true`) or fourth (`false`) argument based on the result. The conditional types Exclude and Extract are also supported. The following shows both TypeScript and TypeBox examples of conditional types.
 
 ```typescript
 // Extends
@@ -935,7 +932,7 @@ const T = Type.Exclude(                              // const T: TUnion<[
 
 ### Mapped Types
 
-TypeBox supports Mapped Types with Type.Mapped. This type accepts a union set of property keys as the first argument, and a type mapping function which accepts each key (`K`) as the second. This type can be used with Conditional and Indexed Access types to allow for generalized property remapping irrespective of property type. The following example remaps each property of `T` to be `T[K] | null`.
+TypeBox supports Mapped types with Type.Mapped. This type accepts a union of property keys as the first argument, and a type mapping function which accepts each key (`K`) as the second. This type can be used with Conditional and Indexed Access types to allow for generalized property remapping irrespective of property type. The following example remaps each property of `T` to be `T[K] | null`.
 
 ```typescript
 const T = Type.Object({                              // const T: TObject<{
@@ -961,7 +958,7 @@ const M = Type.Mapped(Type.KeyOf(T), K => {          // type M = {
 
 ### Template Literal Types
 
-TypeBox supports Template Literal types with Type.TemplateLiteral. This type can be created using a syntax similar to the TypeScript Template Literal syntax. TypeBox encodes Template Literals as regular expression string patterns which enables the template to be checked by Json Schema validators. This type also supports regular expression parsing, enabling template patterns to be used for generative types. The following shows both TypeScript and TypeBox usage.
+TypeBox supports template literals with Type.TemplateLiteral. This type can be created using a syntax similar to the TypeScript template literal syntax or composed from exterior types. TypeBox encodes template literals as regular expression patterns which enables the template to be checked by Json Schema validators. This type also supports regular expression parsing, enabling template patterns to be used for generative types. The following shows both TypeScript and TypeBox usage.
 
 ```typescript
 // TypeScript
@@ -996,7 +993,7 @@ const R = Type.Record(K, Type.String())              // const R: TObject<{
 
 ### Indexed Access Types
 
-TypeBox supports Indexed Access Types with Type.Index. This type enables uniform access to interior property and array element types without having to extract them from the underlying schema representation. This type is supported for Object, Array, Tuple, Union and Intersect types.
+TypeBox supports Indexed Access types with Type.Index. This type enables uniform access to interior property and array element types without having to extract them from the underlying schema representation. This type is supported for Object, Array, Tuple, Union and Intersect types.
 
 ```typescript
 const T = Type.Object({                              // const T: TObject<{
@@ -1140,7 +1137,7 @@ type S = Static<typeof T>                            // type S = 'A' | 'B' | 'C'
 
 ### TypeGuard
 
-TypeBox can type check its own types with the TypeGuard module. This module is written for reflection and provides structural tests for every TypeBox type. Functions of this module return `is` guards which can be used with TypeScript control flow assertions to obtain schema inference. The following guards that the value A is TString.
+TypeBox can type check its own types with the TypeGuard module. This module is written for reflection and provides structural tests for every built-in TypeBox type. Functions of this module return `is` guards which can be used with TypeScript control flow assertions to obtain schema inference. The following guards that the value A is TString.
 
 ```typescript
 import { Type, TypeGuard } from '@sinclair/typebox'
@@ -1593,7 +1590,7 @@ const C = TypeCompiler.Code(Type.String())           // const C = `return functi
 
 ## TypeSystem
 
-The TypeBox TypeSystem module provides functionality to define types above and beyond the built-in Json and JavaScript type sets. They also manage TypeBox's localization options (i18n) for error message generation and can control various assertion policies used when type checking. Configurations made to the TypeSystem module are observed by the TypeCompiler, Value and Error modules.
+The TypeBox TypeSystem module provides configurations to use either Json Schema or TypeScript type checking semantics. Configurations made to the TypeSystem module are observed by the TypeCompiler, Value and Error modules.
 
 <a name='typesystem-policies'></a>
 
@@ -1635,7 +1632,7 @@ TypeSystemPolicy.AllowNullVoid = true
 
 ## Error Function
 
-Error messages in TypeBox can be customized by defining an ErrorFunction. This function allows for the localization of error messages as well as enabling custom error messages for custom types. By default, TypeBox will generate messages using the `en-US` locale. To support additional locales, you can replicate the function found in `src/errors/function.ts` and create a locale specific translations. The function can then be set via SetErrorFunction.
+Error messages in TypeBox can be customized by defining an ErrorFunction. This function allows for the localization of error messages as well as enabling custom error messages for custom types. By default, TypeBox will generate messages using the `en-US` locale. To support additional locales, you can replicate the function found in `src/errors/function.ts` and create a locale specific translation. The function can then be set via SetErrorFunction.
 
 The following example shows an inline error function that intercepts errors for String, Number and Boolean only. The DefaultErrorFunction is used to return a default error message.
 
@@ -1719,7 +1716,7 @@ The following is a list of community packages that offer general tooling, extend
 
 ## Benchmark
 
-This project maintains a set of benchmarks that measure Ajv, Value and TypeCompiler compilation and validation performance. These benchmarks can be run locally by cloning this repository and running `npm run benchmark`. The results below show for Ajv version 8.12.0 running on Node 20.0.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.12.0 running on Node 20.10.0.
 
 For additional comparative benchmarks, please refer to [typescript-runtime-type-benchmarks](https://moltar.github.io/typescript-runtime-type-benchmarks/).
 
@@ -1733,35 +1730,35 @@ This benchmark measures compilation performance for varying types. You can revie
 ┌────────────────────────────┬────────────┬──────────────┬──────────────┬──────────────┐
 │          (index)           │ Iterations │     Ajv      │ TypeCompiler │ Performance  │
 ├────────────────────────────┼────────────┼──────────────┼──────────────┼──────────────┤
-│ Literal_String             │    1000    │ '    216 ms' │ '      9 ms' │ '   24.00 x' │
-│ Literal_Number             │    1000    │ '    169 ms' │ '      7 ms' │ '   24.14 x' │
-│ Literal_Boolean            │    1000    │ '    150 ms' │ '      5 ms' │ '   30.00 x' │
-│ Primitive_Number           │    1000    │ '    161 ms' │ '      7 ms' │ '   23.00 x' │
-│ Primitive_String           │    1000    │ '    148 ms' │ '      6 ms' │ '   24.67 x' │
-│ Primitive_String_Pattern   │    1000    │ '    185 ms' │ '      9 ms' │ '   20.56 x' │
-│ Primitive_Boolean          │    1000    │ '    132 ms' │ '      4 ms' │ '   33.00 x' │
-│ Primitive_Null             │    1000    │ '    141 ms' │ '      3 ms' │ '   47.00 x' │
-│ Object_Unconstrained       │    1000    │ '   1109 ms' │ '     30 ms' │ '   36.97 x' │
-│ Object_Constrained         │    1000    │ '   1200 ms' │ '     24 ms' │ '   50.00 x' │
-│ Object_Vector3             │    1000    │ '    379 ms' │ '      9 ms' │ '   42.11 x' │
-│ Object_Box3D               │    1000    │ '   1709 ms' │ '     30 ms' │ '   56.97 x' │
-│ Tuple_Primitive            │    1000    │ '    456 ms' │ '     14 ms' │ '   32.57 x' │
-│ Tuple_Object               │    1000    │ '   1229 ms' │ '     17 ms' │ '   72.29 x' │
-│ Composite_Intersect        │    1000    │ '    570 ms' │ '     17 ms' │ '   33.53 x' │
-│ Composite_Union            │    1000    │ '    513 ms' │ '     19 ms' │ '   27.00 x' │
-│ Math_Vector4               │    1000    │ '    782 ms' │ '     13 ms' │ '   60.15 x' │
-│ Math_Matrix4               │    1000    │ '    393 ms' │ '     12 ms' │ '   32.75 x' │
-│ Array_Primitive_Number     │    1000    │ '    361 ms' │ '     12 ms' │ '   30.08 x' │
-│ Array_Primitive_String     │    1000    │ '    296 ms' │ '      5 ms' │ '   59.20 x' │
-│ Array_Primitive_Boolean    │    1000    │ '    315 ms' │ '      4 ms' │ '   78.75 x' │
-│ Array_Object_Unconstrained │    1000    │ '   1721 ms' │ '     22 ms' │ '   78.23 x' │
-│ Array_Object_Constrained   │    1000    │ '   1450 ms' │ '     21 ms' │ '   69.05 x' │
-│ Array_Tuple_Primitive      │    1000    │ '    813 ms' │ '     13 ms' │ '   62.54 x' │
-│ Array_Tuple_Object         │    1000    │ '   1537 ms' │ '     17 ms' │ '   90.41 x' │
-│ Array_Composite_Intersect  │    1000    │ '    753 ms' │ '     17 ms' │ '   44.29 x' │
-│ Array_Composite_Union      │    1000    │ '    808 ms' │ '     16 ms' │ '   50.50 x' │
-│ Array_Math_Vector4         │    1000    │ '   1118 ms' │ '     16 ms' │ '   69.88 x' │
-│ Array_Math_Matrix4         │    1000    │ '    690 ms' │ '      9 ms' │ '   76.67 x' │
+│ Literal_String             │    1000    │ '    236 ms' │ '      9 ms' │ '   26.22 x' │
+│ Literal_Number             │    1000    │ '    205 ms' │ '     13 ms' │ '   15.77 x' │
+│ Literal_Boolean            │    1000    │ '    168 ms' │ '      4 ms' │ '   42.00 x' │
+│ Primitive_Number           │    1000    │ '    170 ms' │ '      8 ms' │ '   21.25 x' │
+│ Primitive_String           │    1000    │ '    162 ms' │ '      7 ms' │ '   23.14 x' │
+│ Primitive_String_Pattern   │    1000    │ '    211 ms' │ '     10 ms' │ '   21.10 x' │
+│ Primitive_Boolean          │    1000    │ '    139 ms' │ '      4 ms' │ '   34.75 x' │
+│ Primitive_Null             │    1000    │ '    146 ms' │ '      5 ms' │ '   29.20 x' │
+│ Object_Unconstrained       │    1000    │ '   1160 ms' │ '     33 ms' │ '   35.15 x' │
+│ Object_Constrained         │    1000    │ '   1257 ms' │ '     26 ms' │ '   48.35 x' │
+│ Object_Vector3             │    1000    │ '    393 ms' │ '      8 ms' │ '   49.13 x' │
+│ Object_Box3D               │    1000    │ '   1795 ms' │ '     30 ms' │ '   59.83 x' │
+│ Tuple_Primitive            │    1000    │ '    542 ms' │ '     16 ms' │ '   33.88 x' │
+│ Tuple_Object               │    1000    │ '   1330 ms' │ '     17 ms' │ '   78.24 x' │
+│ Composite_Intersect        │    1000    │ '    624 ms' │ '     17 ms' │ '   36.71 x' │
+│ Composite_Union            │    1000    │ '    565 ms' │ '     19 ms' │ '   29.74 x' │
+│ Math_Vector4               │    1000    │ '    853 ms' │ '     10 ms' │ '   85.30 x' │
+│ Math_Matrix4               │    1000    │ '    406 ms' │ '     12 ms' │ '   33.83 x' │
+│ Array_Primitive_Number     │    1000    │ '    401 ms' │ '     11 ms' │ '   36.45 x' │
+│ Array_Primitive_String     │    1000    │ '    385 ms' │ '      6 ms' │ '   64.17 x' │
+│ Array_Primitive_Boolean    │    1000    │ '    347 ms' │ '      8 ms' │ '   43.38 x' │
+│ Array_Object_Unconstrained │    1000    │ '   1904 ms' │ '     25 ms' │ '   76.16 x' │
+│ Array_Object_Constrained   │    1000    │ '   1582 ms' │ '     20 ms' │ '   79.10 x' │
+│ Array_Tuple_Primitive      │    1000    │ '    864 ms' │ '     11 ms' │ '   78.55 x' │
+│ Array_Tuple_Object         │    1000    │ '   1658 ms' │ '     16 ms' │ '  103.63 x' │
+│ Array_Composite_Intersect  │    1000    │ '    786 ms' │ '     17 ms' │ '   46.24 x' │
+│ Array_Composite_Union      │    1000    │ '    844 ms' │ '     16 ms' │ '   52.75 x' │
+│ Array_Math_Vector4         │    1000    │ '   1192 ms' │ '     10 ms' │ '  119.20 x' │
+│ Array_Math_Matrix4         │    1000    │ '    688 ms' │ '     10 ms' │ '   68.80 x' │
 └────────────────────────────┴────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1775,37 +1772,37 @@ This benchmark measures validation performance for varying types. You can review
 ┌────────────────────────────┬────────────┬──────────────┬──────────────┬──────────────┬──────────────┐
 │          (index)           │ Iterations │  ValueCheck  │     Ajv      │ TypeCompiler │ Performance  │
 ├────────────────────────────┼────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
-│ Literal_String             │  1000000   │ '     24 ms' │ '      5 ms' │ '      4 ms' │ '    1.25 x' │
-│ Literal_Number             │  1000000   │ '     15 ms' │ '     20 ms' │ '     10 ms' │ '    2.00 x' │
+│ Literal_String             │  1000000   │ '     19 ms' │ '      5 ms' │ '      4 ms' │ '    1.25 x' │
+│ Literal_Number             │  1000000   │ '     14 ms' │ '     19 ms' │ '     10 ms' │ '    1.90 x' │
 │ Literal_Boolean            │  1000000   │ '     14 ms' │ '     19 ms' │ '      9 ms' │ '    2.11 x' │
-│ Primitive_Number           │  1000000   │ '     25 ms' │ '     18 ms' │ '     10 ms' │ '    1.80 x' │
-│ Primitive_String           │  1000000   │ '     21 ms' │ '     24 ms' │ '      9 ms' │ '    2.67 x' │
-│ Primitive_String_Pattern   │  1000000   │ '    156 ms' │ '     43 ms' │ '     38 ms' │ '    1.13 x' │
-│ Primitive_Boolean          │  1000000   │ '     18 ms' │ '     17 ms' │ '      9 ms' │ '    1.89 x' │
-│ Primitive_Null             │  1000000   │ '     20 ms' │ '     17 ms' │ '      9 ms' │ '    1.89 x' │
-│ Object_Unconstrained       │  1000000   │ '   1055 ms' │ '     32 ms' │ '     24 ms' │ '    1.33 x' │
-│ Object_Constrained         │  1000000   │ '   1232 ms' │ '     49 ms' │ '     43 ms' │ '    1.14 x' │
-│ Object_Vector3             │  1000000   │ '    432 ms' │ '     23 ms' │ '     13 ms' │ '    1.77 x' │
-│ Object_Box3D               │  1000000   │ '   1993 ms' │ '     54 ms' │ '     46 ms' │ '    1.17 x' │
-│ Object_Recursive           │  1000000   │ '   5115 ms' │ '    342 ms' │ '    159 ms' │ '    2.15 x' │
-│ Tuple_Primitive            │  1000000   │ '    156 ms' │ '     21 ms' │ '     13 ms' │ '    1.62 x' │
-│ Tuple_Object               │  1000000   │ '    740 ms' │ '     29 ms' │ '     18 ms' │ '    1.61 x' │
-│ Composite_Intersect        │  1000000   │ '    797 ms' │ '     26 ms' │ '     14 ms' │ '    1.86 x' │
-│ Composite_Union            │  1000000   │ '    530 ms' │ '     23 ms' │ '     13 ms' │ '    1.77 x' │
-│ Math_Vector4               │  1000000   │ '    240 ms' │ '     22 ms' │ '     11 ms' │ '    2.00 x' │
-│ Math_Matrix4               │  1000000   │ '   1036 ms' │ '     39 ms' │ '     27 ms' │ '    1.44 x' │
-│ Array_Primitive_Number     │  1000000   │ '    248 ms' │ '     20 ms' │ '     12 ms' │ '    1.67 x' │
-│ Array_Primitive_String     │  1000000   │ '    227 ms' │ '     22 ms' │ '     13 ms' │ '    1.69 x' │
-│ Array_Primitive_Boolean    │  1000000   │ '    138 ms' │ '     21 ms' │ '     13 ms' │ '    1.62 x' │
-│ Array_Object_Unconstrained │  1000000   │ '   5540 ms' │ '     66 ms' │ '     59 ms' │ '    1.12 x' │
-│ Array_Object_Constrained   │  1000000   │ '   5750 ms' │ '    123 ms' │ '    108 ms' │ '    1.14 x' │
-│ Array_Object_Recursive     │  1000000   │ '  21842 ms' │ '   1771 ms' │ '    599 ms' │ '    2.96 x' │
-│ Array_Tuple_Primitive      │  1000000   │ '    715 ms' │ '     36 ms' │ '     29 ms' │ '    1.24 x' │
-│ Array_Tuple_Object         │  1000000   │ '   3131 ms' │ '     63 ms' │ '     50 ms' │ '    1.26 x' │
-│ Array_Composite_Intersect  │  1000000   │ '   3064 ms' │ '     44 ms' │ '     35 ms' │ '    1.26 x' │
-│ Array_Composite_Union      │  1000000   │ '   2172 ms' │ '     65 ms' │ '     31 ms' │ '    2.10 x' │
-│ Array_Math_Vector4         │  1000000   │ '   1032 ms' │ '     37 ms' │ '     24 ms' │ '    1.54 x' │
-│ Array_Math_Matrix4         │  1000000   │ '   4859 ms' │ '    114 ms' │ '     86 ms' │ '    1.33 x' │
+│ Primitive_Number           │  1000000   │ '     21 ms' │ '     18 ms' │ '     10 ms' │ '    1.80 x' │
+│ Primitive_String           │  1000000   │ '     22 ms' │ '     17 ms' │ '      9 ms' │ '    1.89 x' │
+│ Primitive_String_Pattern   │  1000000   │ '    164 ms' │ '     44 ms' │ '     36 ms' │ '    1.22 x' │
+│ Primitive_Boolean          │  1000000   │ '     18 ms' │ '     18 ms' │ '      9 ms' │ '    2.00 x' │
+│ Primitive_Null             │  1000000   │ '     19 ms' │ '     17 ms' │ '      9 ms' │ '    1.89 x' │
+│ Object_Unconstrained       │  1000000   │ '    966 ms' │ '     33 ms' │ '     24 ms' │ '    1.38 x' │
+│ Object_Constrained         │  1000000   │ '   1275 ms' │ '     52 ms' │ '     42 ms' │ '    1.24 x' │
+│ Object_Vector3             │  1000000   │ '    427 ms' │ '     23 ms' │ '     14 ms' │ '    1.64 x' │
+│ Object_Box3D               │  1000000   │ '   2024 ms' │ '     56 ms' │ '     50 ms' │ '    1.12 x' │
+│ Object_Recursive           │  1000000   │ '   5263 ms' │ '    358 ms' │ '    164 ms' │ '    2.18 x' │
+│ Tuple_Primitive            │  1000000   │ '    157 ms' │ '     22 ms' │ '     12 ms' │ '    1.83 x' │
+│ Tuple_Object               │  1000000   │ '    767 ms' │ '     29 ms' │ '     18 ms' │ '    1.61 x' │
+│ Composite_Intersect        │  1000000   │ '    769 ms' │ '     26 ms' │ '     15 ms' │ '    1.73 x' │
+│ Composite_Union            │  1000000   │ '    501 ms' │ '     24 ms' │ '     13 ms' │ '    1.85 x' │
+│ Math_Vector4               │  1000000   │ '    250 ms' │ '     23 ms' │ '     11 ms' │ '    2.09 x' │
+│ Math_Matrix4               │  1000000   │ '   1073 ms' │ '     43 ms' │ '     28 ms' │ '    1.54 x' │
+│ Array_Primitive_Number     │  1000000   │ '    264 ms' │ '     21 ms' │ '     12 ms' │ '    1.75 x' │
+│ Array_Primitive_String     │  1000000   │ '    242 ms' │ '     23 ms' │ '     14 ms' │ '    1.64 x' │
+│ Array_Primitive_Boolean    │  1000000   │ '    151 ms' │ '     24 ms' │ '     14 ms' │ '    1.71 x' │
+│ Array_Object_Unconstrained │  1000000   │ '   5864 ms' │ '     66 ms' │ '     58 ms' │ '    1.14 x' │
+│ Array_Object_Constrained   │  1000000   │ '   5996 ms' │ '    138 ms' │ '    116 ms' │ '    1.19 x' │
+│ Array_Object_Recursive     │  1000000   │ '  22515 ms' │ '   1625 ms' │ '    585 ms' │ '    2.78 x' │
+│ Array_Tuple_Primitive      │  1000000   │ '    737 ms' │ '     38 ms' │ '     31 ms' │ '    1.23 x' │
+│ Array_Tuple_Object         │  1000000   │ '   3257 ms' │ '     77 ms' │ '     56 ms' │ '    1.38 x' │
+│ Array_Composite_Intersect  │  1000000   │ '   3119 ms' │ '     49 ms' │ '     38 ms' │ '    1.29 x' │
+│ Array_Composite_Union      │  1000000   │ '   2108 ms' │ '     72 ms' │ '     33 ms' │ '    2.18 x' │
+│ Array_Math_Vector4         │  1000000   │ '   1078 ms' │ '     38 ms' │ '     26 ms' │ '    1.46 x' │
+│ Array_Math_Matrix4         │  1000000   │ '   4967 ms' │ '    126 ms' │ '     88 ms' │ '    1.43 x' │
 └────────────────────────────┴────────────┴──────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1819,12 +1816,11 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │       (index)        │  Compiled  │  Minified  │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '109.2 kb' │ ' 48.6 kb' │  '2.25 x'   │
-│ typebox/errors       │ ' 55.0 kb' │ ' 25.1 kb' │  '2.19 x'   │
+│ typebox/compiler     │ '118.7 kb' │ ' 52.5 kb' │  '2.26 x'   │
+│ typebox/errors       │ ' 55.1 kb' │ ' 25.2 kb' │  '2.19 x'   │
 │ typebox/system       │ '  4.6 kb' │ '  2.0 kb' │  '2.31 x'   │
-│ typebox/type         │ ' 82.9 kb' │ ' 34.9 kb' │  '2.38 x'   │
-│ typebox/value        │ '144.2 kb' │ ' 61.5 kb' │  '2.34 x'   │
-│ typebox              │ ' 82.9 kb' │ ' 34.9 kb' │  '2.37 x'   │
+│ typebox/value        │ '144.8 kb' │ ' 61.8 kb' │  '2.34 x'   │
+│ typebox              │ ' 87.7 kb' │ ' 36.7 kb' │  '2.39 x'   │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```
 

package/build/import/type/extends/extends-mapped-result-from-result.d.mts

@@ -1,13 +0,0 @@
-import type { TSchema } from '../schema/index.mjs';
-import type { TProperties } from '../object/index.mjs';
-import { type TMappedResult } from '../mapped/index.mjs';
-import { type TExtends } from './extends.mjs';
-type MappedResultExtendsPropertyKeys<K extends TProperties, U extends TSchema, L extends TSchema, R extends TSchema> = ({
-    [K2 in keyof K]: TExtends<K[K2], U, L, R>;
-});
-declare function MappedResultExtendsPropertyKeys<K extends TProperties, U extends TSchema, L extends TSchema, R extends TSchema>(K: K, U: U, L: L, R: R): MappedResultExtendsPropertyKeys<K, U, L, R>;
-type MappedResultExtendsProperties<K extends TMappedResult, U extends TSchema, L extends TSchema, R extends TSchema> = (MappedResultExtendsPropertyKeys<K['properties'], U, L, R>);
-declare function MappedResultExtendsProperties<K extends TMappedResult, U extends TSchema, L extends TSchema, R extends TSchema>(K: K, U: U, L: L, R: R): MappedResultExtendsProperties<K, U, L, R>;
-export type TExtendsMappedResultFromResult<T extends TMappedResult, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = MappedResultExtendsProperties<T, U, L, R>> = (TMappedResult<P>);
-export declare function ExtendsMappedResultFromResult<T extends TMappedResult, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = MappedResultExtendsProperties<T, U, L, R>>(T: T, U: U, L: L, R: R): TMappedResult<P>;
-export {};

package/build/import/type/extends/extends-mapped-result-from-result.mjs

@@ -1,14 +0,0 @@
-import { MappedResult } from '../mapped/index.mjs';
-import { Extends } from './extends.mjs';
-function MappedResultExtendsPropertyKeys(K, U, L, R) {
-    return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
-        return { ...Acc, [K2]: Extends(K[K2], U, L, R) };
-    }, {});
-}
-function MappedResultExtendsProperties(K, U, L, R) {
-    return MappedResultExtendsPropertyKeys(K.properties, U, L, R);
-}
-export function ExtendsMappedResultFromResult(T, U, L, R) {
-    const P = MappedResultExtendsProperties(T, U, L, R);
-    return MappedResult(P);
-}

package/build/import/type/extends/extends-mapped-result.d.mts

@@ -1,17 +0,0 @@
-import type { TSchema } from '../schema/index.mjs';
-import type { TProperties } from '../object/index.mjs';
-import type { Assert } from '../helpers/index.mjs';
-import { type TMappedResult, type TMappedKey } from '../mapped/index.mjs';
-import { TLiteral, TLiteralValue } from '../literal/index.mjs';
-import { type TExtends } from './extends.mjs';
-type MappedExtendsPropertyKey<K extends PropertyKey, U extends TSchema, L extends TSchema, R extends TSchema> = {
-    [_ in K]: TExtends<TLiteral<Assert<K, TLiteralValue>>, U, L, R>;
-};
-declare function MappedExtendsPropertyKey<K extends PropertyKey, U extends TSchema, L extends TSchema, R extends TSchema>(K: K, U: U, L: L, R: R): MappedExtendsPropertyKey<K, U, L, R>;
-type MappedExtendsPropertyKeys<K extends PropertyKey[], U extends TSchema, L extends TSchema, R extends TSchema> = (K extends [infer LK extends PropertyKey, ...infer RK extends PropertyKey[]] ? MappedExtendsPropertyKey<LK, U, L, R> & MappedExtendsPropertyKeys<RK, U, L, R> : {});
-declare function MappedExtendsPropertyKeys<K extends PropertyKey[], U extends TSchema, L extends TSchema, R extends TSchema>(K: [...K], U: U, L: L, R: R): MappedExtendsPropertyKeys<K, U, L, R>;
-type MappedExtendsProperties<K extends TMappedKey, U extends TSchema, L extends TSchema, R extends TSchema> = (MappedExtendsPropertyKeys<K['keys'], U, L, R>);
-declare function MappedExtendsProperties<K extends TMappedKey, U extends TSchema, L extends TSchema, R extends TSchema>(K: K, U: U, L: L, R: R): MappedExtendsProperties<K, U, L, R>;
-export type TExtendsMappedResult<T extends TMappedKey, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = MappedExtendsProperties<T, U, L, R>> = (TMappedResult<P>);
-export declare function ExtendsMappedResult<T extends TMappedKey, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = MappedExtendsProperties<T, U, L, R>>(T: T, U: U, L: L, R: R): TMappedResult<P>;
-export {};

package/build/import/type/extends/extends-mapped-result.mjs

@@ -1,21 +0,0 @@
-import { MappedResult } from '../mapped/index.mjs';
-import { Literal } from '../literal/index.mjs';
-import { Extends } from './extends.mjs';
-function MappedExtendsPropertyKey(K, U, L, R) {
-    return {
-        [K]: Extends(Literal(K), U, L, R)
-    };
-}
-function MappedExtendsPropertyKeys(K, U, L, R) {
-    const [LK, ...RK] = K;
-    return (K.length > 0
-        ? { ...MappedExtendsPropertyKey(LK, U, L, R), ...MappedExtendsPropertyKeys(RK, U, L, R) }
-        : {});
-}
-function MappedExtendsProperties(K, U, L, R) {
-    return MappedExtendsPropertyKeys(K.keys, U, L, R);
-}
-export function ExtendsMappedResult(T, U, L, R) {
-    const P = MappedExtendsProperties(T, U, L, R);
-    return MappedResult(P);
-}

package/build/import/type/indexed/indexed-mapped-result.mjs

@@ -1,18 +0,0 @@
-import { IndexResult } from './indexed-result.mjs';
-import { MappedResult } from '../mapped/index.mjs';
-function MappedIndexPropertyKey(T, K) {
-    return { [K]: IndexResult(T, [K]) };
-}
-function MappedIndexPropertyKeys(T, K) {
-    const [L, ...R] = K;
-    return (K.length > 0
-        ? { ...MappedIndexPropertyKey(T, L), ...MappedIndexPropertyKeys(T, R) }
-        : {});
-}
-function MappedIndexProperties(T, K) {
-    return MappedIndexPropertyKeys(T, K.keys);
-}
-export function IndexMappedResult(T, K) {
-    const P = MappedIndexProperties(T, K);
-    return MappedResult(P);
-}

package/build/import/type/intrinsic/intrinsic-mapped-result.mjs

@@ -1,21 +0,0 @@
-import { MappedResult } from '../mapped/index.mjs';
-import { Intrinsic } from './intrinsic.mjs';
-import { Literal } from '../literal/index.mjs';
-function MappedIntrinsicPropertyKey(K, M) {
-    return {
-        [K]: Intrinsic(Literal(K), M)
-    };
-}
-function MappedIntrinsicPropertyKeys(K, M) {
-    const [L, ...R] = K;
-    return (K.length > 0
-        ? { ...MappedIntrinsicPropertyKey(L, M), ...MappedIntrinsicPropertyKeys(R, M) }
-        : {});
-}
-function MappedIntrinsicProperties(T, M) {
-    return MappedIntrinsicPropertyKeys(T['keys'], M);
-}
-export function IntrinsicMappedResult(T, M) {
-    const P = MappedIntrinsicProperties(T, M);
-    return MappedResult(P);
-}

package/build/import/type/omit/omit-mapped-result.d.mts

@@ -1,15 +0,0 @@
-import type { TSchema } from '../schema/index.mjs';
-import type { TProperties } from '../object/index.mjs';
-import { type TMappedResult, type TMappedKey } from '../mapped/index.mjs';
-import { type TOmit } from './omit.mjs';
-type MappedOmitPropertyKey<T extends TSchema, K extends PropertyKey> = {
-    [_ in K]: TOmit<T, [K]>;
-};
-declare function MappedOmitPropertyKey<T extends TSchema, K extends PropertyKey>(T: T, K: K): MappedOmitPropertyKey<T, K>;
-type MappedOmitPropertyKeys<T extends TSchema, K extends PropertyKey[]> = (K extends [infer LK extends PropertyKey, ...infer RK extends PropertyKey[]] ? MappedOmitPropertyKey<T, LK> & MappedOmitPropertyKeys<T, RK> : {});
-declare function MappedOmitPropertyKeys<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): MappedOmitPropertyKeys<T, K>;
-type MappedOmitProperties<T extends TSchema, K extends TMappedKey> = (MappedOmitPropertyKeys<T, K['keys']>);
-declare function MappedOmitProperties<T extends TSchema, K extends TMappedKey>(T: T, K: K): MappedOmitProperties<T, K>;
-export type TOmitMappedResult<T extends TSchema, K extends TMappedKey, P extends TProperties = MappedOmitProperties<T, K>> = (TMappedResult<P>);
-export declare function OmitMappedResult<T extends TSchema, K extends TMappedKey, P extends TProperties = MappedOmitProperties<T, K>>(T: T, K: K): TMappedResult<P>;
-export {};

package/build/import/type/omit/omit-mapped-result.mjs

@@ -1,20 +0,0 @@
-import { MappedResult } from '../mapped/index.mjs';
-import { Omit } from './omit.mjs';
-function MappedOmitPropertyKey(T, K) {
-    return {
-        [K]: Omit(T, [K])
-    };
-}
-function MappedOmitPropertyKeys(T, K) {
-    const [LK, ...RK] = K;
-    return (K.length > 0
-        ? { ...MappedOmitPropertyKey(T, LK), ...MappedOmitPropertyKeys(T, RK) }
-        : {});
-}
-function MappedOmitProperties(T, K) {
-    return MappedOmitPropertyKeys(T, K.keys);
-}
-export function OmitMappedResult(T, K) {
-    const P = MappedOmitProperties(T, K);
-    return MappedResult(P);
-}

package/build/import/type/pick/pick-mapped-result.d.mts

@@ -1,15 +0,0 @@
-import type { TSchema } from '../schema/index.mjs';
-import type { TProperties } from '../object/index.mjs';
-import { type TMappedResult, type TMappedKey } from '../mapped/index.mjs';
-import { type TPick } from './pick.mjs';
-type MappedPickPropertyKey<T extends TSchema, K extends PropertyKey> = {
-    [_ in K]: TPick<T, [K]>;
-};
-declare function MappedPickPropertyKey<T extends TSchema, K extends PropertyKey>(T: T, K: K): MappedPickPropertyKey<T, K>;
-type MappedPickPropertyKeys<T extends TSchema, K extends PropertyKey[]> = (K extends [infer LK extends PropertyKey, ...infer RK extends PropertyKey[]] ? MappedPickPropertyKey<T, LK> & MappedPickPropertyKeys<T, RK> : {});
-declare function MappedPickPropertyKeys<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): MappedPickPropertyKeys<T, K>;
-type MappedPickProperties<T extends TSchema, K extends TMappedKey> = (MappedPickPropertyKeys<T, K['keys']>);
-declare function MappedPickProperties<T extends TSchema, K extends TMappedKey>(T: T, K: K): MappedPickProperties<T, K>;
-export type TPickMappedResult<T extends TSchema, K extends TMappedKey, P extends TProperties = MappedPickProperties<T, K>> = (TMappedResult<P>);
-export declare function PickMappedResult<T extends TSchema, K extends TMappedKey, P extends TProperties = MappedPickProperties<T, K>>(T: T, K: K): TMappedResult<P>;
-export {};

package/build/import/type/pick/pick-mapped-result.mjs

@@ -1,20 +0,0 @@
-import { MappedResult } from '../mapped/index.mjs';
-import { Pick } from './pick.mjs';
-function MappedPickPropertyKey(T, K) {
-    return {
-        [K]: Pick(T, [K])
-    };
-}
-function MappedPickPropertyKeys(T, K) {
-    const [LK, ...RK] = K;
-    return (K.length > 0
-        ? { ...MappedPickPropertyKey(T, LK), ...MappedPickPropertyKeys(T, RK) }
-        : {});
-}
-function MappedPickProperties(T, K) {
-    return MappedPickPropertyKeys(T, K.keys);
-}
-export function PickMappedResult(T, K) {
-    const P = MappedPickProperties(T, K);
-    return MappedResult(P);
-}

package/build/require/type/extends/extends-mapped-result-from-result.d.ts

@@ -1,13 +0,0 @@
-import type { TSchema } from '../schema/index';
-import type { TProperties } from '../object/index';
-import { type TMappedResult } from '../mapped/index';
-import { type TExtends } from './extends';
-type MappedResultExtendsPropertyKeys<K extends TProperties, U extends TSchema, L extends TSchema, R extends TSchema> = ({
-    [K2 in keyof K]: TExtends<K[K2], U, L, R>;
-});
-declare function MappedResultExtendsPropertyKeys<K extends TProperties, U extends TSchema, L extends TSchema, R extends TSchema>(K: K, U: U, L: L, R: R): MappedResultExtendsPropertyKeys<K, U, L, R>;
-type MappedResultExtendsProperties<K extends TMappedResult, U extends TSchema, L extends TSchema, R extends TSchema> = (MappedResultExtendsPropertyKeys<K['properties'], U, L, R>);
-declare function MappedResultExtendsProperties<K extends TMappedResult, U extends TSchema, L extends TSchema, R extends TSchema>(K: K, U: U, L: L, R: R): MappedResultExtendsProperties<K, U, L, R>;
-export type TExtendsMappedResultFromResult<T extends TMappedResult, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = MappedResultExtendsProperties<T, U, L, R>> = (TMappedResult<P>);
-export declare function ExtendsMappedResultFromResult<T extends TMappedResult, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = MappedResultExtendsProperties<T, U, L, R>>(T: T, U: U, L: L, R: R): TMappedResult<P>;
-export {};

package/build/require/type/extends/extends-mapped-result-from-result.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExtendsMappedResultFromResult = void 0;
-const index_1 = require("../mapped/index");
-const extends_1 = require("./extends");
-function MappedResultExtendsPropertyKeys(K, U, L, R) {
-    return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
-        return { ...Acc, [K2]: (0, extends_1.Extends)(K[K2], U, L, R) };
-    }, {});
-}
-function MappedResultExtendsProperties(K, U, L, R) {
-    return MappedResultExtendsPropertyKeys(K.properties, U, L, R);
-}
-function ExtendsMappedResultFromResult(T, U, L, R) {
-    const P = MappedResultExtendsProperties(T, U, L, R);
-    return (0, index_1.MappedResult)(P);
-}
-exports.ExtendsMappedResultFromResult = ExtendsMappedResultFromResult;

package/build/require/type/extends/extends-mapped-result.d.ts

@@ -1,17 +0,0 @@
-import type { TSchema } from '../schema/index';
-import type { TProperties } from '../object/index';
-import type { Assert } from '../helpers/index';
-import { type TMappedResult, type TMappedKey } from '../mapped/index';
-import { TLiteral, TLiteralValue } from '../literal/index';
-import { type TExtends } from './extends';
-type MappedExtendsPropertyKey<K extends PropertyKey, U extends TSchema, L extends TSchema, R extends TSchema> = {
-    [_ in K]: TExtends<TLiteral<Assert<K, TLiteralValue>>, U, L, R>;
-};
-declare function MappedExtendsPropertyKey<K extends PropertyKey, U extends TSchema, L extends TSchema, R extends TSchema>(K: K, U: U, L: L, R: R): MappedExtendsPropertyKey<K, U, L, R>;
-type MappedExtendsPropertyKeys<K extends PropertyKey[], U extends TSchema, L extends TSchema, R extends TSchema> = (K extends [infer LK extends PropertyKey, ...infer RK extends PropertyKey[]] ? MappedExtendsPropertyKey<LK, U, L, R> & MappedExtendsPropertyKeys<RK, U, L, R> : {});
-declare function MappedExtendsPropertyKeys<K extends PropertyKey[], U extends TSchema, L extends TSchema, R extends TSchema>(K: [...K], U: U, L: L, R: R): MappedExtendsPropertyKeys<K, U, L, R>;
-type MappedExtendsProperties<K extends TMappedKey, U extends TSchema, L extends TSchema, R extends TSchema> = (MappedExtendsPropertyKeys<K['keys'], U, L, R>);
-declare function MappedExtendsProperties<K extends TMappedKey, U extends TSchema, L extends TSchema, R extends TSchema>(K: K, U: U, L: L, R: R): MappedExtendsProperties<K, U, L, R>;
-export type TExtendsMappedResult<T extends TMappedKey, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = MappedExtendsProperties<T, U, L, R>> = (TMappedResult<P>);
-export declare function ExtendsMappedResult<T extends TMappedKey, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = MappedExtendsProperties<T, U, L, R>>(T: T, U: U, L: L, R: R): TMappedResult<P>;
-export {};

package/build/require/type/extends/extends-mapped-result.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExtendsMappedResult = void 0;
-const index_1 = require("../mapped/index");
-const index_2 = require("../literal/index");
-const extends_1 = require("./extends");
-function MappedExtendsPropertyKey(K, U, L, R) {
-    return {
-        [K]: (0, extends_1.Extends)((0, index_2.Literal)(K), U, L, R)
-    };
-}
-function MappedExtendsPropertyKeys(K, U, L, R) {
-    const [LK, ...RK] = K;
-    return (K.length > 0
-        ? { ...MappedExtendsPropertyKey(LK, U, L, R), ...MappedExtendsPropertyKeys(RK, U, L, R) }
-        : {});
-}
-function MappedExtendsProperties(K, U, L, R) {
-    return MappedExtendsPropertyKeys(K.keys, U, L, R);
-}
-function ExtendsMappedResult(T, U, L, R) {
-    const P = MappedExtendsProperties(T, U, L, R);
-    return (0, index_1.MappedResult)(P);
-}
-exports.ExtendsMappedResult = ExtendsMappedResult;