typebox 0.0.1 → 1.0.0-rc

package/build/type/engine/indexed/from-array.mjs

@@ -0,0 +1,26 @@
+// deno-fmt-ignore-file
+import { Intersect, IsIntersect } from '../../types/intersect.mjs';
+import { Union, IsUnion } from '../../types/union.mjs';
+import { Literal, IsLiteral } from '../../types/literal.mjs';
+import { Number } from '../../types/number.mjs';
+import { Never } from '../../types/never.mjs';
+import { Extends, ExtendsResult } from '../../extends/index.mjs';
+import { ConvertToIntegerKey } from '../helpers/keys.mjs';
+function NormalizeLiteral(value) {
+    return Literal(ConvertToIntegerKey(value));
+}
+function NormalizeIndexerTypes(types) {
+    return types.map(type => NormalizeIndexer(type));
+}
+export function NormalizeIndexer(type) {
+    return (IsIntersect(type) ? Intersect(NormalizeIndexerTypes(type.allOf)) :
+        IsUnion(type) ? Union(NormalizeIndexerTypes(type.anyOf)) :
+            IsLiteral(type) ? NormalizeLiteral(type.const) :
+                type);
+}
+export function FromArray(type, indexer) {
+    const normalizedIndexer = NormalizeIndexer(indexer);
+    const check = Extends({}, normalizedIndexer, Number());
+    const result = ExtendsResult.IsExtendsTrueLike(check) ? type : Never();
+    return result;
+}

package/build/type/engine/indexed/from-object.d.mts

@@ -0,0 +1,9 @@
+import { type TProperties } from '../../types/properties.mjs';
+import { type TSchema } from '../../types/schema.mjs';
+import { type TEvaluateUnion } from '../evaluate/evaluate.mjs';
+import { type TToIndexableKeys } from '../indexable/to-indexable-keys.mjs';
+type TSelectProperty<Properties extends TProperties, Key extends string, PropertyKey extends string = keyof Properties extends string | number ? `${keyof Properties}` : never, Result extends TSchema[] = Key extends PropertyKey ? [Properties[Key]] : []> = Result;
+type TSelectProperties<Properties extends TProperties, Keys extends string[], Result extends TSchema[] = []> = (Keys extends [infer Left extends string, ...infer Right extends string[]] ? TSelectProperties<Properties, Right, [...Result, ...TSelectProperty<Properties, Left>]> : Result);
+export type TFromObject<Properties extends TProperties, Indexer extends TSchema, Keys extends string[] = TToIndexableKeys<Indexer>, Variants extends TSchema[] = TSelectProperties<Properties, Keys>, Result extends TSchema = TEvaluateUnion<Variants>> = Result;
+export declare function FromObject<Properties extends TProperties, Indexer extends TSchema>(properties: Properties, indexer: Indexer): TFromObject<Properties, Indexer>;
+export {};

package/build/type/engine/indexed/from-object.mjs

@@ -0,0 +1,18 @@
+// deno-fmt-ignore-file
+import { EvaluateUnion } from '../evaluate/evaluate.mjs';
+import { ToIndexableKeys } from '../indexable/to-indexable-keys.mjs';
+function SelectProperty(properties, indexer) {
+    const result = indexer in properties ? [properties[indexer]] : [];
+    return result;
+}
+function SelectProperties(properties, indexer) {
+    return indexer.reduce((result, left) => {
+        return [...result, ...SelectProperty(properties, left)];
+    }, []);
+}
+export function FromObject(properties, indexer) {
+    const keys = ToIndexableKeys(indexer);
+    const variants = SelectProperties(properties, keys);
+    const result = EvaluateUnion(variants);
+    return result;
+}

package/build/type/engine/indexed/from-tuple.d.mts

@@ -0,0 +1,13 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TLiteral } from '../../types/literal.mjs';
+import { type TNumber } from '../../types/number.mjs';
+import { type TInteger } from '../../types/integer.mjs';
+import { type TEvaluateUnion } from '../evaluate/evaluate.mjs';
+import { type TExtends, ExtendsResult } from '../../extends/index.mjs';
+import { type TFormatArrayIndexer } from './array-indexer.mjs';
+type TIndexElementsWithIndexer<Types extends TSchema[], Indexer extends TSchema, Result extends TSchema[] = []> = (Types extends [...infer Left extends TSchema[], infer Right extends TSchema] ? TExtends<{}, TLiteral<Left['length']>, Indexer> extends ExtendsResult.TExtendsTrueLike ? TIndexElementsWithIndexer<Left, Indexer, [Right, ...Result]> : TIndexElementsWithIndexer<Left, Indexer, Result> : Result);
+type TFromTupleWithIndexer<Types extends TSchema[], Indexer extends TSchema, ArrayIndexer extends TSchema = TFormatArrayIndexer<Indexer>, Elements extends TSchema[] = TIndexElementsWithIndexer<Types, ArrayIndexer>, Result extends TSchema = TEvaluateUnion<Elements>> = Result;
+type TFromTupleWithoutIndexer<Types extends TSchema[], Result extends TSchema = TEvaluateUnion<Types>> = Result;
+export type TFromTuple<Types extends TSchema[], Indexer extends TSchema, Result extends TSchema = (Indexer extends TNumber | TInteger ? TFromTupleWithoutIndexer<Types> : TFromTupleWithIndexer<Types, Indexer>)> = Result;
+export declare function FromTuple<Types extends TSchema[], Indexer extends TSchema>(types: [...Types], indexer: Indexer): TFromTuple<Types, Indexer>;
+export {};

