@sinclair/typebox 0.32.0-dev-11 → 0.32.0-dev-13

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

@@ -17,42 +17,43 @@ const index_13 = require("../intersect/index");
 const index_14 = require("../intrinsic/index");
 const index_15 = require("../keyof/index");
 const index_16 = require("../literal/index");
-const index_17 = require("../never/index");
-const index_18 = require("../not/index");
-const index_19 = require("../null/index");
-const index_20 = require("../number/index");
-const index_21 = require("../object/index");
-const index_22 = require("../omit/index");
-const index_23 = require("../optional/index");
-const index_24 = require("../partial/index");
-const index_25 = require("../pick/index");
-const index_26 = require("../readonly/index");
-const index_27 = require("../readonly-optional/index");
-const index_28 = require("../record/index");
-const index_29 = require("../recursive/index");
-const index_30 = require("../ref/index");
-const index_31 = require("../required/index");
-const index_32 = require("../rest/index");
-const index_33 = require("../strict/index");
-const index_34 = require("../string/index");
-const index_35 = require("../template-literal/index");
-const index_36 = require("../transform/index");
-const index_37 = require("../tuple/index");
-const index_38 = require("../union/index");
-const index_39 = require("../unknown/index");
-const index_40 = require("../unsafe/index");
+const index_17 = require("../mapped/index");
+const index_18 = require("../never/index");
+const index_19 = require("../not/index");
+const index_20 = require("../null/index");
+const index_21 = require("../number/index");
+const index_22 = require("../object/index");
+const index_23 = require("../omit/index");
+const index_24 = require("../optional/index");
+const index_25 = require("../partial/index");
+const index_26 = require("../pick/index");
+const index_27 = require("../readonly/index");
+const index_28 = require("../readonly-optional/index");
+const index_29 = require("../record/index");
+const index_30 = require("../recursive/index");
+const index_31 = require("../ref/index");
+const index_32 = require("../required/index");
+const index_33 = require("../rest/index");
+const index_34 = require("../strict/index");
+const index_35 = require("../string/index");
+const index_36 = require("../template-literal/index");
+const index_37 = require("../transform/index");
+const index_38 = require("../tuple/index");
+const index_39 = require("../union/index");
+const index_40 = require("../unknown/index");
+const index_41 = require("../unsafe/index");
 class JsonTypeBuilder {
     Strict(schema) {
-        return (0, index_33.Strict)(schema);
+        return (0, index_34.Strict)(schema);
     }
     ReadonlyOptional(schema) {
-        return (0, index_27.ReadonlyOptional)(schema);
+        return (0, index_28.ReadonlyOptional)(schema);
     }
     Readonly(schema) {
-        return (0, index_26.Readonly)(schema);
+        return (0, index_27.Readonly)(schema);
     }
     Optional(schema) {
-        return (0, index_23.Optional)(schema);
+        return (0, index_24.Optional)(schema);
     }
     Any(options = {}) {
         return (0, index_1.Any)(options);
@@ -78,8 +79,8 @@ class JsonTypeBuilder {
     Enum(item, options = {}) {
         return (0, index_7.Enum)(item, options);
     }
-    Extends(left, right, trueType, falseType, options = {}) {
-        return (0, index_9.Extends)(left, right, trueType, falseType, 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);
@@ -105,68 +106,71 @@ class JsonTypeBuilder {
     Lowercase(schema, options = {}) {
         return (0, index_14.Lowercase)(schema, options);
     }
+    Mapped(key, map, options = {}) {
+        return (0, index_17.Mapped)(key, map, options);
+    }
     Never(options = {}) {
-        return (0, index_17.Never)(options);
+        return (0, index_18.Never)(options);
     }
     Not(schema, options) {
-        return (0, index_18.Not)(schema, options);
+        return (0, index_19.Not)(schema, options);
     }
     Null(options = {}) {
-        return (0, index_19.Null)(options);
+        return (0, index_20.Null)(options);
     }
     Number(options = {}) {
-        return (0, index_20.Number)(options);
+        return (0, index_21.Number)(options);
     }
     Object(properties, options = {}) {
-        return (0, index_21.Object)(properties, options);
+        return (0, index_22.Object)(properties, options);
     }
     Omit(schema, unresolved, options = {}) {
-        return (0, index_22.Omit)(schema, unresolved, options);
+        return (0, index_23.Omit)(schema, unresolved, options);
     }
     Partial(schema, options = {}) {
-        return (0, index_24.Partial)(schema, options);
+        return (0, index_25.Partial)(schema, options);
     }
     Pick(schema, unresolved, options = {}) {
-        return (0, index_25.Pick)(schema, unresolved, options);
+        return (0, index_26.Pick)(schema, unresolved, options);
     }
     Record(key, schema, options = {}) {
-        return (0, index_28.Record)(key, schema);
+        return (0, index_29.Record)(key, schema);
     }
     Recursive(callback, options = {}) {
-        return (0, index_29.Recursive)(callback, options);
+        return (0, index_30.Recursive)(callback, options);
     }
     Ref(unresolved, options = {}) {
-        return (0, index_30.Ref)(unresolved, options);
+        return (0, index_31.Ref)(unresolved, options);
     }
     Required(schema, options = {}) {
-        return (0, index_31.Required)(schema, options);
+        return (0, index_32.Required)(schema, options);
     }
     Rest(schema) {
-        return (0, index_32.Rest)(schema);
+        return (0, index_33.Rest)(schema);
     }
     String(options = {}) {
-        return (0, index_34.String)(options);
+        return (0, index_35.String)(options);
     }
     TemplateLiteral(unresolved, options = {}) {
-        return (0, index_35.TemplateLiteral)(unresolved, options);
+        return (0, index_36.TemplateLiteral)(unresolved, options);
     }
     Transform(schema) {
-        return (0, index_36.Transform)(schema);
+        return (0, index_37.Transform)(schema);
     }
     Tuple(items, options = {}) {
-        return (0, index_37.Tuple)(items, options);
+        return (0, index_38.Tuple)(items, options);
     }
     Uncapitalize(schema, options = {}) {
         return (0, index_14.Uncapitalize)(schema, options);
     }
     Union(schemas, options = {}) {
-        return (0, index_38.Union)(schemas, options);
+        return (0, index_39.Union)(schemas, options);
     }
     Unknown(options = {}) {
-        return (0, index_39.Unknown)(options);
+        return (0, index_40.Unknown)(options);
     }
     Unsafe(options = {}) {
-        return (0, index_40.Unsafe)(options);
+        return (0, index_41.Unsafe)(options);
     }
     Uppercase(schema, options = {}) {
         return (0, index_14.Uppercase)(schema, options);

package/build/require/value/check/check.js

@@ -142,12 +142,12 @@ function TInteger(schema, references, value) {
 function TIntersect(schema, references, value) {
     const check1 = schema.allOf.every((schema) => Visit(schema, references, value));
     if (schema.unevaluatedProperties === false) {
-        const keyPattern = new RegExp((0, index_6.KeyOfStringResolvePattern)(schema));
+        const keyPattern = new RegExp((0, index_6.KeyOfPattern)(schema));
         const check2 = Object.getOwnPropertyNames(value).every((key) => keyPattern.test(key));
         return check1 && check2;
     }
     else if ((0, type_1.TSchema)(schema.unevaluatedProperties)) {
-        const keyCheck = new RegExp((0, index_6.KeyOfStringResolvePattern)(schema));
+        const keyCheck = new RegExp((0, index_6.KeyOfPattern)(schema));
         const check2 = Object.getOwnPropertyNames(value).every((key) => keyCheck.test(key) || Visit(schema.unevaluatedProperties, references, value[key]));
         return check1 && check2;
     }

package/build/require/value/clean/clean.js

@@ -3,16 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Clean = void 0;
 const index_1 = require("../guard/index");
 const type_1 = require("../../type/guard/type");
-const keyof_string_1 = require("../../type/keyof/keyof-string");
-const index_2 = require("../check/index");
-const index_3 = require("../clone/index");
-const index_4 = require("../deref/index");
-const index_5 = require("../../type/symbols/index");
+const index_2 = require("../../type/keyof/index");
+const index_3 = require("../check/index");
+const index_4 = require("../clone/index");
+const index_5 = require("../deref/index");
+const index_6 = require("../../type/symbols/index");
 function IsSchema(schema) {
     return (0, type_1.TSchema)(schema);
 }
 function IsCheckable(schema) {
-    return (0, type_1.TSchema)(schema) && schema[index_5.Kind] !== 'Unsafe';
+    return (0, type_1.TSchema)(schema) && schema[index_6.Kind] !== 'Unsafe';
 }
 function TArray(schema, references, value) {
     if (!(0, index_1.IsArray)(value))
@@ -21,15 +21,15 @@ function TArray(schema, references, value) {
 }
 function TIntersect(schema, references, value) {
     const unevaluatedProperties = schema.unevaluatedProperties;
-    const intersections = schema.allOf.map((schema) => Visit(schema, references, (0, index_3.Clone)(value)));
+    const intersections = schema.allOf.map((schema) => Visit(schema, references, (0, index_4.Clone)(value)));
     const composite = intersections.reduce((acc, value) => ((0, index_1.IsObject)(value) ? { ...acc, ...value } : value), {});
     if (!(0, index_1.IsObject)(value) || !(0, index_1.IsObject)(composite) || !IsSchema(unevaluatedProperties))
         return composite;
-    const knownkeys = (0, keyof_string_1.KeyOfStringResolve)(schema);
+    const knownkeys = (0, index_2.KeyOfPropertyKeys)(schema);
     for (const key of Object.getOwnPropertyNames(value)) {
         if (knownkeys.includes(key))
             continue;
-        if ((0, index_2.Check)(unevaluatedProperties, references, value[key])) {
+        if ((0, index_3.Check)(unevaluatedProperties, references, value[key])) {
             composite[key] = Visit(unevaluatedProperties, references, value[key]);
         }
     }
@@ -44,7 +44,7 @@ function TObject(schema, references, value) {
             value[key] = Visit(schema.properties[key], references, value[key]);
             continue;
         }
-        if (IsSchema(additionalProperties) && (0, index_2.Check)(additionalProperties, references, value[key])) {
+        if (IsSchema(additionalProperties) && (0, index_3.Check)(additionalProperties, references, value[key])) {
             value[key] = Visit(additionalProperties, references, value[key]);
             continue;
         }
@@ -64,7 +64,7 @@ function TRecord(schema, references, value) {
             value[key] = Visit(propertySchema, references, value[key]);
             continue;
         }
-        if (IsSchema(additionalProperties) && (0, index_2.Check)(additionalProperties, references, value[key])) {
+        if (IsSchema(additionalProperties) && (0, index_3.Check)(additionalProperties, references, value[key])) {
             value[key] = Visit(additionalProperties, references, value[key]);
             continue;
         }
@@ -73,10 +73,10 @@ function TRecord(schema, references, value) {
     return value;
 }
 function TRef(schema, references, value) {
-    return Visit((0, index_4.Deref)(schema, references), references, value);
+    return Visit((0, index_5.Deref)(schema, references), references, value);
 }
 function TThis(schema, references, value) {
-    return Visit((0, index_4.Deref)(schema, references), references, value);
+    return Visit((0, index_5.Deref)(schema, references), references, value);
 }
 function TTuple(schema, references, value) {
     if (!(0, index_1.IsArray)(value))
@@ -93,7 +93,7 @@ function TTuple(schema, references, value) {
 }
 function TUnion(schema, references, value) {
     for (const inner of schema.anyOf) {
-        if (IsCheckable(inner) && (0, index_2.Check)(inner, value)) {
+        if (IsCheckable(inner) && (0, index_3.Check)(inner, value)) {
             return Visit(inner, references, value);
         }
     }
@@ -102,7 +102,7 @@ function TUnion(schema, references, value) {
 function Visit(schema, references, value) {
     const references_ = (0, index_1.IsString)(schema.$id) ? [...references, schema] : references;
     const schema_ = schema;
-    switch (schema_[index_5.Kind]) {
+    switch (schema_[index_6.Kind]) {
         case 'Array':
             return TArray(schema_, references_, value);
         case 'Intersect':

package/build/require/value/transform/decode.js

@@ -41,10 +41,10 @@ function TArray(schema, references, value) {
 function TIntersect(schema, references, value) {
     if (!(0, index_2.IsPlainObject)(value) || (0, index_2.IsValueType)(value))
         return Default(schema, value);
-    const knownKeys = (0, index_3.KeyOfStringResolve)(schema);
+    const knownKeys = (0, index_3.KeyOfPropertyKeys)(schema);
     const knownProperties = knownKeys.reduce((value, key) => {
         return (key in value)
-            ? { ...value, [key]: Visit((0, index_4.IndexedTypeResolve)(schema, [key]), references, value[key]) }
+            ? { ...value, [key]: Visit((0, index_4.Index)(schema, [key]), references, value[key]) }
             : value;
     }, value);
     if (!(0, type_1.TTransform)(schema.unevaluatedProperties)) {
@@ -65,7 +65,7 @@ function TNot(schema, references, value) {
 function TObject(schema, references, value) {
     if (!(0, index_2.IsPlainObject)(value))
         return Default(schema, value);
-    const knownKeys = (0, index_3.KeyOfStringResolve)(schema);
+    const knownKeys = (0, index_3.KeyOfPropertyKeys)(schema);
     const knownProperties = knownKeys.reduce((value, key) => {
         return (key in value)
             ? { ...value, [key]: Visit(schema.properties[key], references, value[key]) }

package/build/require/value/transform/encode.js

@@ -43,10 +43,10 @@ function TIntersect(schema, references, value) {
     const defaulted = Default(schema, value);
     if (!(0, index_2.IsPlainObject)(value) || (0, index_2.IsValueType)(value))
         return defaulted;
-    const knownKeys = (0, index_3.KeyOfStringResolve)(schema);
+    const knownKeys = (0, index_3.KeyOfPropertyKeys)(schema);
     const knownProperties = knownKeys.reduce((value, key) => {
         return key in defaulted
-            ? { ...value, [key]: Visit((0, index_4.IndexedTypeResolve)(schema, [key]), references, value[key]) }
+            ? { ...value, [key]: Visit((0, index_4.Index)(schema, [key]), references, value[key]) }
             : value;
     }, defaulted);
     if (!(0, type_1.TTransform)(schema.unevaluatedProperties)) {
@@ -67,7 +67,7 @@ function TObject(schema, references, value) {
     const defaulted = Default(schema, value);
     if (!(0, index_2.IsPlainObject)(value))
         return defaulted;
-    const knownKeys = (0, index_3.KeyOfStringResolve)(schema);
+    const knownKeys = (0, index_3.KeyOfPropertyKeys)(schema);
     const knownProperties = knownKeys.reduce((value, key) => {
         return key in value
             ? { ...value, [key]: Visit(schema.properties[key], references, value[key]) }

package/package.json

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

package/readme.md

@@ -67,15 +67,17 @@ License MIT
   - [JavaScript](#types-javascript)
   - [Options](#types-options)
   - [Properties](#types-properties)
+  - [Imports](#types-imports)
   - [Generics](#types-generics)
   - [References](#types-references)
   - [Recursive](#types-recursive)
   - [Conditional](#types-conditional)
+  - [Mapped](#types-mapped)
   - [Template Literal](#types-templateliteral)
   - [Indexed](#types-indexed)
-  - [Rest](#types-rest)
-  - [Transform](#types-transform)
   - [Intrinsic](#types-intrinsic)
+  - [Transform](#types-transform)
+  - [Rest](#types-rest)
   - [Guard](#types-guard)
   - [Unsafe](#types-unsafe)
   - [Strict](#types-strict)
@@ -375,8 +377,8 @@ The following table lists the supported Json types. These types are fully compat
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Extends(        │ type T =                    │ const T = {                    │
 │   Type.String(),               │  string extends number      │   const: false,                │
-│   Type.Number(),               │  true : false               │   type: 'boolean'              │
-│   Type.Literal(true),          │                             │ }                              │
+│   Type.Number(),               │    ? true                   │   type: 'boolean'              │
+│   Type.Literal(true),          │    : false                  │ }                              │
 │   Type.Literal(false)          │                             │                                │
 │ )                              │                             │                                │
 │                                │                             │                                │
@@ -399,6 +401,20 @@ The following table lists the supported Json types. These types are fully compat
 │ )                              │                             │                                │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.Mapped(         │ type T = {                  │ const T = {                    │
+│   Type.Union([                 │   [_ in 'x' | 'y'] : number │   type: 'object',              │
+│     Type.Literal('x'),         │ }                           │   required: ['x', 'y'],        │
+│     Type.Literal('y')          │                             │   properties: {                │
+│   ]),                          │                             │     x: {                       │
+│   () => Type.Number()          │                             │       type: 'number'           │
+│ )                              │                             │     },                         │
+│                                │                             │     y: {                       │
+│                                │                             │       type: 'number'           │
+│                                │                             │     }                          │
+│                                │                             │   }                            │
+│                                │                             │ }                              │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const U = Type.Union([         │ type U = 'open' | 'close'   │ const T = {                    │
 │   Type.Literal('open'),        │                             │   type: 'string',              │
 │   Type.Literal('close')        │ type T = `on${U}`           │   pattern: '^on(open|close)$'  │
@@ -700,6 +716,32 @@ 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
@@ -848,7 +890,7 @@ function test(node: Node) {
 
 ### Conditional Types
 
-TypeBox supports runtime conditional types with Extends. This type performs a structural assignability check for the first two arguments and will infer one of the second two arguments based on the result. The Extends type is designed to match the assignability rules of TypeScript conditional types. The conditional derived types Exclude and Extract are also supported.
+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.
 
 ```typescript
 // Extends
@@ -889,11 +931,37 @@ const T = Type.Exclude(                              // const T: TUnion<[
 )
 ```
 
+<a name='types-mapped'></a>
+
+### 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`.
+
+```typescript
+const T = Type.Object({                              // const T: TObject<{
+  x: Type.Number(),                                  //   x: TNumber,
+  y: Type.String(),                                  //   y: TString,
+  z: Type.Boolean()                                  //   z: TBoolean
+})                                                   // }>
+
+const M = Type.Mapped(Type.KeyOf(T), K => {          // type M = {
+  return Type.Union([                                //   [K in keyof T]: T[K] | null
+    Type.Index(T, K),                                // }
+    Type.Null()                                      //
+  ])                                                 // ... runtime mapped as
+})                                                   //
+                                                     // const M: TObject<{
+                                                     //   x: TUnion<[TNumber, TNull]>,
+                                                     //   y: TUnion<[TString, TNull]>,
+                                                     //   z: TUnion<[TBoolean, TNull]>
+                                                     // }>
+```
+
 <a name='types-templateliteral'></a>
 
 ### Template Literal Types
 
-TypeBox supports template literal types with 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 enable the template be checked via Json Schema. It 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 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.
 
 ```typescript
 // TypeScript
@@ -928,7 +996,7 @@ const R = Type.Record(K, Type.String())              // const R: TObject<{
 
 ### Indexed Access Types
 
-TypeBox supports Indexed Access Types with 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<{
@@ -951,23 +1019,35 @@ const C = Type.Index(T, Type.KeyOf(T))               // const C: TUnion<[
                                                      // ]>
 ```
 
-<a name='types-rest'></a>
+<a name='types-intrinsic'></a>
 
-### Rest Types
+### Intrinsic Types
 
-TypeBox provides the Rest type to uniformly extract variadic tuples from Intersect, Union and Tuple types. This type can be useful to remap variadic types into different forms. The following uses Rest to remap a Tuple into a Union.
+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.
 
 ```typescript
-const T = Type.Tuple([                               // const T: TTuple<[
-  Type.String(),                                     //   TString,
-  Type.Number()                                      //   TNumber
-])                                                   // ]>
+// TypeScript
 
-const R = Type.Rest(T)                               // const R: [TString, TNumber]
+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'
 
-const U = Type.Union(R)                              // const T: TUnion<[
-                                                     //   TString,
-                                                     //   TNumber
+// TypeBox
+
+const A = Type.Capitalize(Type.Literal('hello'))     // const A: TLiteral<'Hello'>
+
+const B = Type.Capitalize(Type.Union([               // const B: TUnion<[
+  Type.Literal('hello'),                             //   TLiteral<'Hello'>,
+  Type.Literal('world')                              //   TLiteral<'World'>
+]))                                                  // ]>
+
+const C = Type.Capitalize(                           // const C: TTemplateLiteral<[
+  Type.TemplateLiteral('hello${1|2|3}')              //   TLiteral<'Hello'>,
+)                                                    //   TUnion<[
+                                                     //     TLiteral<'1'>,
+                                                     //     TLiteral<'2'>,
+                                                     //     TLiteral<'3'>
+                                                     //   ]>
                                                      // ]>
 ```
 
@@ -1000,35 +1080,23 @@ type E = StaticEncode<typeof T>                      // type E = Array<number>
 type T = Static<typeof T>                            // type T = Array<number>
 ```
 
-<a name='types-intrinsic'></a>
+<a name='types-rest'></a>
 
-### Intrinsic Types
+### Rest Types
 
-TypeBox supports the TypeScript Intrinsic String Manipulation types Uppercase, Lowercase, Capitalize and Uncapitalize. These types can be used to remap String Literal, TemplateLiteral and Union types.
+TypeBox provides the Rest type to uniformly extract variadic tuples from Intersect, Union and Tuple types. This type can be useful to remap variadic types into different forms. The following uses Rest to remap a Tuple into a Union.
 
 ```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 T = Type.Tuple([                               // const T: TTuple<[
+  Type.String(),                                     //   TString,
+  Type.Number()                                      //   TNumber
+])                                                   // ]>
 
-const B = Type.Capitalize(Type.Union([               // const B: TUnion<[
-  Type.Literal('hello'),                             //   TLiteral<'Hello'>,
-  Type.Literal('world')                              //   TLiteral<'World'>
-]))                                                  // ]>
+const R = Type.Rest(T)                               // const R: [TString, TNumber]
 
-const C = Type.Capitalize(                           // const C: TTemplateLiteral<[
-  Type.TemplateLiteral('hello${1|2|3}')              //   TLiteral<'Hello'>,
-)                                                    //   TUnion<[
-                                                     //     TLiteral<'1'>,
-                                                     //     TLiteral<'2'>,
-                                                     //     TLiteral<'3'>
-                                                     //   ]>
+const U = Type.Union(R)                              // const T: TUnion<[
+                                                     //   TString,
+                                                     //   TNumber
                                                      // ]>
 ```
 
@@ -1751,12 +1819,12 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │       (index)        │  Compiled  │  Minified  │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '109.3 kb' │ ' 48.5 kb' │  '2.25 x'   │
-│ typebox/errors       │ ' 54.8 kb' │ ' 24.9 kb' │  '2.20 x'   │
-│ typebox/system       │ ' 12.1 kb' │ '  6.1 kb' │  '1.98 x'   │
-│ typebox/type         │ ' 77.8 kb' │ ' 32.8 kb' │  '2.37 x'   │
-│ typebox/value        │ '143.7 kb' │ ' 61.2 kb' │  '2.35 x'   │
-│ typebox              │ ' 77.9 kb' │ ' 32.8 kb' │  '2.37 x'   │
+│ typebox/compiler     │ '109.2 kb' │ ' 48.6 kb' │  '2.25 x'   │
+│ typebox/errors       │ ' 55.0 kb' │ ' 25.1 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'   │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```
 

package/build/import/type/keyof/keyof-type.d.mts

@@ -1,11 +0,0 @@
-import type { TSchema } from '../schema/index.mjs';
-import type { Ensure } from '../helpers/index.mjs';
-import { type TLiteral, TLiteralValue } from '../literal/index.mjs';
-import { type TNumber } from '../number/index.mjs';
-import { KeyOfStringResolve } from './keyof-string.mjs';
-import { UnionResolve } from '../union/index.mjs';
-type FromLiterals<T extends TLiteralValue[]> = (T extends [infer L extends TLiteralValue, ...infer R extends TLiteralValue[]] ? L extends '[number]' ? [TNumber, ...FromLiterals<R>] : [TLiteral<L>, ...FromLiterals<R>] : []);
-declare function FromLiterals<T extends TLiteralValue[]>(T: [...T]): FromLiterals<T>;
-export type KeyOfTypeResolve<T extends TSchema> = (Ensure<UnionResolve<FromLiterals<KeyOfStringResolve<T>>>>);
-export declare function KeyOfTypeResolve<T extends TSchema>(T: T): KeyOfTypeResolve<T>;
-export {};

package/build/import/type/keyof/keyof-type.mjs

@@ -1,15 +0,0 @@
-import { Literal } from '../literal/index.mjs';
-import { Number } from '../number/index.mjs';
-import { KeyOfStringResolve } from './keyof-string.mjs';
-import { UnionResolve } from '../union/index.mjs';
-function FromLiterals(T) {
-    const [L, ...R] = T;
-    return (T.length > 0
-        ? L === '[number]'
-            ? [Number(), ...FromLiterals(R)]
-            : [Literal(L), ...FromLiterals(R)]
-        : []);
-}
-export function KeyOfTypeResolve(T) {
-    return (UnionResolve(FromLiterals(KeyOfStringResolve(T))));
-}

package/build/require/type/keyof/keyof-type.d.ts

@@ -1,11 +0,0 @@
-import type { TSchema } from '../schema/index';
-import type { Ensure } from '../helpers/index';
-import { type TLiteral, TLiteralValue } from '../literal/index';
-import { type TNumber } from '../number/index';
-import { KeyOfStringResolve } from './keyof-string';
-import { UnionResolve } from '../union/index';
-type FromLiterals<T extends TLiteralValue[]> = (T extends [infer L extends TLiteralValue, ...infer R extends TLiteralValue[]] ? L extends '[number]' ? [TNumber, ...FromLiterals<R>] : [TLiteral<L>, ...FromLiterals<R>] : []);
-declare function FromLiterals<T extends TLiteralValue[]>(T: [...T]): FromLiterals<T>;
-export type KeyOfTypeResolve<T extends TSchema> = (Ensure<UnionResolve<FromLiterals<KeyOfStringResolve<T>>>>);
-export declare function KeyOfTypeResolve<T extends TSchema>(T: T): KeyOfTypeResolve<T>;
-export {};