@sinclair/typebox 0.34.22 → 0.34.24

package/build/cjs/index.d.ts

@@ -52,7 +52,6 @@ export * from './type/record/index';
 export * from './type/recursive/index';
 export * from './type/ref/index';
 export * from './type/regexp/index';
-export * from './type/remap/index';
 export * from './type/required/index';
 export * from './type/rest/index';
 export * from './type/return-type/index';

package/build/cjs/index.js

@@ -75,7 +75,6 @@ __exportStar(require("./type/record/index"), exports);
 __exportStar(require("./type/recursive/index"), exports);
 __exportStar(require("./type/ref/index"), exports);
 __exportStar(require("./type/regexp/index"), exports);
-__exportStar(require("./type/remap/index"), exports);
 __exportStar(require("./type/required/index"), exports);
 __exportStar(require("./type/rest/index"), exports);
 __exportStar(require("./type/return-type/index"), exports);

package/build/cjs/syntax/runtime.d.ts

@@ -1,6 +1,8 @@
 import { Runtime } from '../parser/index';
 import * as t from '../type/index';
 export declare const Module: Runtime.Module<{
+    GenericArgumentList: Runtime.IUnion<unknown[]>;
+    GenericArguments: Runtime.ITuple<{}>;
     Literal: Runtime.IUnion<t.TLiteral<string> | t.TLiteral<number> | t.TLiteral<boolean>>;
     Keyword: Runtime.IUnion<t.TAny | t.TBoolean | t.TBigInt | t.TNever | t.TString | t.TNumber | t.TInteger | t.TNull | t.TSymbol | t.TUndefined | t.TUnknown | t.TVoid>;
     KeyOf: Runtime.IUnion<boolean>;

package/build/cjs/syntax/runtime.js

@@ -40,13 +40,58 @@ const Dereference = (context, key) => {
     return key in context ? context[key] : t.Ref(key);
 };
 // ------------------------------------------------------------------
+// GenericArgumentList
+// ------------------------------------------------------------------
+// prettier-ignore
+const GenericArgumentListMapping = (results) => {
+    return (results.length === 3 ? [results[0], ...results[2]] :
+        results.length === 2 ? [results[0]] :
+            results.length === 1 ? [results[0]] :
+                []);
+};
+// prettier-ignore
+const GenericArgumentList = index_1.Runtime.Union([
+    index_1.Runtime.Tuple([index_1.Runtime.Ident(), index_1.Runtime.Const(Comma), index_1.Runtime.Ref('GenericArgumentList')]),
+    index_1.Runtime.Tuple([index_1.Runtime.Ident(), index_1.Runtime.Const(Comma)]),
+    index_1.Runtime.Tuple([index_1.Runtime.Ident()]),
+    index_1.Runtime.Tuple([]),
+], (results) => GenericArgumentListMapping(results));
+// ------------------------------------------------------------------
+// GenericArguments
+// ------------------------------------------------------------------
+// prettier-ignore
+const GenericArgumentsContext = (args) => {
+    return args.reduce((result, arg, index) => {
+        return { ...result, [arg]: t.Argument(index) };
+    }, {});
+};
+// prettier-ignore
+const GenericArgumentsMapping = (results) => {
+    return results.length === 3
+        ? GenericArgumentsContext(results[1])
+        : {};
+};
+// prettier-ignore
+const GenericArguments = index_1.Runtime.Tuple([
+    index_1.Runtime.Const(LAngle),
+    index_1.Runtime.Ref('GenericArgumentList'),
+    index_1.Runtime.Const(RAngle),
+], results => GenericArgumentsMapping(results));
+// ------------------------------------------------------------------
 // GenericReference
 // ------------------------------------------------------------------
 function GenericReferenceMapping(results, context) {
-    const target = Dereference(context, results[0]);
-    return t.Instantiate(target, results[2]);
+    const type = Dereference(context, results[0]);
+    const args = results[2];
+    return t.Instantiate(type, args);
 }
-const GenericReference = index_1.Runtime.Tuple([index_1.Runtime.Ident(), index_1.Runtime.Const(LAngle), index_1.Runtime.Ref('Elements'), index_1.Runtime.Const(RAngle)], (results, context) => GenericReferenceMapping(results, context));
+// prettier-ignore
+const GenericReference = index_1.Runtime.Tuple([
+    index_1.Runtime.Ident(),
+    index_1.Runtime.Const(LAngle),
+    index_1.Runtime.Ref('Elements'),
+    index_1.Runtime.Const(RAngle)
+], (results, context) => GenericReferenceMapping(results, context));
 // ------------------------------------------------------------------
 // Reference
 // ------------------------------------------------------------------
@@ -607,6 +652,11 @@ const Uint8Array = index_1.Runtime.Const('Uint8Array', index_1.Runtime.As(t.Uint
 // ------------------------------------------------------------------
 // prettier-ignore
 exports.Module = new index_1.Runtime.Module({
+    // ----------------------------------------------------------------
+    // Generic Arguments
+    // ----------------------------------------------------------------
+    GenericArgumentList,
+    GenericArguments,
     // ----------------------------------------------------------------
     // Type Expressions
     // ----------------------------------------------------------------

package/build/cjs/syntax/static.d.ts

@@ -42,8 +42,29 @@ type Delimit<Parser extends Static.IParser, Delimiter extends Static.IParser> =
     Static.Tuple<[]>
 ], DelimitMapping>);
 type Dereference<Context extends t.TProperties, Ref extends string> = (Ref extends keyof Context ? Context[Ref] : t.TRef<Ref>);
+interface GenericArgumentListMapping extends Static.IMapping {
+    output: (this['input'] extends [infer Ident extends string, Comma, infer Rest extends unknown[]] ? [Ident, ...Rest] : this['input'] extends [infer Ident extends string, Comma] ? [Ident] : this['input'] extends [infer Ident extends string] ? [Ident] : [
+    ]);
+}
+type GenericArgumentList = Static.Union<[
+    Static.Tuple<[Static.Ident, Static.Const<Comma>, GenericArgumentList]>,
+    Static.Tuple<[Static.Ident, Static.Const<Comma>]>,
+    Static.Tuple<[Static.Ident]>,
+    Static.Tuple<[]>
+], GenericArgumentListMapping>;
+type GenericArgumentsContext<Args extends string[], Result extends t.TProperties = {}> = (Args extends [...infer Left extends string[], infer Right extends string] ? GenericArgumentsContext<Left, Result & {
+    [_ in Right]: t.TArgument<Left['length']>;
+}> : t.Evaluate<Result>);
+interface GenericArgumentsMapping extends Static.IMapping {
+    output: this['input'] extends [LAngle, infer Args extends string[], RAngle] ? GenericArgumentsContext<Args> : never;
+}
+export type GenericArguments = Static.Tuple<[
+    Static.Const<LAngle>,
+    GenericArgumentList,
+    Static.Const<RAngle>
+], GenericArgumentsMapping>;
 interface GenericReferenceMapping extends Static.IMapping {
-    output: this['context'] extends t.TProperties ? this['input'] extends [infer Reference extends string, LAngle, infer Parameters extends t.TSchema[], RAngle] ? t.TInstantiate<Dereference<this['context'], Reference>, [...Parameters]> : never : never;
+    output: this['context'] extends t.TProperties ? this['input'] extends [infer Reference extends string, LAngle, infer Args extends t.TSchema[], RAngle] ? t.TInstantiate<Dereference<this['context'], Reference>, Args> : never : never;
 }
 type GenericReference = Static.Tuple<[
     Static.Ident,

package/build/cjs/syntax/syntax.d.ts

@@ -1,33 +1,31 @@
-import * as Types from '../type/index';
+import * as t from '../type/index';
 import { Static } from '../parser/index';
-import { Type } from './static';
-/** Parses a TSchema type from TypeScript syntax but does not infer schematics */
-export declare function NoInfer<Context extends Record<PropertyKey, Types.TSchema>, Code extends string>(context: Context, code: Code, options?: Types.SchemaOptions): Types.TSchema | undefined;
-/** Parses a TSchema type from TypeScript syntax but does not infer schematics */
-export declare function NoInfer<Code extends string>(code: Code, options?: Types.SchemaOptions): Types.TSchema | undefined;
-/** Infers a TSchema type from TypeScript syntax. */
-export type TSyntax<Context extends Record<PropertyKey, Types.TSchema>, Code extends string> = (Static.Parse<Type, Code, Context> extends [infer Type extends Types.TSchema, string] ? Type : Types.TNever);
-/** Parses a TSchema type from TypeScript syntax */
-export declare function Syntax<Context extends Record<PropertyKey, Types.TSchema>, Code extends string>(context: Context, code: Code, options?: Types.SchemaOptions): TSyntax<Context, Code>;
-/** Parses a TSchema type from TypeScript syntax */
-export declare function Syntax<Code extends string>(code: Code, options?: Types.SchemaOptions): TSyntax<{}, Code>;
+import { Type, GenericArguments } from './static';
+type TParseSyntax<Context extends Record<PropertyKey, t.TSchema>, Code extends string> = (Static.Parse<GenericArguments, Code, {}> extends [infer Args extends t.TProperties, infer Rest extends string] ? Static.Parse<Type, Rest, Context & Args> : Static.Parse<Type, Code, Context>);
+/** Parses a TypeScript annotation into a TypeBox type but does not infer schematics */
+export declare function NoInfer<Context extends Record<PropertyKey, t.TSchema>, Code extends string>(context: Context, code: Code, options?: t.SchemaOptions): t.TSchema;
+/** Parses a TypeScript annotation into a TypeBox type but does not infer schematics */
+export declare function NoInfer<Code extends string>(code: Code, options?: t.SchemaOptions): t.TSchema;
+/** Parses a TypeScript annotation into a TypeBox type */
+export type TSyntax<Context extends Record<PropertyKey, t.TSchema>, Code extends string> = (TParseSyntax<Context, Code> extends [infer Type extends t.TSchema, string] ? Type : t.TNever);
+/** Parses a TypeScript annotation into a TypeBox type */
+export declare function Syntax<Context extends Record<PropertyKey, t.TSchema>, Annotation extends string>(context: Context, annotation: Annotation, options?: t.SchemaOptions): TSyntax<Context, Annotation>;
+/** Parses a TypeScript annotation into a TypeBox type */
+export declare function Syntax<Annotation extends string>(annotation: Annotation, options?: t.SchemaOptions): TSyntax<{}, Annotation>;
 /**
- * Parses a TSchema type from Syntax.
  * @deprecated Use Syntax() function
  */
-export declare function Parse<Context extends Record<PropertyKey, Types.TSchema>, Code extends string>(context: Context, code: Code, options?: Types.SchemaOptions): TSyntax<Context, Code>;
+export declare function Parse<Context extends Record<PropertyKey, t.TSchema>, Annotation extends string>(context: Context, annotation: Annotation, options?: t.SchemaOptions): TSyntax<Context, Annotation>;
 /**
- * Parses a TSchema type from Syntax.
  * @deprecated Use Syntax() function
  */
-export declare function Parse<Code extends string>(code: Code, options?: Types.SchemaOptions): TSyntax<{}, Code>;
+export declare function Parse<Annotation extends string>(annotation: Annotation, options?: t.SchemaOptions): TSyntax<{}, Annotation>;
 /**
- * Parses a TSchema from TypeScript Syntax
  * @deprecated Use NoInfer() function
  */
-export declare function ParseOnly<Context extends Record<PropertyKey, Types.TSchema>, Code extends string>(context: Context, code: Code, options?: Types.SchemaOptions): Types.TSchema | undefined;
+export declare function ParseOnly<Context extends Record<PropertyKey, t.TSchema>, Code extends string>(context: Context, code: Code, options?: t.SchemaOptions): t.TSchema | undefined;
 /**
- * Parses a TSchema from TypeScript Syntax
  * @deprecated Use NoInfer() function
  */
-export declare function ParseOnly<Code extends string>(code: Code, options?: Types.SchemaOptions): Types.TSchema | undefined;
+export declare function ParseOnly<Code extends string>(code: Code, options?: t.SchemaOptions): t.TSchema | undefined;
+export {};

package/build/cjs/syntax/syntax.js

@@ -5,31 +5,36 @@ exports.NoInfer = NoInfer;
 exports.Syntax = Syntax;
 exports.Parse = Parse;
 exports.ParseOnly = ParseOnly;
-const Types = require("../type/index");
+const t = require("../type/index");
 const runtime_1 = require("./runtime");
-/** Parses a TSchema type from TypeScript syntax but does not infer schematics */
+// prettier-ignore
+function ParseSyntax(context, code) {
+    const results = runtime_1.Module.Parse('GenericArguments', code, {}); // [ArgumentContext, Rest]
+    return (results.length === 2
+        ? runtime_1.Module.Parse('Type', results[1], { ...context, ...results[0] })
+        : runtime_1.Module.Parse('Type', code, context));
+}
+/** Parses a TypeScript annotation into a TypeBox type but does not infer schematics */
 // prettier-ignore
 function NoInfer(...args) {
     const withContext = typeof args[0] === 'string' ? false : true;
     const [context, code, options] = withContext ? [args[0], args[1], args[2] || {}] : [{}, args[0], args[1] || {}];
-    const type = runtime_1.Module.Parse('Type', code, context)[0];
-    return Types.KindGuard.IsSchema(type)
-        ? Types.CloneType(type, options)
-        : Types.Never(options);
+    const result = ParseSyntax(context, code)[0];
+    return t.KindGuard.IsSchema(result)
+        ? t.CloneType(result, options)
+        : t.Never(options);
 }
-/** Parses a TSchema type from TypeScript syntax */
+/** Parses a TypeScript annotation into a TypeBox type */
 function Syntax(...args) {
     return NoInfer.apply(null, args);
 }
 /**
- * Parses a TSchema type from Syntax.
  * @deprecated Use Syntax() function
  */
 function Parse(...args) {
     return NoInfer.apply(null, args);
 }
 /**
- * Parses a TSchema from TypeScript Syntax
  * @deprecated Use NoInfer() function
  */
 function ParseOnly(...args) {

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

@@ -1,25 +1,50 @@
-import type { TSchema } from '../schema/index';
-import type { TArgument } from '../argument/index';
-import { type TNever } from '../never/index';
+import { type TSchema } from '../schema/index';
+import { type TArgument } from '../argument/index';
+import { type TUnknown } from '../unknown/index';
 import { type TReadonlyOptional } from '../readonly-optional/index';
 import { type TReadonly } from '../readonly/index';
 import { type TOptional } from '../optional/index';
-import { type TRemap, type TMapping as TRemapMapping } from '../remap/index';
-type TInstantiateArgument<Argument extends TArgument, Type extends TSchema, IsArgumentReadonly extends number = Argument extends TReadonly<TSchema> ? 1 : 0, IsArgumentOptional extends number = Argument extends TOptional<TSchema> ? 1 : 0, Result extends TSchema = ([
-    IsArgumentReadonly,
-    IsArgumentOptional
-] extends [1, 1] ? TReadonlyOptional<Type> : [
-    IsArgumentReadonly,
-    IsArgumentOptional
-] extends [0, 1] ? TOptional<Type> : [
-    IsArgumentReadonly,
-    IsArgumentOptional
-] extends [1, 0] ? TReadonly<Type> : Type)> = Result;
-interface TInstantiateArguments<Arguments extends TSchema[]> extends TRemapMapping {
-    output: (this['input'] extends TArgument<infer Index extends number> ? Index extends keyof Arguments ? Arguments[Index] extends TSchema ? TInstantiateArgument<this['input'], Arguments[Index]> : TNever : TNever : this['input']);
-}
+import { type TConstructor } from '../constructor/index';
+import { type TFunction } from '../function/index';
+import { type TIntersect } from '../intersect/index';
+import { type TUnion } from '../union/index';
+import { type TTuple } from '../tuple/index';
+import { type TArray } from '../array/index';
+import { type TAsyncIterator } from '../async-iterator/index';
+import { type TIterator } from '../iterator/index';
+import { type TPromise } from '../promise/index';
+import { type TObject, type TProperties } from '../object/index';
+import { type TRecordOrObject, type TRecord } from '../record/index';
+type TFromConstructor<Args extends TSchema[], Parameters extends TSchema[], InstanceType extends TSchema, Result extends TConstructor = TConstructor<TFromTypes<Args, Parameters>, TFromType<Args, InstanceType>>> = Result;
+type TFromFunction<Args extends TSchema[], Parameters extends TSchema[], ReturnType extends TSchema, Result extends TFunction = TFunction<TFromTypes<Args, Parameters>, TFromType<Args, ReturnType>>> = Result;
+type TFromIntersect<Args extends TSchema[], Types extends TSchema[], Result extends TIntersect = TIntersect<TFromTypes<Args, Types>>> = Result;
+type TFromUnion<Args extends TSchema[], Types extends TSchema[], Result extends TUnion = TUnion<TFromTypes<Args, Types>>> = Result;
+type TFromTuple<Args extends TSchema[], Types extends TSchema[], Result extends TTuple = TTuple<TFromTypes<Args, Types>>> = Result;
+type TFromArray<Args extends TSchema[], Type extends TSchema, Result extends TArray = TArray<TFromType<Args, Type>>> = Result;
+type TFromAsyncIterator<Args extends TSchema[], Type extends TSchema, Result extends TAsyncIterator = TAsyncIterator<TFromType<Args, Type>>> = Result;
+type TFromIterator<Args extends TSchema[], Type extends TSchema, Result extends TIterator = TIterator<TFromType<Args, Type>>> = Result;
+type TFromPromise<Args extends TSchema[], Type extends TSchema, Result extends TPromise = TPromise<TFromType<Args, Type>>> = Result;
+type TFromObject<Args extends TSchema[], Properties extends TProperties, Result extends TProperties = TFromProperties<Args, Properties>> = TObject<Result>;
+type TFromRecord<Args extends TSchema[], Key extends TSchema, Value extends TSchema, MappedKey extends TSchema = TFromType<Args, Key>, MappedValue extends TSchema = TFromType<Args, Value>, Result extends TSchema = TRecordOrObject<MappedKey, MappedValue>> = Result;
+type TFromArgument<Args extends TSchema[], Index extends number, Result extends TSchema = Index extends keyof Args[Index] ? Args[Index] : TUnknown> = Result;
+type TFromProperty<Args extends TSchema[], Type extends TSchema, IsReadonly extends boolean = Type extends TReadonly<Type> ? true : false, IsOptional extends boolean = Type extends TOptional<Type> ? true : false, Mapped extends TSchema = TFromType<Args, Type>, Result extends TSchema = ([
+    IsReadonly,
+    IsOptional
+] extends [true, true] ? TReadonlyOptional<Mapped> : [
+    IsReadonly,
+    IsOptional
+] extends [true, false] ? TReadonly<Mapped> : [
+    IsReadonly,
+    IsOptional
+] extends [false, true] ? TOptional<Mapped> : Mapped)> = Result;
+type TFromProperties<Args extends TSchema[], Properties extends TProperties, Result extends TProperties = {
+    [Key in keyof Properties]: TFromProperty<Args, Properties[Key]>;
+}> = Result;
+export type TFromTypes<Args extends TSchema[], Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromTypes<Args, Right, [...Result, TFromType<Args, Left>]> : Result);
+export declare function FromTypes<Args extends TSchema[], Types extends TSchema[]>(args: [...Args], types: [...Types]): TFromTypes<Args, Types>;
+export type TFromType<Args extends TSchema[], Type extends TSchema> = (Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TFromConstructor<Args, Parameters, InstanceType> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFromFunction<Args, Parameters, ReturnType> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<Args, Types> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Args, Types> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple<Args, Types> : Type extends TArray<infer Type extends TSchema> ? TFromArray<Args, Type> : Type extends TAsyncIterator<infer Type extends TSchema> ? TFromAsyncIterator<Args, Type> : Type extends TIterator<infer Type extends TSchema> ? TFromIterator<Args, Type> : Type extends TPromise<infer Type extends TSchema> ? TFromPromise<Args, Type> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<Args, Properties> : Type extends TRecord<infer Key extends TSchema, infer Value extends TSchema> ? TFromRecord<Args, Key, Value> : Type extends TArgument<infer Index extends number> ? TFromArgument<Args, Index> : Type);
 /** `[JavaScript]` Instantiates a type with the given parameters */
-export type TInstantiate<Type extends TSchema, Arguments extends TSchema[]> = (TRemap<Type, TInstantiateArguments<Arguments>>);
+export type TInstantiate<Type extends TSchema, Args extends TSchema[], Result extends TSchema = TFromType<Args, Type>> = Result;
 /** `[JavaScript]` Instantiates a type with the given parameters */
-export declare function Instantiate<Type extends TSchema, Arguments extends TSchema[]>(type: Type, args: [...Arguments]): TInstantiate<Type, Arguments>;
+export declare function Instantiate<Type extends TSchema, Args extends TSchema[]>(type: Type, args: [...Args]): TInstantiate<Type, Args>;
 export {};

package/build/cjs/type/instantiate/instantiate.js

@@ -1,32 +1,120 @@
 "use strict";
 
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromTypes = FromTypes;
 exports.Instantiate = Instantiate;
-const index_1 = require("../never/index");
+const type_1 = require("../clone/type");
+const index_1 = require("../unknown/index");
 const index_2 = require("../readonly-optional/index");
 const index_3 = require("../readonly/index");
 const index_4 = require("../optional/index");
-const index_5 = require("../remap/index");
+const index_5 = require("../object/index");
+const index_6 = require("../record/index");
+const ValueGuard = require("../guard/value");
 const KindGuard = require("../guard/kind");
 // prettier-ignore
-function InstantiateArgument(argument, type) {
-    const isReadonly = KindGuard.IsReadonly(argument);
-    const isOptional = KindGuard.IsOptional(argument);
-    return (isReadonly && isOptional ? (0, index_2.ReadonlyOptional)(type) :
-        isReadonly && !isOptional ? (0, index_3.Readonly)(type) :
-            !isReadonly && isOptional ? (0, index_4.Optional)(type) :
-                type);
+function FromConstructor(args, type) {
+    type.parameters = FromTypes(args, type.parameters);
+    type.returns = FromType(args, type.returns);
+    return type;
+}
+// prettier-ignore
+function FromFunction(args, type) {
+    type.parameters = FromTypes(args, type.parameters);
+    type.returns = FromType(args, type.returns);
+    return type;
+}
+// prettier-ignore
+function FromIntersect(args, type) {
+    type.allOf = FromTypes(args, type.allOf);
+    return type;
+}
+// prettier-ignore
+function FromUnion(args, type) {
+    type.anyOf = FromTypes(args, type.anyOf);
+    return type;
+}
+// prettier-ignore
+function FromTuple(args, type) {
+    if (ValueGuard.IsUndefined(type.items))
+        return type;
+    type.items = FromTypes(args, type.items);
+    return type;
+}
+// prettier-ignore
+function FromArray(args, type) {
+    type.items = FromType(args, type.items);
+    return type;
+}
+// prettier-ignore
+function FromAsyncIterator(args, type) {
+    type.items = FromType(args, type.items);
+    return type;
+}
+// prettier-ignore
+function FromIterator(args, type) {
+    type.items = FromType(args, type.items);
+    return type;
+}
+// prettier-ignore
+function FromPromise(args, type) {
+    type.item = FromType(args, type.item);
+    return type;
+}
+// prettier-ignore
+function FromObject(args, type) {
+    const properties = FromProperties(args, type.properties);
+    return { ...type, ...(0, index_5.Object)(properties) }; // retain options
+}
+// prettier-ignore
+function FromRecord(args, type) {
+    const mappedKey = FromType(args, (0, index_6.RecordKey)(type));
+    const mappedValue = FromType(args, (0, index_6.RecordValue)(type));
+    const result = (0, index_6.Record)(mappedKey, mappedValue);
+    return { ...type, ...result }; // retain options
+}
+// prettier-ignore
+function FromArgument(args, argument) {
+    return argument.index in args ? args[argument.index] : (0, index_1.Unknown)();
+}
+// prettier-ignore
+function FromProperty(args, type) {
+    const isReadonly = KindGuard.IsReadonly(type);
+    const isOptional = KindGuard.IsOptional(type);
+    const mapped = FromType(args, type);
+    return (isReadonly && isOptional ? (0, index_2.ReadonlyOptional)(mapped) :
+        isReadonly && !isOptional ? (0, index_3.Readonly)(mapped) :
+            !isReadonly && isOptional ? (0, index_4.Optional)(mapped) :
+                mapped);
+}
+// prettier-ignore
+function FromProperties(args, properties) {
+    return globalThis.Object.getOwnPropertyNames(properties).reduce((result, key) => {
+        return { ...result, [key]: FromProperty(args, properties[key]) };
+    }, {});
+}
+// prettier-ignore
+function FromTypes(args, types) {
+    return types.map(type => FromType(args, type));
+}
+// prettier-ignore
+function FromType(args, type) {
+    return (KindGuard.IsConstructor(type) ? FromConstructor(args, type) :
+        KindGuard.IsFunction(type) ? FromFunction(args, type) :
+            KindGuard.IsIntersect(type) ? FromIntersect(args, type) :
+                KindGuard.IsUnion(type) ? FromUnion(args, type) :
+                    KindGuard.IsTuple(type) ? FromTuple(args, type) :
+                        KindGuard.IsArray(type) ? FromArray(args, type) :
+                            KindGuard.IsAsyncIterator(type) ? FromAsyncIterator(args, type) :
+                                KindGuard.IsIterator(type) ? FromIterator(args, type) :
+                                    KindGuard.IsPromise(type) ? FromPromise(args, type) :
+                                        KindGuard.IsObject(type) ? FromObject(args, type) :
+                                            KindGuard.IsRecord(type) ? FromRecord(args, type) :
+                                                KindGuard.IsArgument(type) ? FromArgument(args, type) :
+                                                    type);
 }
 /** `[JavaScript]` Instantiates a type with the given parameters */
 // prettier-ignore
 function Instantiate(type, args) {
-    return (0, index_5.Remap)(type, (type) => {
-        return KindGuard.IsArgument(type)
-            ? type.index in args
-                ? KindGuard.IsSchema(args[type.index])
-                    ? InstantiateArgument(type, args[type.index])
-                    : (0, index_1.Never)()
-                : (0, index_1.Never)()
-            : type;
-    });
+    return FromType(args, (0, type_1.CloneType)(type));
 }

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

@@ -43,7 +43,6 @@ export { Record } from '../record/index';
 export { Recursive } from '../recursive/index';
 export { Ref } from '../ref/index';
 export { RegExp } from '../regexp/index';
-export { Remap } from '../remap/index';
 export { Required } from '../required/index';
 export { Rest } from '../rest/index';
 export { ReturnType } from '../return-type/index';

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

@@ -1,8 +1,8 @@
 "use strict";
 
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Required = exports.Remap = exports.RegExp = exports.Ref = exports.Recursive = exports.Record = exports.ReadonlyOptional = exports.Readonly = exports.Promise = exports.Pick = exports.Partial = exports.Parameters = exports.Optional = exports.Omit = exports.Object = exports.Number = exports.Null = exports.Not = exports.Never = exports.Module = exports.Mapped = exports.Literal = exports.KeyOf = exports.Iterator = exports.Uppercase = exports.Lowercase = exports.Uncapitalize = exports.Capitalize = exports.Intersect = exports.Integer = exports.Instantiate = exports.InstanceType = exports.Index = exports.Function = exports.Extract = exports.Extends = exports.Exclude = exports.Enum = exports.Date = exports.ConstructorParameters = exports.Constructor = exports.Const = exports.Composite = exports.Boolean = exports.BigInt = exports.Awaited = exports.AsyncIterator = exports.Array = exports.Argument = exports.Any = void 0;
-exports.Void = exports.Unsafe = exports.Unknown = exports.Union = exports.Undefined = exports.Uint8Array = exports.Tuple = exports.Transform = exports.TemplateLiteral = exports.Symbol = exports.String = exports.ReturnType = exports.Rest = void 0;
+exports.Rest = exports.Required = exports.RegExp = exports.Ref = exports.Recursive = exports.Record = exports.ReadonlyOptional = exports.Readonly = exports.Promise = exports.Pick = exports.Partial = exports.Parameters = exports.Optional = exports.Omit = exports.Object = exports.Number = exports.Null = exports.Not = exports.Never = exports.Module = exports.Mapped = exports.Literal = exports.KeyOf = exports.Iterator = exports.Uppercase = exports.Lowercase = exports.Uncapitalize = exports.Capitalize = exports.Intersect = exports.Integer = exports.Instantiate = exports.InstanceType = exports.Index = exports.Function = exports.Extract = exports.Extends = exports.Exclude = exports.Enum = exports.Date = exports.ConstructorParameters = exports.Constructor = exports.Const = exports.Composite = exports.Boolean = exports.BigInt = exports.Awaited = exports.AsyncIterator = exports.Array = exports.Argument = exports.Any = void 0;
+exports.Void = exports.Unsafe = exports.Unknown = exports.Union = exports.Undefined = exports.Uint8Array = exports.Tuple = exports.Transform = exports.TemplateLiteral = exports.Symbol = exports.String = exports.ReturnType = void 0;
 // ------------------------------------------------------------------
 // Type: Module
 // ------------------------------------------------------------------
@@ -99,33 +99,31 @@ var index_44 = require("../ref/index");
 Object.defineProperty(exports, "Ref", { enumerable: true, get: function () { return index_44.Ref; } });
 var index_45 = require("../regexp/index");
 Object.defineProperty(exports, "RegExp", { enumerable: true, get: function () { return index_45.RegExp; } });
-var index_46 = require("../remap/index");
-Object.defineProperty(exports, "Remap", { enumerable: true, get: function () { return index_46.Remap; } });
-var index_47 = require("../required/index");
-Object.defineProperty(exports, "Required", { enumerable: true, get: function () { return index_47.Required; } });
-var index_48 = require("../rest/index");
-Object.defineProperty(exports, "Rest", { enumerable: true, get: function () { return index_48.Rest; } });
-var index_49 = require("../return-type/index");
-Object.defineProperty(exports, "ReturnType", { enumerable: true, get: function () { return index_49.ReturnType; } });
-var index_50 = require("../string/index");
-Object.defineProperty(exports, "String", { enumerable: true, get: function () { return index_50.String; } });
-var index_51 = require("../symbol/index");
-Object.defineProperty(exports, "Symbol", { enumerable: true, get: function () { return index_51.Symbol; } });
-var index_52 = require("../template-literal/index");
-Object.defineProperty(exports, "TemplateLiteral", { enumerable: true, get: function () { return index_52.TemplateLiteral; } });
-var index_53 = require("../transform/index");
-Object.defineProperty(exports, "Transform", { enumerable: true, get: function () { return index_53.Transform; } });
-var index_54 = require("../tuple/index");
-Object.defineProperty(exports, "Tuple", { enumerable: true, get: function () { return index_54.Tuple; } });
-var index_55 = require("../uint8array/index");
-Object.defineProperty(exports, "Uint8Array", { enumerable: true, get: function () { return index_55.Uint8Array; } });
-var index_56 = require("../undefined/index");
-Object.defineProperty(exports, "Undefined", { enumerable: true, get: function () { return index_56.Undefined; } });
-var index_57 = require("../union/index");
-Object.defineProperty(exports, "Union", { enumerable: true, get: function () { return index_57.Union; } });
-var index_58 = require("../unknown/index");
-Object.defineProperty(exports, "Unknown", { enumerable: true, get: function () { return index_58.Unknown; } });
-var index_59 = require("../unsafe/index");
-Object.defineProperty(exports, "Unsafe", { enumerable: true, get: function () { return index_59.Unsafe; } });
-var index_60 = require("../void/index");
-Object.defineProperty(exports, "Void", { enumerable: true, get: function () { return index_60.Void; } });
+var index_46 = require("../required/index");
+Object.defineProperty(exports, "Required", { enumerable: true, get: function () { return index_46.Required; } });
+var index_47 = require("../rest/index");
+Object.defineProperty(exports, "Rest", { enumerable: true, get: function () { return index_47.Rest; } });
+var index_48 = require("../return-type/index");
+Object.defineProperty(exports, "ReturnType", { enumerable: true, get: function () { return index_48.ReturnType; } });
+var index_49 = require("../string/index");
+Object.defineProperty(exports, "String", { enumerable: true, get: function () { return index_49.String; } });
+var index_50 = require("../symbol/index");
+Object.defineProperty(exports, "Symbol", { enumerable: true, get: function () { return index_50.Symbol; } });
+var index_51 = require("../template-literal/index");
+Object.defineProperty(exports, "TemplateLiteral", { enumerable: true, get: function () { return index_51.TemplateLiteral; } });
+var index_52 = require("../transform/index");
+Object.defineProperty(exports, "Transform", { enumerable: true, get: function () { return index_52.Transform; } });
+var index_53 = require("../tuple/index");
+Object.defineProperty(exports, "Tuple", { enumerable: true, get: function () { return index_53.Tuple; } });
+var index_54 = require("../uint8array/index");
+Object.defineProperty(exports, "Uint8Array", { enumerable: true, get: function () { return index_54.Uint8Array; } });
+var index_55 = require("../undefined/index");
+Object.defineProperty(exports, "Undefined", { enumerable: true, get: function () { return index_55.Undefined; } });
+var index_56 = require("../union/index");
+Object.defineProperty(exports, "Union", { enumerable: true, get: function () { return index_56.Union; } });
+var index_57 = require("../unknown/index");
+Object.defineProperty(exports, "Unknown", { enumerable: true, get: function () { return index_57.Unknown; } });
+var index_58 = require("../unsafe/index");
+Object.defineProperty(exports, "Unsafe", { enumerable: true, get: function () { return index_58.Unsafe; } });
+var index_59 = require("../void/index");
+Object.defineProperty(exports, "Void", { enumerable: true, get: function () { return index_59.Void; } });

package/build/esm/index.d.mts

@@ -52,7 +52,6 @@ export * from './type/record/index.mjs';
 export * from './type/recursive/index.mjs';
 export * from './type/ref/index.mjs';
 export * from './type/regexp/index.mjs';
-export * from './type/remap/index.mjs';
 export * from './type/required/index.mjs';
 export * from './type/rest/index.mjs';
 export * from './type/return-type/index.mjs';

package/build/esm/index.mjs

@@ -58,7 +58,6 @@ export * from './type/record/index.mjs';
 export * from './type/recursive/index.mjs';
 export * from './type/ref/index.mjs';
 export * from './type/regexp/index.mjs';
-export * from './type/remap/index.mjs';
 export * from './type/required/index.mjs';
 export * from './type/rest/index.mjs';
 export * from './type/return-type/index.mjs';

package/build/esm/syntax/runtime.d.mts

@@ -1,6 +1,8 @@
 import { Runtime } from '../parser/index.mjs';
 import * as t from '../type/index.mjs';
 export declare const Module: Runtime.Module<{
+    GenericArgumentList: Runtime.IUnion<unknown[]>;
+    GenericArguments: Runtime.ITuple<{}>;
     Literal: Runtime.IUnion<t.TLiteral<string> | t.TLiteral<number> | t.TLiteral<boolean>>;
     Keyword: Runtime.IUnion<t.TAny | t.TBoolean | t.TBigInt | t.TNever | t.TString | t.TNumber | t.TInteger | t.TNull | t.TSymbol | t.TUndefined | t.TUnknown | t.TVoid>;
     KeyOf: Runtime.IUnion<boolean>;