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

package/build/require/type/pick/pick-from-mapped-key.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PickFromMappedKey = void 0;
+const index_1 = require("../mapped/index");
+const pick_1 = require("./pick");
+function FromPropertyKey(T, K, options) {
+    return {
+        [K]: (0, pick_1.Pick)(T, [K], options)
+    };
+}
+function FromPropertyKeys(T, K, options) {
+    const [LK, ...RK] = K;
+    return (K.length > 0
+        ? { ...FromPropertyKey(T, LK, options), ...FromPropertyKeys(T, RK, options) }
+        : {});
+}
+function FromMappedKey(T, K, options) {
+    return FromPropertyKeys(T, K.keys, options);
+}
+function PickFromMappedKey(T, K, options) {
+    const P = FromMappedKey(T, K, options);
+    return (0, index_1.MappedResult)(P);
+}
+exports.PickFromMappedKey = PickFromMappedKey;

package/build/require/type/pick/pick.d.ts

@@ -6,7 +6,7 @@ import { type TUnion } from '../union/index';
 import { type TObject, type TProperties } from '../object/index';
 import { type TIndexPropertyKeys } from '../indexed/index';
 import { TMappedKey } from '../mapped/index';
-import { type TPickMappedResult } from './pick-mapped-result';
+import { type TPickFromMappedKey } from './pick-from-mapped-key';
 type FromIntersect<T extends TSchema[], K extends PropertyKey[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [PickResolve<L, K>, ...FromIntersect<R, K>] : [];
 declare function FromIntersect<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K): FromIntersect<T, K>;
 type FromUnion<T extends TSchema[], K extends PropertyKey[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [PickResolve<L, K>, ...FromUnion<R, K>] : [];
@@ -16,7 +16,7 @@ declare function FromProperties<T extends TProperties, K extends PropertyKey[]>(
 export type PickResolve<T extends TProperties, K extends PropertyKey[]> = T extends TRecursive<infer S> ? TRecursive<PickResolve<S, K>> : T extends TIntersect<infer S> ? TIntersect<FromIntersect<S, K>> : T extends TUnion<infer S> ? TUnion<FromUnion<S, K>> : T extends TObject<infer S> ? TObject<FromProperties<S, K>> : TObject<{}>;
 export declare function PickResolve<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): PickResolve<T, K>;
 export type TPick<T extends TSchema, K extends PropertyKey[]> = PickResolve<T, K>;
-export declare function Pick<T extends TSchema, K extends TMappedKey>(T: T, K: K): TPickMappedResult<T, K>;
+export declare function Pick<T extends TSchema, K extends TMappedKey>(T: T, K: K): TPickFromMappedKey<T, K>;
 export declare function Pick<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TPick<T, I>;
 export declare function Pick<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TPick<T, K>;
 export {};

package/build/require/type/pick/pick.js

@@ -8,7 +8,7 @@ const index_4 = require("../indexed/index");
 const index_5 = require("../discard/index");
 const index_6 = require("../symbols/index");
 const type_1 = require("../clone/type");
-const pick_mapped_result_1 = require("./pick-mapped-result");
+const pick_from_mapped_key_1 = require("./pick-from-mapped-key");
 const type_2 = require("../guard/type");
 function FromIntersect(T, K) {
     return T.map((T) => PickResolve(T, K));
@@ -30,7 +30,7 @@ function PickResolve(T, K) {
 exports.PickResolve = PickResolve;
 function Pick(T, K, options = {}) {
     if ((0, type_2.TMappedKey)(K)) {
-        return (0, pick_mapped_result_1.PickMappedResult)(T, K);
+        return (0, pick_from_mapped_key_1.PickFromMappedKey)(T, K, options);
     }
     else {
         const I = (0, type_2.TSchema)(K) ? (0, index_4.IndexPropertyKeys)(K) : K;

package/build/require/type/required/index.d.ts

@@ -1 +1,2 @@
+export * from './required-from-mapped-result';
 export * from './required';

package/build/require/type/required/index.js

@@ -14,4 +14,5 @@ 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("./required-from-mapped-result"), exports);
 __exportStar(require("./required"), exports);

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

@@ -0,0 +1,13 @@
+import type { SchemaOptions } from '../schema/index';
+import type { TProperties } from '../object/index';
+import { type TMappedResult } from '../mapped/index';
+import { type TRequired } from './required';
+type FromProperties<K extends TProperties> = ({
+    [K2 in keyof K]: TRequired<K[K2]>;
+});
+declare function FromProperties<K extends TProperties>(K: K, options: SchemaOptions): FromProperties<K>;
+type FromMappedResult<K extends TMappedResult> = (FromProperties<K['properties']>);
+declare function FromMappedResult<K extends TMappedResult>(K: K, options: SchemaOptions): FromMappedResult<K>;
+export type TRequiredFromMappedResult<T extends TMappedResult, P extends TProperties = FromMappedResult<T>> = (TMappedResult<P>);
+export declare function RequiredFromMappedResult<T extends TMappedResult, P extends TProperties = FromMappedResult<T>>(T: T, options: SchemaOptions): TMappedResult<P>;
+export {};

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequiredFromMappedResult = void 0;
+const index_1 = require("../mapped/index");
+const required_1 = require("./required");
+function FromProperties(K, options) {
+    return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
+        return { ...Acc, [K2]: (0, required_1.Required)(K[K2], options) };
+    }, {});
+}
+function FromMappedResult(K, options) {
+    return FromProperties(K.properties, options);
+}
+function RequiredFromMappedResult(T, options) {
+    const P = FromMappedResult(T, options);
+    return (0, index_1.MappedResult)(P);
+}
+exports.RequiredFromMappedResult = RequiredFromMappedResult;

package/build/require/type/required/required.d.ts

@@ -1,5 +1,6 @@
 import type { TSchema, SchemaOptions } from '../schema/index';
 import type { Evaluate } from '../helpers/index';
+import type { TMappedResult } from '../mapped/index';
 import { type TReadonlyOptional } from '../readonly-optional/index';
 import { type TOptional } from '../optional/index';
 import { type TReadonly } from '../readonly/index';
@@ -7,6 +8,7 @@ import { type TRecursive } from '../recursive/index';
 import { type TIntersect } from '../intersect/index';
 import { type TUnion } from '../union/index';
 import { type TObject, type TProperties } from '../object/index';
+import { type TRequiredFromMappedResult } from './required-from-mapped-result';
 type FromIntersect<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [RequiredResolve<L>, ...FromIntersect<R>] : []);
 declare function FromIntersect<T extends TSchema[]>(T: [...T]): FromIntersect<T>;
 type FromUnion<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [RequiredResolve<L>, ...FromUnion<R>] : []);