package/build/type/engine/indexed/from-tuple.mjs

@@ -0,0 +1,28 @@
+// deno-fmt-ignore-file
+import { Literal } from '../../types/literal.mjs';
+import { IsNumber } from '../../types/number.mjs';
+import { IsInteger } from '../../types/integer.mjs';
+import { EvaluateUnion } from '../evaluate/evaluate.mjs';
+import { Extends, ExtendsResult } from '../../extends/index.mjs';
+import { FormatArrayIndexer } from './array-indexer.mjs';
+function IndexElementsWithIndexer(types, indexer) {
+    return types.reduceRight((result, right, index) => {
+        const check = Extends({}, Literal(index), indexer);
+        return ExtendsResult.IsExtendsTrueLike(check)
+            ? [right, ...result]
+            : result;
+    }, []);
+}
+function FromTupleWithIndexer(types, indexer) {
+    const formattedArrayIndexer = FormatArrayIndexer(indexer);
+    const elements = IndexElementsWithIndexer(types, formattedArrayIndexer);
+    return EvaluateUnion(elements);
+}
+function FromTupleWithoutIndexer(types) {
+    return EvaluateUnion(types);
+}
+export function FromTuple(types, indexer) {
+    return (IsNumber(indexer) || IsInteger(indexer)
+        ? FromTupleWithoutIndexer(types)
+        : FromTupleWithIndexer(types, indexer));
+}

package/build/type/engine/indexed/index.d.mts

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

package/build/type/engine/indexed/index.mjs

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

package/build/type/engine/indexed/instantiate.d.mts

@@ -0,0 +1,21 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TArray } from '../../types/array.mjs';
+import { type TCyclic } from '../../types/cyclic.mjs';
+import { type TIntersect } from '../../types/intersect.mjs';
+import { type TNever } from '../../types/never.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TTuple } from '../../types/tuple.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TFromArray } from './from-array.mjs';
+import { type TFromObject } from './from-object.mjs';
+import { type TFromTuple } from './from-tuple.mjs';
+import { type TState, type TInstantiateType, TCanInstantiate } from '../instantiate.mjs';
+import { type TIndexDeferred } from '../../action/indexed.mjs';
+import { type TCollapseToObject } from '../object/index.mjs';
+type TNormalizeType<Type extends TSchema, Result extends TSchema = (Type extends TCyclic | TIntersect | TUnion ? TCollapseToObject<Type> : Type)> = Result;
+type TIndexAction<Type extends TSchema, Indexer extends TSchema, Normal extends TSchema = TNormalizeType<Type>> = (Normal extends TArray<infer Type extends TSchema> ? TFromArray<Type, Indexer> : Normal extends TObject<infer Properties extends TProperties> ? TFromObject<Properties, Indexer> : Normal extends TTuple<infer Types extends TSchema[]> ? TFromTuple<Types, Indexer> : TNever);
+type TIndexImmediate<Context extends TProperties, State extends TState, Type extends TSchema, Indexer extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>, InstantiatedIndexer extends TSchema = TInstantiateType<Context, State, Indexer>> = TIndexAction<InstantiatedType, InstantiatedIndexer>;
+export type TIndexInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, Indexer extends TSchema> = TCanInstantiate<Context, [Type, Indexer]> extends true ? TIndexImmediate<Context, State, Type, Indexer> : TIndexDeferred<Type, Indexer>;
+export declare function IndexInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, Indexer extends TSchema>(context: Context, state: State, type: Type, indexer: Indexer, options: TSchemaOptions): TIndexInstantiate<Context, State, Type, Indexer>;
+export {};

package/build/type/engine/indexed/instantiate.mjs

@@ -0,0 +1,37 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../../system/memory/index.mjs';
+import { IsArray } from '../../types/array.mjs';
+import { IsCyclic } from '../../types/cyclic.mjs';
+import { IsIntersect } from '../../types/intersect.mjs';
+import { Never } from '../../types/never.mjs';
+import { IsObject } from '../../types/object.mjs';
+import { IsTuple } from '../../types/tuple.mjs';
+import { IsUnion } from '../../types/union.mjs';
+import { FromArray } from './from-array.mjs';
+import { FromObject } from './from-object.mjs';
+import { FromTuple } from './from-tuple.mjs';
+import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
+import { IndexDeferred } from '../../action/indexed.mjs';
+import { CollapseToObject } from '../object/index.mjs';
+function NormalizeType(type) {
+    const result = (IsCyclic(type) || IsIntersect(type) || IsUnion(type) ? CollapseToObject(type) :
+        type);
+    return result;
+}
+function IndexAction(type, indexer) {
+    const normal = NormalizeType(type);
+    return (IsArray(normal) ? FromArray(normal.items, indexer) :
+        IsObject(normal) ? FromObject(normal.properties, indexer) :
+            IsTuple(normal) ? FromTuple(normal.items, indexer) :
+                Never());
+}
+function IndexImmediate(context, state, type, indexer, options) {
+    const instantiatedType = InstantiateType(context, state, type);
+    const instantiatedIndexer = InstantiateType(context, state, indexer);
+    return Memory.Update(IndexAction(instantiatedType, instantiatedIndexer), {}, options);
+}
+export function IndexInstantiate(context, state, type, indexer, options) {
+    return (CanInstantiate(context, [type, indexer])
+        ? IndexImmediate(context, state, type, indexer, options)
+        : IndexDeferred(type, indexer, options));
+}

