@sinclair/typebox 0.32.0-dev-22 → 0.32.0-dev-24

package/readme.md

@@ -51,9 +51,9 @@ type T = Static<typeof T>                            // type T = {
 
 ## Overview
 
-TypeBox is a runtime type builder that creates in-memory Json Schema objects that infer as TypeScript types. The Json Schema produced by this library is designed to match the static type checking rules of the TypeScript compiler. TypeBox provides a unified type that can be statically checked by the TypeScript compiler and runtime asserted using standard Json Schema validation.
+TypeBox is a runtime type builder that creates in-memory Json Schema objects that infer as TypeScript types. The schematics produced by this library are designed to match the static type checking rules of the TypeScript compiler. TypeBox offers a unified type that can be statically checked by TypeScript and runtime asserted using standard Json Schema validation.
 
-This library enables Json Schema to be created with the same expressiveness as TypeScript's type system. It can be used either as a simple tool to build up complex schematics or integrated into REST or RPC services to help validate data received over the wire.
+This library is designed to be a runtime type system with capabilities similar to TypeScript's static type system. It can be used as a simple tool to build up complex schematics or integrated into REST and RPC services to help validate data received over the wire.
 
 License MIT
 
@@ -64,16 +64,16 @@ License MIT
 - [Types](#types)
   - [Json](#types-json)
   - [JavaScript](#types-javascript)
-  - [Modules](#types-modules)
+  - [Import](#types-import)
   - [Options](#types-options)
   - [Properties](#types-properties)
   - [Generics](#types-generics)
   - [References](#types-references)
   - [Recursive](#types-recursive)
   - [Template Literal](#types-template-literal)
-  - [Conditional](#types-conditional)
-  - [Mapped](#types-mapped)
   - [Indexed](#types-indexed)
+  - [Mapped](#types-mapped)
+  - [Conditional](#types-conditional)
   - [Intrinsic](#types-intrinsic)
   - [Transform](#types-transform)
   - [Rest](#types-rest)
@@ -643,33 +643,25 @@ TypeBox provides an extended type set that can be used to create schematics for
 └────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
 ```
 
-<a name='types-modules'></a>
+<a name='types-import'></a>
 
-### Modules
+### Import
 
-TypeBox supports a modular type system that allows for selective type imports. Using selective imports can be helpful in resource constrained environments as it enables modern bundlers to tree shake unused types. This can lead to reduced bundle sizes.
+You can import Type to bring in the full type system. This is recommended for most users.
 
+```typescript
+import { Type, type Static } from '@sinclair/typebox'
+```
+You can also import types individually. This approach enables modern bundlers to tree shake unused types.
 ```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
 
-You can pass Json Schema options on the last argument of any type. Option hints specific to each type are provided for convenience.
+You can pass Json Schema options on the last argument of any given type. Option hints specific to each type are provided for convenience.
 
 ```typescript
 // String must be an email
@@ -742,31 +734,22 @@ Object properties can be modified with Readonly and Optional. The following tabl
 
 ### Generic Types
 
-Generic types can be created with generic functions. All types extend the base type TSchema. It is common to constrain generic function arguments to this type. The following creates a generic Vector type.
+Generic types can be created with functions. TypeBox types extend the TSchema interface so you should constrain parameters to this type. The following creates a generic Vector type.
 
 ```typescript
 import { Type, type Static, type TSchema } from '@sinclair/typebox'
 
-const Vector = <T extends TSchema>(t: T) => Type.Object({ x: t, y: t, z: t })
+const Vector = <T extends TSchema>(T: T) => 
+  Type.Object({                                      // type Vector<T> = {
+    x: T,                                            //   x: T,
+    y: T,                                            //   y: T,
+    z: T                                             //   z: T
+  })                                                 // }
 
-const NumberVector = Vector(Type.Number())           // const NumberVector = {
-                                                     //   type: 'object',
-                                                     //   required: ['x', 'y', 'z'],
-                                                     //   properties: {
-                                                     //     x: { type: 'number' },
-                                                     //     y: { type: 'number' },
-                                                     //     z: { type: 'number' }
-                                                     //   }
-                                                     // }
-
-type NumberVector = Static<typeof NumberVector>      // type NumberVector = {
-                                                     //   x: number,
-                                                     //   y: number,
-                                                     //   z: number
-                                                     // }
+const NumberVector = Vector(Type.Number())           // type NumberVector = Vector<number>
 ```
 
-Generic types are often used to create aliases for more complex types. The following creates a Nullable generic type.
+Generic types are often used to create aliases for complex types. The following creates a Nullable generic type.
 
 ```typescript
 const Nullable = <T extends TSchema>(schema: T) => Type.Union([schema, Type.Null()])
@@ -785,7 +768,7 @@ type T = Static<typeof T>                            // type T = string | null
 
 ### Reference Types
 
-Reference types can be created with Type.Ref. These types infer the same as the target type.
+Reference types can be created with Ref. These types infer the same as the target type but only store a named `$ref` to the target type.
 
 ```typescript
 const Vector = Type.Object({                         // const Vector = {
@@ -807,7 +790,7 @@ type VectorRef = Static<typeof VectorRef>            // type VectorRef = {
                                                      //    y: number
                                                      // }
 ```
-Use Type.Deref to dereference a type. This will replace any `$ref` with the target type.
+Use Deref to dereference a type. This function will replace any interior reference with the target type.
 ```typescript
 const Vertex = Type.Object({                         // const Vertex = {
   position: VectorRef,                               //   type: 'object',
@@ -840,16 +823,14 @@ const VertexDeref = Type.Deref(Vertex, [Vector])     // const VertexDeref = {
                                                      //     }
                                                      //   }
                                                      // }
-
-
 ```
-Note that reference types do not contain structural information about the type they're referencing. This means they cannot be used directly with some type mapping types (such as Partial) that require structural information to operate. For applications that need mapping on references, use Type.Deref to dereference the type first.
+Note that Ref types do not store structural information about the type they're referencing. Because of this, these types cannot be used with some mapping types (such as Partial or Pick). For applications that require mapping on Ref, use Deref to normalize the type first.
 
 <a name='types-recursive'></a>
 
 ### Recursive Types
 
-TypeBox supports singular recursive data structures. Recursive type inference is also supported. The following creates a recursive Node data structure.
+TypeBox supports recursive data structures with Recursive. This type wraps an interior type and provides it a `this` context that allows the type to reference itself. The following creates a recursive type. Singular recursive inference is also supported.
 
 ```typescript
 const Node = Type.Recursive(This => Type.Object({    // const Node = {
@@ -886,7 +867,7 @@ function test(node: Node) {
 
 ### Template Literal Types
 
-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.
+TypeBox supports template literal types with 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 expressions which enables the template to be checked by Json Schema validators. This type also supports regular expression parsing that enables template patterns to be used for generative types. The following shows both TypeScript and TypeBox usage.
 
 ```typescript
 // TypeScript
@@ -917,56 +898,50 @@ const R = Type.Record(K, Type.String())              // const R: TObject<{
                                                      // }>
 ```
 
-<a name='types-conditional'></a>
+<a name='types-indexed'></a>
 
-### Conditional Types
+### Indexed Access 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. The conditional types Exclude and Extract are also supported. The following shows both TypeScript and TypeBox examples of conditional types.
+TypeBox supports indexed access types with Index. This type enables uniform access to interior property and 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
-// Extends
-
-type T = string extends number ? true : false        // type T = false
-
-const T = Type.Extends(                              // const T: TLiteral<false>
-  Type.String(), 
-  Type.Number(), 
-  Type.Literal(true), 
-  Type.Literal(false)
-)
-
-// Extract
-
-type T = Extract<1 | 2 | 3, 1>                       // type T = 1
-
-const T = Type.Extract(                              // const T: TLiteral<1> 
-  Type.Union([
-    Type.Literal(1),
-    Type.Literal(2), 
-    Type.Literal(3) 
-  ]), 
-  Type.Literal(1)
-)
+const T = Type.Object({                              // const T: TObject<{
+  x: Type.Number(),                                  //   x: TNumber,
+  y: Type.String(),                                  //   y: TString,
+  z: Type.Boolean()                                  //   z: TBoolean
+})                                                   // }>
 
-// Exclude
+const A = Type.Index(T, ['x'])                       // type A = T['x']
+                                                     //
+                                                     // ... evaluates as
+                                                     //
+                                                     // const A: TNumber
 
-type T = Exclude<1 | 2 | 3, 1>                       // type T = 2 | 3
+const B = Type.Index(T, ['x', 'y'])                  // type B = T['x' | 'y']
+                                                     //
+                                                     // ... evaluates as
+                                                     //
+                                                     // const B: TUnion<[
+                                                     //   TNumber,
+                                                     //   TString,
+                                                     // ]>
 
-const T = Type.Exclude(                              // const T: TUnion<[
-  Type.Union([                                       //   TLiteral<2>,
-    Type.Literal(1),                                 //   TLiteral<3>
-    Type.Literal(2),                                 // ]>
-    Type.Literal(3)
-  ]),
-  Type.Literal(1)
-)
+const C = Type.Index(T, Type.KeyOf(T))               // type C = T[keyof T]
+                                                     //
+                                                     // ... evaluates as
+                                                     // 
+                                                     // const C: TUnion<[
+                                                     //   TNumber,
+                                                     //   TString,
+                                                     //   TBoolean
+                                                     // ]>
 ```
 
 <a name='types-mapped'></a>
 
 ### Mapped Types
 
-TypeBox supports Mapped types with Type.Mapped. This type accepts two arguments, the first a union of literal keys and the second a type mapping function which receives a mapping key `K`. The following remaps the type `T` to be `Partial<T>` using type mapping.
+TypeBox supports mapped object types with Mapped. This type accepts two arguments, the first is a union type typically derived from KeyOf, the second is a mapping function that receives a mapping key `K` that can be used to index properties of a type. The following implements Partial using mapped types.
 
 ```typescript
 const T = Type.Object({                              // const T: TObject<{
@@ -975,61 +950,68 @@ const T = Type.Object({                              // const T: TObject<{
   z: Type.Boolean()                                  //   z: TBoolean
 })                                                   // }>
 
-const M = Type.Mapped(Type.KeyOf(T), K => {          // type M = { [K in keyof T]?: T[K] }
+const P = Type.Mapped(Type.KeyOf(T), K => {          // type P = { [K in keyof T]?: T[K] }
   return Type.Optional(Type.Index(T, K))             //
-})                                                   // 
-                                                     
-                                                     // ... runtime mapped as
-                                                     //
-                                                     // const M: TObject<{
+})                                                   // ... evaluated as
+                                                     // 
+                                                     // const P: TObject<{
                                                      //   x: TOptional<TNumber>,
                                                      //   y: TOptional<TString>,
                                                      //   z: TOptional<TBoolean>
                                                      // }>
 ```
 
-<a name='types-indexed'></a>
+<a name='types-conditional'></a>
 
-### Indexed Access Types
+### Conditional 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 runtime conditional types with Extends. This type performs a structural assignability check against the first (`left`) and second (`right`) 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
-const T = Type.Object({                              // const T: TObject<{
-  x: Type.Number(),                                  //   x: TNumber,
-  y: Type.String(),                                  //   y: TString,
-  z: Type.Boolean()                                  //   z: TBoolean
-})                                                   // }>
-
-const A = Type.Index(T, ['x'])                       // const A: TNumber
+// Extends
+const T = Type.Extends(                              // type T = string extends number ? true : false
+  Type.String(),                                     //   
+  Type.Number(),                                     // ... evaluated as
+  Type.Literal(true),                                //
+  Type.Literal(false)                                // const T: TLiteral<false>
+)
 
-const B = Type.Index(T, ['x', 'y'])                  // const B: TUnion<[
-                                                     //   TNumber,
-                                                     //   TString,
-                                                     // ]>
+// Extract
+const T = Type.Extract(                              // type T = Extract<1 | 2 | 3, 1>
+  Type.Union([                                       //
+    Type.Literal(1),                                 // ... evaluated as
+    Type.Literal(2),                                 //
+    Type.Literal(3)                                  // const T: TLiteral<1>
+  ]), 
+  Type.Literal(1)
+)
 
-const C = Type.Index(T, Type.KeyOf(T))               // const C: TUnion<[
-                                                     //   TNumber,
-                                                     //   TString,
-                                                     //   TBoolean
-                                                     // ]>
+// Exclude
+const T = Type.Exclude(                              // type T = Exclude<1 | 2 | 3, 1>
+  Type.Union([                                       // 
+    Type.Literal(1),                                 // ... evaluated as
+    Type.Literal(2),                                 //
+    Type.Literal(3)                                  // const T: TUnion<[
+  ]),                                                //   TLiteral<2>,
+  Type.Literal(1)                                    //   TLiteral<3>,
+)                                                    // ]>
 ```
 
 <a name='types-intrinsic'></a>
 
 ### Intrinsic Types
 
-TypeBox supports the TypeScript Intrinsic String Manipulation types Uppercase, Lowercase, Capitalize and Uncapitalize. These types can be used to remap String Literal, Template Literal and Union of Literal types.
+TypeBox supports the TypeScript intrinsic string manipulation types Uppercase, Lowercase, Capitalize and Uncapitalize. These types can be used to remap Literal, Template Literal and Union of Literal types.
 
 ```typescript
 // TypeScript
-
 type A = Capitalize<'hello'>                         // type A = 'Hello'
+
 type B = Capitalize<'hello' | 'world'>               // type C = 'Hello' | 'World'
+
 type C = Capitalize<`hello${1|2|3}`>                 // type B = 'Hello1' | 'Hello2' | 'Hello3'
 
 // TypeBox
-
 const A = Type.Capitalize(Type.Literal('hello'))     // const A: TLiteral<'Hello'>
 
 const B = Type.Capitalize(Type.Union([               // const B: TUnion<[
@@ -1051,7 +1033,7 @@ const C = Type.Capitalize(                           // const C: TTemplateLitera
 
 ### Transform Types
 
-TypeBox supports value decoding and encoding with Transform types. These types work in tandem with the Encode and Decode functions available on the Value and TypeCompiler modules. Transform types can be used to convert Json encoded values into constructs more natural to JavaScript. The following creates a Transform type to decode numbers into Dates using the Value module.
+TypeBox supports value decoding and encoding with Transform types. These types work in tandem with the Encode and Decode functions available on the Value and TypeCompiler submodules. Transform types can be used to convert Json encoded values into constructs more natural to JavaScript. The following creates a Transform type to decode numbers into Dates using the Value submodule.
 
 ```typescript
 import { Value } from '@sinclair/typebox/value'
@@ -1103,13 +1085,11 @@ const U = Type.Union(R)                              // const T: TUnion<[
 TypeBox supports user defined types with Unsafe. This type allows you to specify both schema representation and inference type. The following creates an Unsafe type with a number schema that infers as string.
 
 ```typescript
-const T = Type.Unsafe<string>({ type: 'number' })    // const T = {
-                                                     //   type: 'number'
-                                                     // }
+const T = Type.Unsafe<string>({ type: 'number' })    // const T = { type: 'number' }
 
 type T = Static<typeof T>                            // type T = string - ?
 ```
-The Unsafe type is often used to create schematics for extended specifications like OpenAPI
+The Unsafe type is often used to create schematics for extended specifications like OpenAPI.
 ```typescript
 
 const Nullable = <T extends TSchema>(schema: T) => Type.Unsafe<Static<T> | null>({ 
@@ -1136,12 +1116,12 @@ 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 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 `T` is TString.
+TypeBox can check its own types with the TypeGuard module. This module is written for type introspection and provides structural tests for every built-in TypeBox type. Functions of this module return `is` guards which can be used with control flow assertions to obtain schema inference for unknown values. The following guards that the value `T` is TString.
 
 ```typescript
 import { TypeGuard, Kind } from '@sinclair/typebox'
 
-const T: unknown = { [Kind]: 'String', type: 'string' }
+const T = { [Kind]: 'String', type: 'string' }
 
 if(TypeGuard.IsString(T)) {
 
@@ -1182,7 +1162,7 @@ const U = Type.Strict(T)                             // const U = {
 
 ## Values
 
-TypeBox provides an optional utility module that can be used to perform structural operations on JavaScript values. This module includes functionality to create, check and cast values from types as well as check equality, clone, diff and patch JavaScript values. This module is provided via optional import.
+TypeBox provides an optional Value submodule that can be used to perform structural operations on JavaScript values. This submodule includes functionality to create, check and cast values from types as well as check equality, clone, diff and patch JavaScript values. This submodule is provided via optional import.
 
 ```typescript
 import { Value } from '@sinclair/typebox/value'
@@ -1240,7 +1220,7 @@ const R2 = Value.Convert(T, { x: 'not a number' })   // const R2 = { x: 'not a n
 
 ### Clean
 
-Removes excess properties from a value and returns the result. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first.
+Use Clean to remove excess properties from a value. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first.
 
 ```typescript
 const T = Type.Object({ 
@@ -1259,7 +1239,7 @@ const Z = Value.Clean(T, { x: 1, y: 2, z: 3 })        // const 'Z = { x: 1, y: 2
 
 ### Default
 
-Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first.
+Use Default to generate missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first.
 
 ```typescript
 const T = Type.Object({ 
@@ -1278,7 +1258,7 @@ const Z = Value.Default(T, { x: 1 })                    // const 'Z = { x: 1, y:
 
 ### Cast
 
-Use the Cast function to cast a value with a type. The cast function will retain as much information as possible from the original value.
+Use the Cast function to upcast a value into a target type. This function will retain as much infomation as possible from the original value. The Cast function is intended to be used in data migration scenarios where existing values need to be upgraded to match a modified type.
 
 ```typescript
 const T = Type.Object({ x: Type.Number(), y: Type.Number() }, { additionalProperties: false })
@@ -1294,7 +1274,7 @@ const Z = Value.Cast(T, { x: 1, y: 2, z: 3 })        // const Z = { x: 1, y: 2 }
 
 ### Decode
 
-Use the Decode function to decode a value from a type, or throw if the value is invalid. The return value will infer as the decoded type. This function will run Transform codecs if available.
+Use the Decode function to decode a value from a type or throw if the value is invalid. The return value will infer as the decoded type. This function will run Transform codecs if available.
 
 ```typescript
 const A = Value.Decode(Type.String(), 'hello')        // const A = 'hello'
@@ -1305,7 +1285,7 @@ const B = Value.Decode(Type.String(), 42)             // throw
 
 ### Encode
 
-Use the Encode function to encode a value to a type, or throw if the value is invalid. The return value will infer as the encoded type. This function will run Transform codecs if available.
+Use the Encode function to encode a value to a type or throw if the value is invalid. The return value will infer as the encoded type. This function will run Transform codecs if available.
 
 ```typescript
 const A = Value.Encode(Type.String(), 'hello')        // const A = 'hello'
@@ -1405,7 +1385,7 @@ const Y = { z: 1 }                                   // const Y = { z: 1 }
 const X = { y: Y }                                   // const X = { y: { z: 1 } }
 const A = { x: X }                                   // const A = { x: { y: { z: 1 } } }
 
-Value.Mutate(A, { x: { y: { z: 2 } } })              // const A' = { x: { y: { z: 2 } } }
+Value.Mutate(A, { x: { y: { z: 2 } } })              // A' = { x: { y: { z: 2 } } }
 
 const R0 = A.x.y.z === 2                             // const R0 = true
 const R1 = A.x.y === Y                               // const R1 = true
@@ -1423,9 +1403,9 @@ import { ValuePointer } from '@sinclair/typebox/value'
 
 const A = { x: 0, y: 0, z: 0 }
 
-ValuePointer.Set(A, '/x', 1)                         // const A' = { x: 1, y: 0, z: 0 }
-ValuePointer.Set(A, '/y', 1)                         // const A' = { x: 1, y: 1, z: 0 }
-ValuePointer.Set(A, '/z', 1)                         // const A' = { x: 1, y: 1, z: 1 }
+ValuePointer.Set(A, '/x', 1)                         // A' = { x: 1, y: 0, z: 0 }
+ValuePointer.Set(A, '/y', 1)                         // A' = { x: 1, y: 1, z: 0 }
+ValuePointer.Set(A, '/z', 1)                         // A' = { x: 1, y: 1, z: 1 }
 ```
 
 <a name='typeregistry'></a>
@@ -1575,7 +1555,7 @@ const all = [...C.Errors(value)]                     // const all = [{
                                                      // }]
 ```
 
-Use the Code function to generate assertion functions as strings. This function can be used to create high performance assertions that can be written to disk as importable modules. The following generates code to check a string.
+Use the Code function to generate assertion functions as strings. This function can be used to generate code that can be written to disk as importable modules. This technique is sometimes referred to as Ahead of Time (AOT) compilation. The following generates code to check a string.
 
 ```typescript
 const C = TypeCompiler.Code(Type.String())           // const C = `return function check(value) {
@@ -1595,7 +1575,7 @@ The TypeBox TypeSystem module provides configurations to use either Json Schema
 
 ### Policies
 
-TypeBox validates using standard Json Schema assertion policies by default. The TypeSystemPolicy module can override some of these to have TypeBox check values inline with TypeScript static assertions. It also provides overrides for certain checking rules related to non-serializable values (such as void) which can be useful in Json based protocols such as JsonRpc-2. 
+TypeBox validates using standard Json Schema assertion policies by default. The TypeSystemPolicy module can override some of these to have TypeBox assert values inline with TypeScript static checks. It also provides overrides for certain checking rules related to non-serializable values (such as void) which can be helpful in Json based protocols such as Json Rpc 2.0. 
 
 The following overrides are available.
 
@@ -1622,7 +1602,7 @@ TypeSystemPolicy.AllowNaN = true
 
 // Allow void types to check with undefined and null (default is false)
 //
-// Used to signal void return on Json-RPC 2.0 protocol
+// Used to signal void return on Json-Rpc 2.0 protocol
 
 TypeSystemPolicy.AllowNullVoid = true
 ```
@@ -1686,7 +1666,7 @@ TypeBox offers a web based code generation tool that can convert TypeScript type
 
 ## TypeBox Codegen
 
-TypeBox provides a code generation library that can be used to automate type translation between TypeScript and TypeBox. This library also includes functionality to transform TypeScript types to other ecosystem libraries.
+TypeBox provides a code generation library that can be integrated into toolchains to automate type translation between TypeScript and TypeBox. This library also includes functionality to transform TypeScript types to other ecosystem libraries.
 
 [TypeBox Codegen Link Here](https://github.com/sinclairzx81/typebox-codegen)
 
@@ -1815,11 +1795,11 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │       (index)        │  Compiled  │  Minified  │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ 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/value        │ '144.8 kb' │ ' 61.8 kb' │  '2.34 x'   │
-│ typebox              │ ' 87.7 kb' │ ' 36.7 kb' │  '2.39 x'   │
+│ typebox/compiler     │ '119.9 kb' │ ' 52.5 kb' │  '2.29 x'   │
+│ typebox/errors       │ ' 55.5 kb' │ ' 25.2 kb' │  '2.21 x'   │
+│ typebox/system       │ '  4.7 kb' │ '  2.0 kb' │  '2.33 x'   │
+│ typebox/value        │ '146.8 kb' │ ' 61.9 kb' │  '2.37 x'   │
+│ typebox              │ ' 90.7 kb' │ ' 37.7 kb' │  '2.40 x'   │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```