@@ -15,8 +17,9 @@ type FromProperties<T extends TProperties> = Evaluate<{
     [K in keyof T]: T[K] extends (TReadonlyOptional<infer S>) ? TReadonly<S> : T[K] extends (TReadonly<infer S>) ? TReadonly<S> : T[K] extends (TOptional<infer S>) ? S : T[K];
 }>;
 declare function FromProperties<T extends TProperties>(T: T): TProperties;
-export type RequiredResolve<T extends TSchema> = (T extends TRecursive<infer S> ? TRecursive<RequiredResolve<S>> : T extends TIntersect<infer S> ? TIntersect<FromIntersect<S>> : T extends TUnion<infer S> ? TUnion<FromUnion<S>> : T extends TObject<infer S> ? TObject<FromProperties<S>> : TObject<{}>);
-export declare function RequiredResolve<T extends TSchema>(T: T): RequiredResolve<T>;
+type RequiredResolve<T extends TSchema> = (T extends TRecursive<infer S> ? TRecursive<RequiredResolve<S>> : T extends TIntersect<infer S> ? TIntersect<FromIntersect<S>> : T extends TUnion<infer S> ? TUnion<FromUnion<S>> : T extends TObject<infer S> ? TObject<FromProperties<S>> : TObject<{}>);
+declare function RequiredResolve<T extends TSchema>(T: T): RequiredResolve<T>;
 export type TRequired<T extends TSchema> = RequiredResolve<T>;