package/build/type/engine/instance-type/index.d.mts

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

package/build/type/engine/instance-type/index.mjs

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

package/build/type/engine/instance-type/instantiate.d.mts

@@ -0,0 +1,12 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TConstructor } from '../../types/constructor.mjs';
+import { type TNever } from '../../types/never.mjs';
+import { type TInstanceTypeDeferred } from '../../action/instance-type.mjs';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
+type TInstanceTypeAction<Type extends TSchema> = (Type extends TConstructor<infer _Parameters extends TSchema[], infer InstanceType extends TSchema> ? InstanceType : TNever);
+export type TInstanceTypeImmediate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TInstanceTypeAction<InstantiatedType>;
+export declare function InstanceTypeImmediate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TInstanceTypeImmediate<Context, State, Type>;
+export type TInstanceTypeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema> = TCanInstantiate<Context, [Type]> extends true ? TInstanceTypeImmediate<Context, State, Type> : TInstanceTypeDeferred<Type>;
+export declare function InstanceTypeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options?: TSchemaOptions): TInstanceTypeInstantiate<Context, State, Type>;
+export {};

package/build/type/engine/instance-type/instantiate.mjs

@@ -0,0 +1,20 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../../system/memory/index.mjs';
+import { IsConstructor } from '../../types/constructor.mjs';
+import { Never } from '../../types/never.mjs';
+import { InstanceTypeDeferred } from '../../action/instance-type.mjs';
+import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
+function InstanceTypeAction(type) {
+    return (IsConstructor(type)
+        ? type.instanceType
+        : Never());
+}
+export function InstanceTypeImmediate(context, state, type, options) {
+    const instantiatedType = InstantiateType(context, state, type);
+    return Memory.Update(InstanceTypeAction(instantiatedType), {}, options);
+}
+export function InstanceTypeInstantiate(context, state, type, options = {}) {
+    return (CanInstantiate(context, [type])
+        ? InstanceTypeImmediate(context, state, type, options)
+        : InstanceTypeDeferred(type, options));
+}

package/build/type/engine/instantiate.d.mts

