@sinclair/typebox 0.34.22 → 0.34.24

package/readme.md

@@ -64,7 +64,6 @@ License MIT
 - [Types](#types)
   - [Json](#types-json)
   - [JavaScript](#types-javascript)
-  - [Import](#types-import)
   - [Options](#types-options)
   - [Properties](#types-properties)
   - [Generics](#types-generics)
@@ -97,16 +96,18 @@ License MIT
   - [Mutate](#values-mutate)
   - [Pointer](#values-pointer)
 - [Syntax](#syntax)
-  - [Type](#syntax-type)
-  - [Options](#syntax-options)
+  - [Create](#syntax-create)
   - [Parameters](#syntax-parameters)
   - [Generics](#syntax-generics)
+  - [Options](#syntax-options)
 - [TypeRegistry](#typeregistry)
   - [Type](#typeregistry-type)
   - [Format](#typeregistry-format)
 - [TypeCheck](#typecheck)
   - [Ajv](#typecheck-ajv)
   - [TypeCompiler](#typecheck-typecompiler)
+- [TypeMap](#typemap)
+  - [Usage](#typemap-usage)
 - [TypeSystem](#typesystem)
   - [Policies](#typesystem-policies)
 - [Error Function](#error-function)
@@ -638,22 +639,6 @@ TypeBox provides an extended type set that can be used to create schematics for
 └────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
 ```
 
-<a name='types-import'></a>
-
-### Import
-
-Import the Type namespace to bring in the full TypeBox type system. This is recommended for most users.
-
-```typescript
-import { Type, type Static } from '@sinclair/typebox'
-```
-
-You can also selectively import types. This enables modern bundlers to tree shake for unused types.
-
-```typescript
-import { Object, Number, String, Boolean, type Static } from '@sinclair/typebox'
-```
-
 <a name='types-options'></a>
 
 ### Options
@@ -741,22 +726,6 @@ const Nullable = <T extends TSchema>(T: T) => {     // type Nullable<T> = T | nu
 const T = Nullable(Type.String())                  // type T = Nullable<string>
 ```
 
-Generic types can also be created with Argument types
-
-```typescript
-const Vector = Type.Object({                        // type Vector<A_0, A_1, A_2> = {
-  x: Type.Argument(0),                              //   x: A_0,
-  y: Type.Argument(1),                              //   y: A_1,
-  z: Type.Argument(2),                              //   z: A_2
-})                                                  // }
-
-const T = Type.Instantiate(Vector, [                // type T = Vector<
-  Type.Boolean(),                                   //   boolean, 
-  Type.Number(),                                    //   number,
-  Type.String()                                     //   string
-])                                                  // >
-```
-
 <a name='types-recursive'></a>
 
 ### Recursive Types
@@ -1337,79 +1306,89 @@ ValuePointer.Set(A, '/z', 1)                         // A' = { x: 1, y: 1, z: 1
 
 ## Syntax Types
 
-TypeBox provides optional support for runtime and type level parsing from TypeScript syntax.
+TypeBox includes support for parsing TypeScript annotation syntax into TypeBox schematics.
+
+This feature is provided via optional import.
 
 ```typescript
 import { Syntax } from '@sinclair/typebox/syntax'
 ```
 
-<a name='syntax-type'></a>
+<a name='syntax-create'></a>
 
-### Type
+### Create
 
-Use the Syntax function to create TypeBox type from TypeScript syntax.
+Use the Syntax function to create TypeBox types from TypeScript syntax ([Example](https://www.typescriptlang.org/play/?moduleResolution=99&module=199&ts=5.8.0-beta#code/JYWwDg9gTgLgBAbzgZQJ4DsYEMAecC+cAZlBCHAOQACAzsOgMYA2WwUA9DKmAKYBGEHOxoZsOCgChQkWIhTYYwBgWKly1OoxZtO3foMkSGEdDXgAVOAF4Uo3AAoABkhwAuOOgCuIPjygAaOFR3Lx8-AkcASjgY2Jj2djhjUwt3cwB5PgArHgYYAB4ECTiS0rLyisrYhNi3OHMAOW9fAOKq9o7OuBqY4PqmsKg2rpHR+MT8AD4JCS5eeut5LEUGfLmeCCJ6ybHKmvWFmyLdk86euDrQlv9h07uy876rv1v7t-GCIA))
 
 ```typescript
 const T = Syntax(`{ x: number, y: number }`)        // const T: TObject<{
-                                                    //   x: TNumber
+                                                    //   x: TNumber,
                                                     //   y: TNumber
                                                     // }>
-```
-
-<a name='syntax-options'></a>
-
-### Options
-
-Options can be passed to types on the last parameter
 
-```typescript
-const T = Syntax(`number`, {                      // const T = {
-  minimum: 0,                                     //   type: 'number',
-  maximum: 10                                     //   minimum: 0,
-})                                                //   maximum: 10
-                                                  // }
+type T = Static<typeof T>                            // type T = {
+                                                     //   x: number,
+                                                     //   y: number
+                                                     // }
 ```
 
 <a name="syntax-parameters"></a>
 
 ### Parameters
 
-Syntax types can be parameterized to accept exterior types.
+Syntax types can be parameterized to receive exterior types ([Example](https://www.typescriptlang.org/play/?moduleResolution=99&module=199&ts=5.8.0-beta#code/JYWwDg9gTgLgBAbzgZQJ4DsYEMAecC+cAZlBCHAOQACAzsOgMYA2WwUA9DKmAKYBGEHOxoZsOCgCgJDCOhrwAKnAC8KUbgAUAAyQ4AXHHQBXEHx5QANHFQHjp8wS0BKOK7ev27ODLmKDCgHk+ACseBhgAHgQJd1i4+ITEpLdPN304BQA5EzNLGOSCwqK4VNcbDOz7KHzi2rqPL3wAPikfeRQVNUxNJCV8Ky0ABSxYYCwmCIUm52LUtvhkfyDQ8Kia+o2C0rh0wLAYYFlxycrcpot1zav47fK9g6OJrJzzFuv3m8amoA))
 
 ```typescript
-const T = Syntax('number')
-
-const S = Syntax({ T }, `{ x: T, y: T, z: T }`)     // const S: TObject<{
+const T = Syntax(`{ x: number, y: number }`)        // const T: TObject<{
                                                     //   x: TNumber,
-                                                    //   y: TNumber,
-                                                    //   z: TNumber
+                                                    //   y: TNumber
+                                                    // }>
+
+const S = Syntax({ T }, `Partial<T>`)               // const S: TObject<{
+                                                    //   x: TOptional<TNumber>,
+                                                    //   y: TOptional<TNumber>
                                                     // }>
 ```
 
+
+
 <a name="syntax-generics"></a>
 
 ### Generics
 
-Generic types can be created using Argument types.
+Syntax types support generic parameters in the following way ([Example](https://www.typescriptlang.org/play/?moduleResolution=99&module=199&ts=5.8.0-beta#code/JYWwDg9gTgLgBAbzgZQJ4DsYEMAecC+cAZlBCHAOQACAzsOgMYA2WwUA9DKmAKYBGEHOxoZsOCgChQkWIhTYYwBgWKly1OoxZtO3foMkSGEdDXgA1HgxjQ4AXhSjcACgAGAHgAaAGjgBNXwAtAD45CTg4HAAuOB84cLhUGID4iIAvGMD4-FcASgkjEzM4ACEsOhpLa2gae0dMFyQqmygCX1cEBOi4Zuh3AEZfAAZh4O8EpJ6rFvcRuEG4IbGEjKnqqFnh337lnPyJLl5S8uBK6Zq65AUld0OeCCJjit6oGlCIiPZ2ODun05fag5Oh8QaCweCIZCoV8Pt0kN0FpM5qshm0ElCMZisSCYRFJvCYnNJgsUWjseSKeDcXBVgTFr4kb5Vv0COjKezsTD8EA))
 
 ```typescript
-const Vector = Syntax(`{
-  x: Argument<0>,
-  y: Argument<1>,
-  z: Argument<2>
+const Vector = Syntax(`<X, Y, Z> { 
+  x: X, 
+  y: Y, 
+  z: Z 
 }`)
 
-const Basis = Syntax({ Vector }, `{
+const BasisVectors = Syntax({ Vector }, `{
   x: Vector<1, 0, 0>,
   y: Vector<0, 1, 0>,
   z: Vector<0, 0, 1>,
 }`)
 
-type Basis = Static<typeof Basis>                   // type Basis = {
+type BasisVectors = Static<typeof BasisVectors>     // type BasisVectors = {
                                                     //   x: { x: 1, y: 0, z: 0 },
                                                     //   y: { x: 0, y: 1, z: 0 },
                                                     //   z: { x: 0, y: 0, z: 1 }
-                                                    // } 
+                                                    // }
+```
+
+<a name='syntax-options'></a>
+
+### Options
+
+Options can be passed via the last parameter
+
+```typescript
+const T = Syntax(`number`, { minimum: 42 })       // const T = {
+                                                  //   type: 'number',
+                                                  //   minimum: 42
+                                                  // }
 ```
 
 <a name='typeregistry'></a>
@@ -1573,6 +1552,44 @@ const C = TypeCompiler.Code(Type.String())           // const C = `return functi
                                                      // }`
 ```
 
+<a name='typemap'></a>
+
+## TypeMap
+
+TypeBox offers an external package for bi-directional mapping between TypeBox, Valibot, and Zod type libraries. It also includes syntax parsing support for Valibot and Zod and supports the Standard Schema specification. For more details on TypeMap, refer to the project repository.
+
+[TypeMap Repository](https://github.com/sinclairzx81/typemap)
+
+<a name='typemap-usage'></a>
+
+### Usage
+
+TypeMap needs to be installed seperately
+
+```bash
+$ npm install @sinclair/typemap
+```
+
+Once installed it offers advanced structural remapping between various runtime type libraries ([Example](https://www.typescriptlang.org/play/?moduleResolution=99&module=199&ts=5.8.0-beta#code/JYWwDg9gTgLgBAbzgFQJ5gKYCEIA8A0cAyqgHYwCGBcAWhACZwC+cAZlBCHAOQACAzsFIBjADYVgUAPQx0GEBTDcAUMuERS-eMjgBeFHJy4AFAAMkuAFxxSAVxAAjDFEKprdx88IAvd-adQzKYAlHBwUlJw6pra1sgA8g4AVhjCMAA8CMphObl5+QWFRcW5ETlWKABy-s4A3NkljU3NBWVhblU1UPUtvX3FbXC+nZ7dDf0TE2VMAHyq0VrEesRklCbIoS1lC-BE1twWfqOuRwE+p87MKmoaiwBKy3T0xkTBAHRgFFD8GMZ2oqJNnltrd4HdrFlJltImEKh4Aj0oU1Bh14XVxkiBjChhcxpjGtMwkA))
+
+```typescript
+import { TypeBox, Syntax, Zod } from '@sinclair/typemap'
+
+const T = TypeBox(`{ x: number, y: number, z: number }`)  // const T: TObject<{
+                                                          //   x: TNumber;
+                                                          //   y: TNumber;
+                                                          //   z: TNumber;
+                                                          // }>
+
+const S = Syntax(T)                // const S: '{ x: number, y: number, z: number }'
+
+const R = Zod(S).parse(null)       // const R: {
+                                   //   x: number;
+                                   //   y: number;
+                                   //   z: number;
+                                   // }                    
+```
+
 <a name='typesystem'></a>
 
 ## TypeSystem

package/build/cjs/type/remap/index.d.ts

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

package/build/cjs/type/remap/index.js

@@ -1,18 +0,0 @@
-"use strict";
-
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./remap"), exports);

package/build/cjs/type/remap/remap.d.ts

@@ -1,30 +0,0 @@
-import { TSchema } from '../schema/index';
-import { TObject, TProperties } from '../object/index';
-import { TConstructor } from '../constructor/index';
-import { TFunction } from '../function/index';
-import { TIntersect } from '../intersect/index';
-import { TUnion } from '../union/index';
-import { TTuple } from '../tuple/index';
-import { TArray } from '../array/index';
-import { TAsyncIterator } from '../async-iterator/index';
-import { TIterator } from '../iterator/index';
-import { TPromise } from '../promise/index';
-import { TRecord, TRecordOrObject } from '../record/index';
-export type TCallback = (schema: TSchema) => TSchema;
-export interface TMapping {
-    input: unknown;
-    output: unknown;
-}
-type TApply<Type extends TSchema, Mapping extends TMapping, Mapped = (Mapping & {
-    input: Type;
-})['output'], Result = Mapped extends TSchema ? Mapped : never> = Result;
-type TFromProperties<Properties extends TProperties, Mapping extends TMapping, Result extends TProperties = {
-    [Key in keyof Properties]: TRemap<Properties[Key], Mapping>;
-}> = Result;
-type TFromTypes<Types extends TSchema[], Mapping extends TMapping, Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromTypes<Right, Mapping, [...Result, TRemap<Left, Mapping>]> : Result);
-type TFromType<Type extends TSchema, Mapping extends TMapping, Result extends TSchema = (TApply<Type, Mapping>)> = Result;
-/** `[Internal]` Applies a recursive conditional remapping of a type and its sub type constituents */
-export type TRemap<Type extends TSchema, Mapping extends TMapping, Mapped extends TSchema = TFromType<Type, Mapping>, Result extends TSchema = (Mapped extends TConstructor<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TConstructor<TFromTypes<Parameters, Mapping>, TFromType<ReturnType, Mapping>> : Mapped extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFunction<TFromTypes<Parameters, Mapping>, TFromType<ReturnType, Mapping>> : Mapped extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromTypes<Types, Mapping>> : Mapped extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromTypes<Types, Mapping>> : Mapped extends TTuple<infer Types extends TSchema[]> ? TTuple<TFromTypes<Types, Mapping>> : Mapped extends TArray<infer Type extends TSchema> ? TArray<TFromType<Type, Mapping>> : Mapped extends TAsyncIterator<infer Type extends TSchema> ? TAsyncIterator<TFromType<Type, Mapping>> : Mapped extends TIterator<infer Type extends TSchema> ? TIterator<TFromType<Type, Mapping>> : Mapped extends TPromise<infer Type extends TSchema> ? TPromise<TFromType<Type, Mapping>> : Mapped extends TObject<infer Properties extends TProperties> ? TObject<TFromProperties<Properties, Mapping>> : Mapped extends TRecord<infer Key extends TSchema, infer Value extends TSchema> ? TRecordOrObject<TFromType<Key, Mapping>, TFromType<Value, Mapping>> : Mapped)> = Result;
-/** `[Internal]` Applies a recursive conditional remapping of a type and its sub type constituents */
-export declare function Remap(type: TSchema, callback: TCallback): TSchema;
-export {};

package/build/cjs/type/remap/remap.js

@@ -1,47 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Remap = Remap;
-const index_1 = require("../object/index");
-const index_2 = require("../constructor/index");
-const index_3 = require("../function/index");
-const index_4 = require("../intersect/index");
-const index_5 = require("../union/index");
-const index_6 = require("../tuple/index");
-const index_7 = require("../array/index");
-const index_8 = require("../async-iterator/index");
-const index_9 = require("../iterator/index");
-const index_10 = require("../promise/index");
-const index_11 = require("../record/index");
-const KindGuard = require("../guard/kind");
-const type_1 = require("../clone/type");
-function FromProperties(properties, func) {
-    return globalThis.Object.getOwnPropertyNames(properties).reduce((result, key) => {
-        return { ...result, [key]: Remap(properties[key], func) };
-    }, {});
-}
-function FromTypes(types, callback) {
-    return types.map((type) => Remap(type, callback));
-}
-function FromType(type, callback) {
-    return callback(type);
-}
-/** `[Internal]` Applies a recursive conditional remapping of a type and its sub type constituents */
-// prettier-ignore
-function Remap(type, callback) {
-    // Map incoming type
-    const mapped = (0, type_1.CloneType)(FromType(type, callback));
-    // Return remapped interior
-    return (KindGuard.IsConstructor(type) ? (0, index_2.Constructor)(FromTypes(type.parameters, callback), FromType(type.returns, callback), mapped) :
-        KindGuard.IsFunction(type) ? (0, index_3.Function)(FromTypes(type.parameters, callback), FromType(type.returns, callback), mapped) :
-            KindGuard.IsIntersect(type) ? (0, index_4.Intersect)(FromTypes(type.allOf, callback), mapped) :
-                KindGuard.IsUnion(type) ? (0, index_5.Union)(FromTypes(type.anyOf, callback), mapped) :
-                    KindGuard.IsTuple(type) ? (0, index_6.Tuple)(FromTypes(type.items || [], callback), mapped) :
-                        KindGuard.IsArray(type) ? (0, index_7.Array)(FromType(type.items, callback), mapped) :
-                            KindGuard.IsAsyncIterator(type) ? (0, index_8.AsyncIterator)(FromType(type.items, callback), mapped) :
-                                KindGuard.IsIterator(type) ? (0, index_9.Iterator)(FromType(type.items, callback), mapped) :
-                                    KindGuard.IsPromise(type) ? (0, index_10.Promise)(FromType(type.items, callback), mapped) :
-                                        KindGuard.IsObject(type) ? (0, index_1.Object)(FromProperties(type.properties, callback), mapped) :
-                                            KindGuard.IsRecord(type) ? (0, index_11.Record)(FromType((0, index_11.RecordKey)(type), callback), FromType((0, index_11.RecordValue)(type), callback), mapped) :
-                                                (0, type_1.CloneType)(mapped));
-}

package/build/esm/type/remap/index.d.mts

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

package/build/esm/type/remap/index.mjs

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

package/build/esm/type/remap/remap.d.mts

@@ -1,30 +0,0 @@
-import { TSchema } from '../schema/index.mjs';
-import { TObject, TProperties } from '../object/index.mjs';
-import { TConstructor } from '../constructor/index.mjs';
-import { TFunction } from '../function/index.mjs';
-import { TIntersect } from '../intersect/index.mjs';
-import { TUnion } from '../union/index.mjs';
-import { TTuple } from '../tuple/index.mjs';
-import { TArray } from '../array/index.mjs';
-import { TAsyncIterator } from '../async-iterator/index.mjs';
-import { TIterator } from '../iterator/index.mjs';
-import { TPromise } from '../promise/index.mjs';
-import { TRecord, TRecordOrObject } from '../record/index.mjs';
-export type TCallback = (schema: TSchema) => TSchema;
-export interface TMapping {
-    input: unknown;
-    output: unknown;
-}
-type TApply<Type extends TSchema, Mapping extends TMapping, Mapped = (Mapping & {
-    input: Type;
-})['output'], Result = Mapped extends TSchema ? Mapped : never> = Result;
-type TFromProperties<Properties extends TProperties, Mapping extends TMapping, Result extends TProperties = {
-    [Key in keyof Properties]: TRemap<Properties[Key], Mapping>;
-}> = Result;
-type TFromTypes<Types extends TSchema[], Mapping extends TMapping, Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromTypes<Right, Mapping, [...Result, TRemap<Left, Mapping>]> : Result);
-type TFromType<Type extends TSchema, Mapping extends TMapping, Result extends TSchema = (TApply<Type, Mapping>)> = Result;
-/** `[Internal]` Applies a recursive conditional remapping of a type and its sub type constituents */
-export type TRemap<Type extends TSchema, Mapping extends TMapping, Mapped extends TSchema = TFromType<Type, Mapping>, Result extends TSchema = (Mapped extends TConstructor<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TConstructor<TFromTypes<Parameters, Mapping>, TFromType<ReturnType, Mapping>> : Mapped extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFunction<TFromTypes<Parameters, Mapping>, TFromType<ReturnType, Mapping>> : Mapped extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromTypes<Types, Mapping>> : Mapped extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromTypes<Types, Mapping>> : Mapped extends TTuple<infer Types extends TSchema[]> ? TTuple<TFromTypes<Types, Mapping>> : Mapped extends TArray<infer Type extends TSchema> ? TArray<TFromType<Type, Mapping>> : Mapped extends TAsyncIterator<infer Type extends TSchema> ? TAsyncIterator<TFromType<Type, Mapping>> : Mapped extends TIterator<infer Type extends TSchema> ? TIterator<TFromType<Type, Mapping>> : Mapped extends TPromise<infer Type extends TSchema> ? TPromise<TFromType<Type, Mapping>> : Mapped extends TObject<infer Properties extends TProperties> ? TObject<TFromProperties<Properties, Mapping>> : Mapped extends TRecord<infer Key extends TSchema, infer Value extends TSchema> ? TRecordOrObject<TFromType<Key, Mapping>, TFromType<Value, Mapping>> : Mapped)> = Result;
-/** `[Internal]` Applies a recursive conditional remapping of a type and its sub type constituents */
-export declare function Remap(type: TSchema, callback: TCallback): TSchema;
-export {};

package/build/esm/type/remap/remap.mjs

@@ -1,43 +0,0 @@
-import { Object } from '../object/index.mjs';
-import { Constructor } from '../constructor/index.mjs';
-import { Function } from '../function/index.mjs';
-import { Intersect } from '../intersect/index.mjs';
-import { Union } from '../union/index.mjs';
-import { Tuple } from '../tuple/index.mjs';
-import { Array } from '../array/index.mjs';
-import { AsyncIterator } from '../async-iterator/index.mjs';
-import { Iterator } from '../iterator/index.mjs';
-import { Promise } from '../promise/index.mjs';
-import { Record, RecordKey, RecordValue } from '../record/index.mjs';
-import * as KindGuard from '../guard/kind.mjs';
-import { CloneType } from '../clone/type.mjs';
-function FromProperties(properties, func) {
-    return globalThis.Object.getOwnPropertyNames(properties).reduce((result, key) => {
-        return { ...result, [key]: Remap(properties[key], func) };
-    }, {});
-}
-function FromTypes(types, callback) {
-    return types.map((type) => Remap(type, callback));
-}
-function FromType(type, callback) {
-    return callback(type);
-}
-/** `[Internal]` Applies a recursive conditional remapping of a type and its sub type constituents */
-// prettier-ignore
-export function Remap(type, callback) {
-    // Map incoming type
-    const mapped = CloneType(FromType(type, callback));
-    // Return remapped interior
-    return (KindGuard.IsConstructor(type) ? Constructor(FromTypes(type.parameters, callback), FromType(type.returns, callback), mapped) :
-        KindGuard.IsFunction(type) ? Function(FromTypes(type.parameters, callback), FromType(type.returns, callback), mapped) :
-            KindGuard.IsIntersect(type) ? Intersect(FromTypes(type.allOf, callback), mapped) :
-                KindGuard.IsUnion(type) ? Union(FromTypes(type.anyOf, callback), mapped) :
-                    KindGuard.IsTuple(type) ? Tuple(FromTypes(type.items || [], callback), mapped) :
-                        KindGuard.IsArray(type) ? Array(FromType(type.items, callback), mapped) :
-                            KindGuard.IsAsyncIterator(type) ? AsyncIterator(FromType(type.items, callback), mapped) :
-                                KindGuard.IsIterator(type) ? Iterator(FromType(type.items, callback), mapped) :
-                                    KindGuard.IsPromise(type) ? Promise(FromType(type.items, callback), mapped) :
-                                        KindGuard.IsObject(type) ? Object(FromProperties(type.properties, callback), mapped) :
-                                            KindGuard.IsRecord(type) ? Record(FromType(RecordKey(type), callback), FromType(RecordValue(type), callback), mapped) :
-                                                CloneType(mapped));
-}