+export declare function Required<T extends TMappedResult>(T: T, options?: SchemaOptions): TRequiredFromMappedResult<T>;
 export declare function Required<T extends TSchema>(T: T, options?: SchemaOptions): TRequired<T>;
 export {};

package/build/require/type/required/required.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Required = exports.RequiredResolve = void 0;
+exports.Required = void 0;
 const index_1 = require("../intersect/index");
 const index_2 = require("../union/index");
 const index_3 = require("../object/index");
 const index_4 = require("../symbols/index");
 const type_1 = require("../clone/type");
 const index_5 = require("../discard/index");
+const required_from_mapped_result_1 = require("./required-from-mapped-result");
 const type_2 = require("../guard/type");
 function FromIntersect(T) {
     const [L, ...R] = T;
@@ -31,10 +32,14 @@ function RequiredResolve(T) {
             (0, type_2.TObject)(T) ? (0, index_3.Object)(FromProperties(T.properties)) :
                 (0, index_3.Object)({}));
 }
-exports.RequiredResolve = RequiredResolve;
 function Required(T, options = {}) {
-    const D = (0, index_5.Discard)(T, [index_4.TransformKind, '$id', 'required']);
-    const R = (0, type_1.CloneType)(RequiredResolve(T), options);
-    return { ...D, ...R };
+    if ((0, type_2.TMappedResult)(T)) {
+        return (0, required_from_mapped_result_1.RequiredFromMappedResult)(T, options);
+    }
+    else {
+        const D = (0, index_5.Discard)(T, [index_4.TransformKind, '$id', 'required']);
+        const R = (0, type_1.CloneType)(RequiredResolve(T), options);
+        return { ...D, ...R };
+    }
 }
 exports.Required = Required;

package/build/require/type/type/json.d.ts

@@ -5,14 +5,14 @@ import { type TComposite } from '../composite/index';
 import { type TConst } from '../const/index';
 import { type TDeref } from '../deref/index';
 import { type TEnum, type TEnumKey, type TEnumValue } from '../enum/index';
-import { type TExclude } from '../exclude/index';
-import { type TExtends, type TExtendsMappedResult, type TExtendsMappedResultFromResult } from '../extends/index';
-import { type TExtract } from '../extract/index';
-import { TIndex, type TIndexPropertyKeys, type TIndexMappedResult } from '../indexed/index';
+import { type TExclude, type TExcludeFromMappedResult } from '../exclude/index';
+import { type TExtends, type TExtendsFromMappedKey, type TExtendsFromMappedResult } from '../extends/index';
+import { type TExtract, type TExtractFromMappedResult } from '../extract/index';
+import { TIndex, type TIndexPropertyKeys, type TIndexFromMappedKey } from '../indexed/index';
 import { type IntegerOptions, type TInteger } from '../integer/index';
 import { type IntersectOptions, type IntersectResolve } from '../intersect/index';
 import { type TCapitalize, type TUncapitalize, type TLowercase, type TUppercase } from '../intrinsic/index';
-import { type TKeyOf } from '../keyof/index';
+import { type TKeyOf, type TKeyOfFromMappedResult } from '../keyof/index';
 import { type TLiteral, type TLiteralValue } from '../literal/index';
 import { type TMappedFunction, type TMapped, type TMappedResult } from '../mapped/index';
 import { type TNever } from '../never/index';