@@ -0,0 +1,162 @@
+import { type TOptional, TOptionalAdd, TOptionalRemove } from '../types/_optional.mjs';
+import { type TReadonly, TReadonlyAdd, TReadonlyRemove } from '../types/_readonly.mjs';
+import { type TSchema } from '../types/schema.mjs';
+import { type TArray } from '../types/array.mjs';
+import { type TAsyncIterator } from '../types/async-iterator.mjs';
+import { type TConstructor } from '../types/constructor.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TFunction } from '../types/function.mjs';
+import { type TCall } from '../types/call.mjs';
+import { type TIdentifier } from '../types/identifier.mjs';
+import { type TIntersect } from '../types/intersect.mjs';
+import { type TIterator } from '../types/iterator.mjs';
+import { type TObject } from '../types/object.mjs';
+import { type TPromise } from '../types/promise.mjs';
+import { type TProperties } from '../types/properties.mjs';
+import { type TRecord } from '../types/record.mjs';
+import { type TTuple } from '../types/tuple.mjs';
+import { type TUnion } from '../types/union.mjs';
+import { type TRef } from '../types/ref.mjs';
+import { type TRest } from '../types/rest.mjs';
+import { type TReadonlyAddAction, type TReadonlyRemoveAction } from '../action/_readonly.mjs';
+import { type TOptionalAddAction, type TOptionalRemoveAction } from '../action/_optional.mjs';
+import { type TAwaitedInstantiate } from './awaited/instantiate.mjs';
+import { type TCallInstantiate } from './call/instantiate.mjs';
+import { type TCapitalizeInstantiate } from './intrinsics/instantiate.mjs';
+import { type TConditionalInstantiate } from './conditional/index.mjs';
+import { type TConstructorParametersInstantiate } from './constructor-parameters/instantiate.mjs';
+import { type TEvaluateInstantiate } from './evaluate/instantiate.mjs';
+import { type TExcludeInstantiate } from './exclude/instantiate.mjs';
+import { type TExtractInstantiate } from './extract/instantiate.mjs';
+import { type TIndexInstantiate } from './indexed/instantiate.mjs';
+import { type TInstanceTypeInstantiate } from './instance-type/instantiate.mjs';
+import { type TInterfaceInstantiate } from './interface/instantiate.mjs';
+import { type TKeyOfInstantiate } from './keyof/instantiate.mjs';
+import { type TLowercaseInstantiate } from './intrinsics/instantiate.mjs';
+import { type TMappedInstantiate } from './mapped/instantiate.mjs';
+import { type TModuleInstantiate } from './module/instantiate.mjs';
+import { type TNonNullableInstantiate } from './non-nullable/instantiate.mjs';
+import { type TOmitInstantiate } from './omit/instantiate.mjs';
+import { type TOptionsInstantiate } from './options/instantiate.mjs';
+import { type TParametersInstantiate } from './parameters/instantiate.mjs';
+import { type TPartialInstantiate } from './partial/instantiate.mjs';
+import { type TPickInstantiate } from './pick/instantiate.mjs';
+import { type TRecordInstantiate } from './record/instantiate.mjs';
+import { type TRefInstantiate } from './ref/instantiate.mjs';
+import { type TRequiredInstantiate } from './required/instantiate.mjs';
+import { type TReturnTypeInstantiate } from './return-type/instantiate.mjs';
+import { type TTemplateLiteralInstantiate } from './template-literal/instantiate.mjs';
+import { type TUncapitalizeInstantiate } from './intrinsics/instantiate.mjs';
+import { type TUppercaseInstantiate } from './intrinsics/instantiate.mjs';
+import { type TRestSpread } from './rest/index.mjs';
+export interface TState {
+    callstack: string[];
+}
+type TCanInstantiateRef<Context extends TProperties, Ref extends string> = (Ref extends keyof Context ? true : false);
+type TCanInstantiateType<Context extends TProperties, Type extends TSchema> = (Type extends TIntersect<infer Types extends TSchema[]> ? TCanInstantiate<Context, Types> : Type extends TUnion<infer Types extends TSchema[]> ? TCanInstantiate<Context, Types> : Type extends TRef<infer Ref extends string> ? TCanInstantiateRef<Context, Ref> : true);
+export type TCanInstantiate<Context extends TProperties, Types extends TSchema[]> = Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TCanInstantiateType<Context, Left> extends true ? TCanInstantiate<Context, Right> : false : true;
+export declare function CanInstantiate<Context extends TProperties, Types extends TSchema[]>(context: Context, types: [...Types]): TCanInstantiate<Context, Types>;
+type ModifierAction = 'add' | 'remove' | 'none';
+type TModifierActions<Type extends TSchema, Readonly extends ModifierAction, Optional extends ModifierAction> = (Type extends TReadonlyRemoveAction<infer Type extends TSchema> ? TModifierActions<Type, 'remove', Optional> : Type extends TOptionalRemoveAction<infer Type extends TSchema> ? TModifierActions<Type, Readonly, 'remove'> : Type extends TReadonlyAddAction<infer Type extends TSchema> ? TModifierActions<Type, 'add', Optional> : Type extends TOptionalAddAction<infer Type extends TSchema> ? TModifierActions<Type, Readonly, 'add'> : [
+    Type,
+    Readonly,
+    Optional
+]);
+type TApplyReadonly<Action extends ModifierAction, Type extends TSchema> = (Action extends 'remove' ? TReadonlyRemove<Type> : Action extends 'add' ? TReadonlyAdd<Type> : Type);
+type TApplyOptional<Action extends ModifierAction, Type extends TSchema> = (Action extends 'remove' ? TOptionalRemove<Type> : Action extends 'add' ? TOptionalAdd<Type> : Type);
+export type TInstantiateProperties<Context extends TProperties, State extends TState, Properties extends TProperties, Result extends TProperties = {
+    [Key in keyof Properties]: TInstantiateType<Context, State, Properties[Key]>;
+}> = Result;
+export declare function InstantiateProperties<Context extends TProperties, State extends TState, Properties extends TProperties>(context: Context, state: State, properties: TProperties): TInstantiateProperties<Context, State, Properties>;
+export type TInstantiateElements<Context extends TProperties, State extends TState, Types extends TSchema[], Elements extends TSchema[] = TInstantiateTypes<Context, State, Types>, Result extends TSchema[] = TRestSpread<Elements>> = Result;
+export declare function InstantiateElements<Context extends TProperties, State extends TState, Types extends TSchema[]>(context: Context, state: State, types: [...Types]): TInstantiateElements<Context, State, Types>;
+export type TInstantiateTypes<Context extends TProperties, State extends TState, Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TInstantiateTypes<Context, State, Right, [...Result, TInstantiateType<Context, State, Left>]> : Result);
+export declare function InstantiateTypes<Context extends TProperties, State extends TState, Types extends TSchema[]>(context: Context, state: State, types: [...Types]): TInstantiateTypes<Context, State, Types>;
+type TInstantiateDeferred<Context extends TProperties, State extends TState, Action extends string, Parameters extends TSchema[]> = ([
+    Action,
+    Parameters
+] extends ['Awaited', [infer Type extends TSchema]] ? TAwaitedInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['Capitalize', [infer Type extends TSchema]] ? TCapitalizeInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['Conditional', [infer Left extends TSchema, infer Right extends TSchema, infer True extends TSchema, infer False extends TSchema]] ? TConditionalInstantiate<Context, State, Left, Right, True, False> : [
+    Action,
+    Parameters
+] extends ['ConstructorParameters', [infer Type extends TSchema]] ? TConstructorParametersInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['Evaluate', [infer Type extends TSchema]] ? TEvaluateInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['Exclude', [infer Left extends TSchema, infer Right extends TSchema]] ? TExcludeInstantiate<Context, State, Left, Right> : [
+    Action,
+    Parameters
+] extends ['Extract', [infer Left extends TSchema, infer Right extends TSchema]] ? TExtractInstantiate<Context, State, Left, Right> : [
+    Action,
+    Parameters
+] extends ['Index', [infer Type extends TSchema, infer Indexer extends TSchema]] ? TIndexInstantiate<Context, State, Type, Indexer> : [
+    Action,
+    Parameters
+] extends ['InstanceType', [infer Type extends TSchema]] ? TInstanceTypeInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['Interface', [infer Heritage extends TSchema[], infer Properties extends TProperties]] ? TInterfaceInstantiate<Context, State, Heritage, Properties> : [
+    Action,
+    Parameters
+] extends ['KeyOf', [infer Type extends TSchema]] ? TKeyOfInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['Lowercase', [infer Type extends TSchema]] ? TLowercaseInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['Mapped', [infer Name extends TIdentifier, infer Key extends TSchema, infer As extends TSchema, infer Property extends TSchema]] ? TMappedInstantiate<Context, State, Name, Key, As, Property> : [
+    Action,
+    Parameters
+] extends ['Module', [infer Properties extends TProperties]] ? TModuleInstantiate<Context, State, Properties> : [
+    Action,
+    Parameters
+] extends ['NonNullable', [infer Type extends TSchema]] ? TNonNullableInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['Pick', [infer Type extends TSchema, infer Indexer extends TSchema]] ? TPickInstantiate<Context, State, Type, Indexer> : [
+    Action,
+    Parameters
+] extends ['Options', [infer Type extends TSchema, infer Options extends TSchema]] ? TOptionsInstantiate<Context, State, Type, Options> : [
+    Action,
+    Parameters
+] extends ['Parameters', [infer Type extends TSchema]] ? TParametersInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['Partial', [infer Type extends TSchema]] ? TPartialInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['Omit', [infer Type extends TSchema, infer Indexer extends TSchema]] ? TOmitInstantiate<Context, State, Type, Indexer> : [
+    Action,
+    Parameters
+] extends ['Record', [infer Key extends TSchema, infer Value extends TSchema]] ? TRecordInstantiate<Context, State, Key, Value> : [
+    Action,
+    Parameters
+] extends ['Required', [infer Type extends TSchema]] ? TRequiredInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['ReturnType', [infer Type extends TSchema]] ? TReturnTypeInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['TemplateLiteral', [infer Types extends TSchema[]]] ? TTemplateLiteralInstantiate<Context, State, Types> : [
+    Action,
+    Parameters
+] extends ['Uncapitalize', [infer Type extends TSchema]] ? TUncapitalizeInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['Uppercase', [infer Type extends TSchema]] ? TUppercaseInstantiate<Context, State, Type> : TDeferred<Action, Parameters>);
+export type TInstantiateType<Context extends TProperties, State extends TState, Input extends TSchema, ModifierState extends [TSchema, ModifierAction, ModifierAction] = TModifierActions<Input, Input extends TReadonly<Input> ? 'add' : 'none', Input extends TOptional<Input> ? 'add' : 'none'>, Type extends TSchema = ModifierState[0], Instantiated extends TSchema = (Type extends TRef<infer Ref extends string> ? TRefInstantiate<Context, State, Ref> : Type extends TArray<infer Type extends TSchema> ? TArray<TInstantiateType<Context, State, Type>> : Type extends TAsyncIterator<infer Type extends TSchema> ? TAsyncIterator<TInstantiateType<Context, State, Type>> : Type extends TCall<infer Target extends TSchema, infer Parameters extends TSchema[]> ? TCallInstantiate<Context, State, Target, Parameters> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TConstructor<TInstantiateTypes<Context, State, Parameters>, TInstantiateType<Context, State, InstanceType>> : Type extends TDeferred<infer Action extends string, infer Types extends TSchema[]> ? TInstantiateDeferred<Context, State, Action, Types> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFunction<TInstantiateTypes<Context, State, Parameters>, TInstantiateType<Context, State, ReturnType>> : Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TInstantiateTypes<Context, State, Types>> : Type extends TIterator<infer Type extends TSchema> ? TIterator<TInstantiateType<Context, State, Type>> : Type extends TObject<infer Properties extends TProperties> ? TObject<TInstantiateProperties<Context, State, Properties>> : Type extends TPromise<infer Type extends TSchema> ? TPromise<TInstantiateType<Context, State, Type>> : Type extends TRecord<infer Key extends string, infer Type extends TSchema> ? TRecord<Key, TInstantiateType<Context, State, Type>> : Type extends TRest<infer Type extends TSchema> ? TRest<TInstantiateType<Context, State, Type>> : Type extends TTuple<infer Types extends TSchema[]> ? TTuple<TInstantiateElements<Context, State, Types>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TInstantiateTypes<Context, State, Types>> : Type)> = TApplyReadonly<ModifierState[1], TApplyOptional<ModifierState[2], Instantiated>>;
+export declare function InstantiateType<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, input: Type): TInstantiateType<Context, State, Type>;
+/** Instantiates computed schematics using the given context and type. */
+export type TInstantiate<Context extends TProperties, Type extends TSchema> = (TInstantiateType<Context, {
+    callstack: [];
+}, Type>);
+/** Instantiates computed schematics using the given context and type. */
+export declare function Instantiate<Context extends TProperties, Type extends TSchema>(context: Context, type: Type): TInstantiate<Context, Type>;
+export {};