@@ -21,16 +21,16 @@ import { type TNull } from '../null/index';
 import { type TMappedKey } from '../mapped/index';
 import { type TNumber, type NumberOptions } from '../number/index';
 import { type TObject, type TProperties, type ObjectOptions } from '../object/index';
-import { type TOmit, type TOmitMappedResult } from '../omit/index';
+import { type TOmit, type TOmitFromMappedKey } from '../omit/index';
 import { type TOptional } from '../optional/index';
-import { type TPartial } from '../partial/index';
-import { type TPick, type TPickMappedResult } from '../pick/index';
+import { type TPartial, type TPartialFromMappedResult } from '../partial/index';
+import { type TPick, type TPickFromMappedKey } from '../pick/index';
 import { type TReadonly } from '../readonly/index';
 import { type TReadonlyOptional } from '../readonly-optional/index';
 import { type RecordResolve } from '../record/index';
 import { type TRecursive, type TThis } from '../recursive/index';
 import { type TRef } from '../ref/index';
-import { type TRequired } from '../required/index';
+import { type TRequired, type TRequiredFromMappedResult } from '../required/index';
 import { type TRest } from '../rest/index';
 import { type TSchema, type SchemaOptions } from '../schema/index';
 import { type TString, type StringOptions } from '../string/index';