package/build/type/engine/instantiate.mjs

@@ -0,0 +1,165 @@
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+import { Guard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Modifiers
+// ------------------------------------------------------------------
+import { IsOptional, OptionalAdd, OptionalRemove } from '../types/_optional.mjs';
+import { IsReadonly, ReadonlyAdd, ReadonlyRemove } from '../types/_readonly.mjs';
+// ------------------------------------------------------------------
+// Types
+// ------------------------------------------------------------------
+import { IsSchema } from '../types/schema.mjs';
+import { Array, IsArray, ArrayOptions } from '../types/array.mjs';
+import { AsyncIterator, IsAsyncIterator, AsyncIteratorOptions } from '../types/async-iterator.mjs';
+import { Constructor, IsConstructor, ConstructorOptions } from '../types/constructor.mjs';
+import { Deferred, IsDeferred } from '../types/deferred.mjs';
+import { Function, IsFunction, FunctionOptions } from '../types/function.mjs';
+import { IsCall } from '../types/call.mjs';
+import { Intersect, IsIntersect, IntersectOptions } from '../types/intersect.mjs';
+import { Iterator, IsIterator, IteratorOptions } from '../types/iterator.mjs';
+import { Object, IsObject, ObjectOptions } from '../types/object.mjs';
+import { Promise, IsPromise, PromiseOptions } from '../types/promise.mjs';
+import { RecordFromPattern, IsRecord, RecordPattern, RecordValue } from '../types/record.mjs';
+import { Tuple, IsTuple, TupleOptions } from '../types/tuple.mjs';
+import { Union, IsUnion, UnionOptions } from '../types/union.mjs';
+import { IsRef } from '../types/ref.mjs';
+import { Rest, IsRest } from '../types/rest.mjs';
+// ------------------------------------------------------------------
+// Modifier Actions
+// ------------------------------------------------------------------
+import { IsReadonlyAddAction, IsReadonlyRemoveAction } from '../action/_readonly.mjs';
+import { IsOptionalAddAction, IsOptionalRemoveAction } from '../action/_optional.mjs';
+// ------------------------------------------------------------------
+// Instantiate
+// ------------------------------------------------------------------
+import { AwaitedInstantiate } from './awaited/instantiate.mjs';
+import { CallInstantiate } from './call/instantiate.mjs';
+import { CapitalizeInstantiate } from './intrinsics/instantiate.mjs';
+import { ConditionalInstantiate } from './conditional/index.mjs';
+import { ConstructorParametersInstantiate } from './constructor-parameters/instantiate.mjs';
+import { EvaluateInstantiate } from './evaluate/instantiate.mjs';
+import { ExcludeInstantiate } from './exclude/instantiate.mjs';
+import { ExtractInstantiate } from './extract/instantiate.mjs';
+import { IndexInstantiate } from './indexed/instantiate.mjs';
+import { InstanceTypeInstantiate } from './instance-type/instantiate.mjs';
+import { InterfaceInstantiate } from './interface/instantiate.mjs';
+import { KeyOfInstantiate } from './keyof/instantiate.mjs';
+import { LowercaseInstantiate } from './intrinsics/instantiate.mjs';
+import { MappedInstantiate } from './mapped/instantiate.mjs';
+import { ModuleInstantiate } from './module/instantiate.mjs';
+import { NonNullableInstantiate } from './non-nullable/instantiate.mjs';
+import { OmitInstantiate } from './omit/instantiate.mjs';
+import { OptionsInstantiate } from './options/instantiate.mjs';
+import { ParametersInstantiate } from './parameters/instantiate.mjs';
+import { PartialInstantiate } from './partial/instantiate.mjs';
+import { PickInstantiate } from './pick/instantiate.mjs';
+import { RecordInstantiate } from './record/instantiate.mjs';
+import { RefInstantiate } from './ref/instantiate.mjs';
+import { RequiredInstantiate } from './required/instantiate.mjs';
+import { ReturnTypeInstantiate } from './return-type/instantiate.mjs';
+import { TemplateLiteralInstantiate } from './template-literal/instantiate.mjs';
+import { UncapitalizeInstantiate } from './intrinsics/instantiate.mjs';
+import { UppercaseInstantiate } from './intrinsics/instantiate.mjs';
+import { RestSpread } from './rest/index.mjs';
+function CanInstantiateRef(context, ref) {
+    return (ref in context);
+}
+function CanInstantiateType(context, type) {
+    return (IsIntersect(type) ? CanInstantiate(context, type.allOf) :
+        IsUnion(type) ? CanInstantiate(context, type.anyOf) :
+            IsRef(type) ? CanInstantiateRef(context, type.$ref) :
+                true);
+}
+export function CanInstantiate(context, types) {
+    const [left, ...right] = types;
+    return (IsSchema(left)
+        ? CanInstantiateType(context, left)
+            ? CanInstantiate(context, right)
+            : false
+        : true);
+}
+function ModifierActions(type, readonly, optional) {
+    return (IsReadonlyRemoveAction(type) ? ModifierActions(type.type, 'remove', optional) :
+        IsOptionalRemoveAction(type) ? ModifierActions(type.type, readonly, 'remove') :
+            IsReadonlyAddAction(type) ? ModifierActions(type.type, 'add', optional) :
+                IsOptionalAddAction(type) ? ModifierActions(type.type, readonly, 'add') :
+                    [type, readonly, optional]);
+}
+function ApplyReadonly(action, type) {
+    return (Guard.IsEqual(action, 'remove') ? ReadonlyRemove(type) :
+        Guard.IsEqual(action, 'add') ? ReadonlyAdd(type) :
+            type);
+}
+function ApplyOptional(action, type) {
+    return (Guard.IsEqual(action, 'remove') ? OptionalRemove(type) :
+        Guard.IsEqual(action, 'add') ? OptionalAdd(type) :
+            type);
+}
+export function InstantiateProperties(context, state, properties) {
+    return Guard.Keys(properties).reduce((result, key) => {
+        return { ...result, [key]: InstantiateType(context, state, properties[key]) };
+    }, {});
+}
+export function InstantiateElements(context, state, types) {
+    const elements = InstantiateTypes(context, state, types);
+    const result = RestSpread(elements);
+    return result;
+}
+export function InstantiateTypes(context, state, types) {
+    return types.map(type => InstantiateType(context, state, type));
+}
+function InstantiateDeferred(context, state, action, parameters, options) {
+    return (Guard.IsEqual(action, 'Awaited') ? AwaitedInstantiate(context, state, parameters[0], options) :
+        Guard.IsEqual(action, 'Capitalize') ? CapitalizeInstantiate(context, state, parameters[0], options) :
+            Guard.IsEqual(action, 'Conditional') ? ConditionalInstantiate(context, state, parameters[0], parameters[1], parameters[2], parameters[3], options) :
+                Guard.IsEqual(action, 'ConstructorParameters') ? ConstructorParametersInstantiate(context, state, parameters[0], options) :
+                    Guard.IsEqual(action, 'Evaluate') ? EvaluateInstantiate(context, state, parameters[0], options) :
+                        Guard.IsEqual(action, 'Exclude') ? ExcludeInstantiate(context, state, parameters[0], parameters[1], options) :
+                            Guard.IsEqual(action, 'Extract') ? ExtractInstantiate(context, state, parameters[0], parameters[1], options) :
+                                Guard.IsEqual(action, 'Index') ? IndexInstantiate(context, state, parameters[0], parameters[1], options) :
+                                    Guard.IsEqual(action, 'InstanceType') ? InstanceTypeInstantiate(context, state, parameters[0], options) :
+                                        Guard.IsEqual(action, 'Interface') ? InterfaceInstantiate(context, state, parameters[0], parameters[1], options) :
+                                            Guard.IsEqual(action, 'KeyOf') ? KeyOfInstantiate(context, state, parameters[0], options) :
+                                                Guard.IsEqual(action, 'Lowercase') ? LowercaseInstantiate(context, state, parameters[0], options) :
+                                                    Guard.IsEqual(action, 'Mapped') ? MappedInstantiate(context, state, parameters[0], parameters[1], parameters[2], parameters[3], options) :
+                                                        Guard.IsEqual(action, 'Module') ? ModuleInstantiate(context, state, parameters[0], options) :
+                                                            Guard.IsEqual(action, 'NonNullable') ? NonNullableInstantiate(context, state, parameters[0], options) :
+                                                                Guard.IsEqual(action, 'Pick') ? PickInstantiate(context, state, parameters[0], parameters[1], options) :
+                                                                    Guard.IsEqual(action, 'Options') ? OptionsInstantiate(context, state, parameters[0], parameters[1]) :
+                                                                        Guard.IsEqual(action, 'Parameters') ? ParametersInstantiate(context, state, parameters[0], options) :
+                                                                            Guard.IsEqual(action, 'Partial') ? PartialInstantiate(context, state, parameters[0], options) :
+                                                                                Guard.IsEqual(action, 'Omit') ? OmitInstantiate(context, state, parameters[0], parameters[1], options) :
+                                                                                    Guard.IsEqual(action, 'Record') ? RecordInstantiate(context, state, parameters[0], parameters[1], options) :
+                                                                                        Guard.IsEqual(action, 'Required') ? RequiredInstantiate(context, state, parameters[0], options) :
+                                                                                            Guard.IsEqual(action, 'ReturnType') ? ReturnTypeInstantiate(context, state, parameters[0], options) :
+                                                                                                Guard.IsEqual(action, 'TemplateLiteral') ? TemplateLiteralInstantiate(context, state, parameters[0], options) :
+                                                                                                    Guard.IsEqual(action, 'Uncapitalize') ? UncapitalizeInstantiate(context, state, parameters[0], options) :
+                                                                                                        Guard.IsEqual(action, 'Uppercase') ? UppercaseInstantiate(context, state, parameters[0], options) :
+                                                                                                            Deferred(action, parameters, options));
+}
+export function InstantiateType(context, state, input) {
+    const modifierActions = ModifierActions(input, IsReadonly(input) ? 'add' : 'none', IsOptional(input) ? 'add' : 'none');
+    const type = modifierActions[0];
+    const instantiated = (IsRef(type) ? RefInstantiate(context, state, type.$ref) :
+        IsArray(type) ? Array(InstantiateType(context, state, type.items), ArrayOptions(type)) :
+            IsAsyncIterator(type) ? AsyncIterator(InstantiateType(context, state, type.iteratorItems), AsyncIteratorOptions(type)) :
+                IsCall(type) ? CallInstantiate(context, state, type.target, type.arguments) :
+                    IsConstructor(type) ? Constructor(InstantiateTypes(context, state, type.parameters), InstantiateType(context, state, type.instanceType), ConstructorOptions(type)) :
+                        IsDeferred(type) ? InstantiateDeferred(context, state, type.action, type.parameters, type.options) :
+                            IsFunction(type) ? Function(InstantiateTypes(context, state, type.parameters), InstantiateType(context, state, type.returnType), FunctionOptions(type)) :
+                                IsIntersect(type) ? Intersect(InstantiateTypes(context, state, type.allOf), IntersectOptions(type)) :
+                                    IsIterator(type) ? Iterator(InstantiateType(context, state, type.iteratorItems), IteratorOptions(type)) :
+                                        IsObject(type) ? Object(InstantiateProperties(context, state, type.properties), ObjectOptions(type)) :
+                                            IsPromise(type) ? Promise(InstantiateType(context, state, type.item), PromiseOptions(type)) :
+                                                IsRecord(type) ? RecordFromPattern(RecordPattern(type), InstantiateType(context, state, RecordValue(type))) :
+                                                    IsRest(type) ? Rest(InstantiateType(context, state, type.items)) :
+                                                        IsTuple(type) ? Tuple(InstantiateElements(context, state, type.items), TupleOptions(type)) :
+                                                            IsUnion(type) ? Union(InstantiateTypes(context, state, type.anyOf), UnionOptions(type)) :
+                                                                type);
+    return ApplyReadonly(modifierActions[1], ApplyOptional(modifierActions[2], instantiated));
+}
+/** Instantiates computed schematics using the given context and type. */
+export function Instantiate(context, type) {
+    return InstantiateType(context, { callstack: [] }, type);
+}

package/build/type/engine/interface/index.d.mts

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

package/build/type/engine/interface/index.mjs

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

package/build/type/engine/interface/instantiate.d.mts

@@ -0,0 +1,16 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TEvaluateIntersect } from '../evaluate/evaluate.mjs';
+import { type TInterfaceDeferred } from '../../action/index.mjs';
+import { type TState, type TCanInstantiate } from '../instantiate.mjs';
+import { type TInstantiateProperties } from '../instantiate.mjs';
+import { type TInstantiateTypes } from '../instantiate.mjs';
+type TInterfaceImmediate<Context extends TProperties, State extends TState, Heritage extends TSchema[], Properties extends TProperties, InstantiatedHeritage extends TSchema[] = TInstantiateTypes<Context, {
+    callstack: [];
+}, Heritage>, instantiatedProperties extends TProperties = TInstantiateProperties<Context, {
+    callstack: [];
+}, Properties>, EvaluatedInterface extends TSchema = TEvaluateIntersect<[...InstantiatedHeritage, TObject<instantiatedProperties>]>> = EvaluatedInterface;
+export type TInterfaceInstantiate<Context extends TProperties, State extends TState, Heritage extends TSchema[], Properties extends TProperties> = TCanInstantiate<Context, Heritage> extends true ? TInterfaceImmediate<Context, State, Heritage, Properties> : TInterfaceDeferred<Heritage, Properties>;
+export declare function InterfaceInstantiate<Context extends TProperties, State extends TState, Heritage extends TSchema[], Properties extends TProperties>(context: Context, state: State, heritage: [...Heritage], properties: Properties, options: TSchemaOptions): TInterfaceInstantiate<Context, State, Heritage, Properties>;
+export {};

package/build/type/engine/interface/instantiate.mjs

@@ -0,0 +1,19 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../../system/memory/index.mjs';
+import { Object } from '../../types/object.mjs';
+import { EvaluateIntersect } from '../evaluate/evaluate.mjs';
+import { InterfaceDeferred } from '../../action/index.mjs';
+import { CanInstantiate } from '../instantiate.mjs';
+import { InstantiateProperties } from '../instantiate.mjs';
+import { InstantiateTypes } from '../instantiate.mjs';
+function InterfaceImmediate(context, state, heritage, properties, options) {
+    const instantiatedHeritage = InstantiateTypes(context, { callstack: [] }, heritage);
+    const instantiatedProperties = InstantiateProperties(context, { callstack: [] }, properties);
+    const evaluatedInterface = EvaluateIntersect([...instantiatedHeritage, Object(instantiatedProperties)]);
+    return Memory.Update(evaluatedInterface, {}, options);
+}
+export function InterfaceInstantiate(context, state, heritage, properties, options) {
+    return (CanInstantiate(context, heritage)
+        ? InterfaceImmediate(context, state, heritage, properties, options)
+        : InterfaceDeferred(heritage, properties, options));
+}

package/build/type/engine/intrinsics/from-literal.d.mts

@@ -0,0 +1,5 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TLiteral, type TLiteralValue } from '../../types/literal.mjs';
+import { type TMappingType, type TMappingFunc, type TApplyMapping } from './mapping.mjs';
+export type TFromLiteral<Mapping extends TMappingType, Value extends TLiteralValue> = (Value extends string ? TLiteral<TApplyMapping<Mapping, Value>> : TLiteral<Value>);
+export declare function FromLiteral(mapping: TMappingFunc, value: TLiteralValue): TSchema;

package/build/type/engine/intrinsics/from-literal.mjs

@@ -0,0 +1,9 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
+import { Literal } from '../../types/literal.mjs';
+import { ApplyMapping } from './mapping.mjs';
+export function FromLiteral(mapping, value) {
+    return (Guard.IsString(value)
+        ? Literal(ApplyMapping(mapping, value))
+        : Literal(value));
+}