@@ -53,16 +53,19 @@ export declare class JsonTypeBuilder {
     Const<T>(value: T, options?: SchemaOptions): TConst<T>;
     Deref<T extends TSchema>(schema: T, references: TSchema[]): TDeref<T>;
     Enum<V extends TEnumValue, T extends Record<TEnumKey, V>>(item: T, options?: SchemaOptions): TEnum<T>;
-    Extends<L extends TMappedResult, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtendsMappedResultFromResult<L, R, T, F>;
-    Extends<L extends TMappedKey, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtendsMappedResult<L, R, T, F>;
-    Extends<L extends TSchema, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtends<L, R, T, F>;
+    Exclude<L extends TMappedResult, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExcludeFromMappedResult<L, R>;
     Exclude<L extends TSchema, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExclude<L, R>;
+    Extends<L extends TMappedResult, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtendsFromMappedResult<L, R, T, F>;
+    Extends<L extends TMappedKey, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtendsFromMappedKey<L, R, T, F>;
+    Extends<L extends TSchema, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtends<L, R, T, F>;
+    Extract<L extends TMappedResult, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtractFromMappedResult<L, R>;
     Extract<L extends TSchema, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtract<L, R>;
-    Index<T extends TSchema, K extends TMappedKey>(T: T, K: K): TIndexMappedResult<T, K>;
+    Index<T extends TSchema, K extends TMappedKey>(T: T, K: K, options?: SchemaOptions): TIndexFromMappedKey<T, K>;
     Index<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TIndex<T, I>;
     Index<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TIndex<T, K>;
     Integer(options?: IntegerOptions): TInteger;
     Intersect<T extends TSchema[]>(T: [...T], options?: IntersectOptions): IntersectResolve<T>;
+    KeyOf<T extends TMappedResult>(schema: T, options?: SchemaOptions): TKeyOfFromMappedResult<T>;
     KeyOf<T extends TSchema>(schema: T, options?: SchemaOptions): TKeyOf<T>;
     Literal<T extends TLiteralValue>(value: T, options?: SchemaOptions): TLiteral<T>;
     Lowercase<T extends TSchema>(schema: T, options?: SchemaOptions): TLowercase<T>;
@@ -73,18 +76,20 @@ export declare class JsonTypeBuilder {
     Null(options?: SchemaOptions): TNull;
     Number(options?: NumberOptions): TNumber;
     Object<T extends TProperties>(properties: T, options?: ObjectOptions): TObject<T>;
-    Omit<T extends TSchema, K extends TMappedKey>(T: T, K: K): TOmitMappedResult<T, K>;
+    Omit<T extends TSchema, K extends TMappedKey>(T: T, K: K): TOmitFromMappedKey<T, K>;
     Omit<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TOmit<T, I>;
     Omit<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TOmit<T, K>;
+    Partial<T extends TMappedResult>(T: T, options?: ObjectOptions): TPartialFromMappedResult<T>;
     Partial<T extends TSchema>(schema: T, options?: ObjectOptions): TPartial<T>;
-    Pick<T extends TSchema, K extends TMappedKey>(T: T, K: K): TPickMappedResult<T, K>;
+    Pick<T extends TSchema, K extends TMappedKey>(T: T, K: K): TPickFromMappedKey<T, K>;
     Pick<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TPick<T, I>;
     Pick<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TPick<T, K>;
     Record<K extends TSchema, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): RecordResolve<K, T>;
     Recursive<T extends TSchema>(callback: (thisType: TThis) => T, options?: SchemaOptions): TRecursive<T>;
     Ref<T extends TSchema>(schema: T, options?: SchemaOptions): TRef<T>;
     Ref<T extends TSchema>($ref: string, options?: SchemaOptions): TRef<T>;
-    Required<T extends TSchema>(schema: T, options?: SchemaOptions): TRequired<T>;
+    Required<T extends TMappedResult>(T: T, options?: ObjectOptions): TRequiredFromMappedResult<T>;
+    Required<T extends TSchema>(schema: T, options?: ObjectOptions): TRequired<T>;
     Rest<T extends TSchema>(schema: T): TRest<T>;
     String(options?: StringOptions): TString;
     TemplateLiteral<T extends string>(syntax: T, options?: SchemaOptions): TemplateLiteralSyntax<T>;

package/build/require/type/type/json.js

@@ -79,12 +79,12 @@ class JsonTypeBuilder {
     Enum(item, options = {}) {
         return (0, index_7.Enum)(item, options);
     }
-    Extends(L, R, T, F, options = {}) {
-        return (0, index_9.Extends)(L, R, T, F, options);
-    }
     Exclude(unionType, excludedMembers, options = {}) {
         return (0, index_8.Exclude)(unionType, excludedMembers, options);
     }
+    Extends(L, R, T, F, options = {}) {
+        return (0, index_9.Extends)(L, R, T, F, options);
+    }
     Extract(type, union, options = {}) {
         return (0, index_10.Extract)(type, union, options);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.0-dev-14",
+  "version": "0.32.0-dev-15",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",

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
 
@@ -67,7 +67,7 @@ License MIT
   - [JavaScript](#types-javascript)
   - [Options](#types-options)
   - [Properties](#types-properties)
-  - [Imports](#types-imports)
+  - [Modular](#types-modular)
   - [Generics](#types-generics)
   - [References](#types-references)
   - [Recursive](#types-recursive)
@@ -717,30 +717,19 @@ Object properties can be modified with Readonly and Optional. The following tabl
 └────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
 ```
 
-<a name='types-imports'></a>
+<a name='types-modular'></a>
 
-### Import Types
+### Modular 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.
+TypeBox implements a modular type system. The following imports the full type system (recommended)
 
 ```typescript
-import { Type } from '@sinclair/typebox'             // 34.9 kb minified
-
-const T = Type.Object({
-  x: Type.Number(),
-  y: Type.Number()
-})
+import { Type } from '@sinclair/typebox'             // 36.5 kb minified
 ```
-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.
+The following imports types individually which enables modern bundlers to optimize bundle sizes via tree shaking.
 ```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>
 
@@ -811,7 +800,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 +879,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 +924,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<{
@@ -996,7 +985,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 +1129,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 +1582,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 +1624,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 +1708,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 +1722,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 +1764,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 +1808,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.3 kb' │ ' 52.4 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.0 kb' │ ' 61.5 kb' │  '2.34 x'   │
+│ typebox              │ ' 87.0 kb' │ ' 36.5 kb' │  '2.39 x'   │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```