@depup/typebox 1.1.23-depup.0 → 1.3.8-depup.0

package/build/type/engine/instantiate.mjs

@@ -4,100 +4,73 @@ import { Guard } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Modifiers
 // ------------------------------------------------------------------
-import { IsImmutable, Immutable } from '../types/_immutable.mjs';
-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 { IsBase } from '../types/base.mjs';
+import { AddImmutableAction } from './immutable/instantiate_add.mjs';
+import { AddReadonlyAction } from './readonly/instantiate_add.mjs';
+import { AddOptionalAction } from './optional/instantiate_add.mjs';
+import { _Array_, IsArray, ArrayOptions } from '../types/array.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 { Dependent, IsDependent, DependentOptions } from '../types/dependent.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
+// Modifier Instantiate
 // ------------------------------------------------------------------
-import { IsReadonlyAddAction, IsReadonlyRemoveAction } from '../action/_readonly.mjs';
-import { IsOptionalAddAction, IsOptionalRemoveAction } from '../action/_optional.mjs';
+import { AddImmutableInstantiate } from './immutable/instantiate_add.mjs';
+import { RemoveImmutableInstantiate } from './immutable/instantiate_remove.mjs';
+import { AddReadonlyInstantiate } from './readonly/instantiate_add.mjs';
+import { RemoveReadonlyInstantiate } from './readonly/instantiate_remove.mjs';
+import { AddOptionalInstantiate } from './optional/instantiate_add.mjs';
+import { RemoveOptionalInstantiate } from './optional/instantiate_remove.mjs';
+import { IsOptional } from '../types/_optional.mjs';
+import { IsImmutable } from '../types/_immutable.mjs';
+import { IsReadonly } from '../types/_readonly.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 { 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 { 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 { 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 { ReadonlyTypeInstantiate } from './readonly-type/instantiate.mjs';
+import { ReadonlyObjectInstantiate } from './readonly_object/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 { 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 { WithInstantiate } from './with/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]);
+export function State(callstack, visited) {
+    return { callstack, visited };
 }
-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 CanInstantiate(types) {
+    return Guard.ShiftLeft(types, (left, right) => IsRef(left)
+        ? false
+        : CanInstantiate(right), () => true);
 }
 export function InstantiateProperties(context, state, properties) {
     return Guard.Keys(properties).reduce((result, key) => {
@@ -112,61 +85,74 @@ export function InstantiateElements(context, state, types) {
 export function InstantiateTypes(context, state, types) {
     return types.map(type => InstantiateType(context, state, type));
 }
+function WithModifiers(type, instantiatedType) {
+    const withOptional = IsOptional(type) ? AddOptionalAction(instantiatedType, {}) : instantiatedType;
+    const withReadonly = IsReadonly(type) ? AddReadonlyAction(withOptional, {}) : withOptional;
+    const withImmutable = IsImmutable(type) ? AddImmutableAction(withReadonly, {}) : withReadonly;
+    return withImmutable;
+}
 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, 'ReadonlyType') ? ReadonlyTypeInstantiate(context, state, parameters[0], 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));
+    return (
+    // Modifiers
+    Guard.IsEqual(action, 'AddImmutable') ? AddImmutableInstantiate(context, state, parameters[0], options) :
+        Guard.IsEqual(action, 'RemoveImmutable') ? RemoveImmutableInstantiate(context, state, parameters[0], options) :
+            Guard.IsEqual(action, 'AddReadonly') ? AddReadonlyInstantiate(context, state, parameters[0], options) :
+                Guard.IsEqual(action, 'RemoveReadonly') ? RemoveReadonlyInstantiate(context, state, parameters[0], options) :
+                    Guard.IsEqual(action, 'AddOptional') ? AddOptionalInstantiate(context, state, parameters[0], options) :
+                        Guard.IsEqual(action, 'RemoveOptional') ? RemoveOptionalInstantiate(context, state, parameters[0], options) :
+                            // Actions
+                            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, '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, 'ReadonlyObject') ? ReadonlyObjectInstantiate(context, state, parameters[0], 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) :
+                                                                                                                                Guard.IsEqual(action, 'With') ? WithInstantiate(context, state, parameters[0], parameters[1]) :
+                                                                                                                                    Deferred(action, parameters, options));
 }
-export function InstantiateType(context, state, input) {
-    const immutable = IsImmutable(input);
-    const modifiers = ModifierActions(input, IsReadonly(input) ? 'add' : 'none', IsOptional(input) ? 'add' : 'none');
-    const type = IsBase(modifiers[0]) ? modifiers[0].Clone() : modifiers[0];
-    const instantiated = (IsRef(type) ? RefInstantiate(context, state, type, 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);
-    const withImmutable = immutable ? Immutable(instantiated) : instantiated;
-    const withModifiers = ApplyReadonly(modifiers[1], ApplyOptional(modifiers[2], withImmutable));
+function InstantiateImmediate(context, state, type) {
+    const instantiatedType = (IsRef(type) ? RefInstantiate(context, state, type, type.$ref) :
+        IsArray(type) ? _Array_(InstantiateType(context, state, type.items), ArrayOptions(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)) :
+                    IsFunction(type) ? _Function_(InstantiateTypes(context, state, type.parameters), InstantiateType(context, state, type.returnType), FunctionOptions(type)) :
+                        IsDependent(type) ? Dependent(InstantiateType(context, state, type.if), InstantiateType(context, state, type.then), InstantiateType(context, state, type.else), DependentOptions(type)) :
+                            IsIntersect(type) ? Intersect(InstantiateTypes(context, state, type.allOf), IntersectOptions(type)) :
+                                IsObject(type) ? Object(InstantiateProperties(context, state, type.properties), ObjectOptions(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);
+    const withModifiers = WithModifiers(type, instantiatedType);
     return withModifiers;
 }
+export function InstantiateType(context, state, type) {
+    const result = IsDeferred(type)
+        ? InstantiateDeferred(context, state, type.action, type.parameters, type.options)
+        : InstantiateImmediate(context, state, type);
+    return result;
+}
 /** Instantiates computed schematics using the given context and type. */
 export function Instantiate(context, type) {
-    return InstantiateType(context, { callstack: [] }, type);
+    return InstantiateType(context, State([], []), type);
 }

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

@@ -3,14 +3,13 @@ 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 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>;
+import { type TState } from '../instantiate.mjs';
+type TInterfaceOperation<Heritage extends TSchema[], Properties extends TProperties, Result extends TSchema = TEvaluateIntersect<[...Heritage, TObject<Properties>]>> = Result;
+export type TInterfaceAction<Heritage extends TSchema[], Properties extends TProperties, Result extends TSchema = TCanInstantiate<Heritage> extends true ? TInterfaceOperation<Heritage, Properties> : TInterfaceDeferred<Heritage, Properties>> = Result;
+export declare function InterfaceAction<Heritage extends TSchema[], Properties extends TProperties>(heritage: [...Heritage], properties: Properties, options: TSchemaOptions): TInterfaceAction<Heritage, Properties>;
+export type TInterfaceInstantiate<Context extends TProperties, State extends TState, Heritage extends TSchema[], Properties extends TProperties, InstantiatedHeritage extends TSchema[] = TInstantiateTypes<Context, State, Heritage>, InstantiatedProperties extends TProperties = TInstantiateProperties<Context, State, Properties>> = TInterfaceAction<InstantiatedHeritage, InstantiatedProperties>;
 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

@@ -6,14 +6,18 @@ 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);
+function InterfaceOperation(heritage, properties) {
+    const result = EvaluateIntersect([...heritage, Object(properties)]);
+    return result;
+}
+export function InterfaceAction(heritage, properties, options) {
+    const result = CanInstantiate(heritage)
+        ? Memory.Update(InterfaceOperation(heritage, properties), {}, options)
+        : InterfaceDeferred(heritage, properties, options);
+    return result;
 }
 export function InterfaceInstantiate(context, state, heritage, properties, options) {
-    return (CanInstantiate(context, heritage)
-        ? InterfaceImmediate(context, state, heritage, properties, options)
-        : InterfaceDeferred(heritage, properties, options));
+    const instantiatedHeritage = InstantiateTypes(context, state, heritage);
+    const instantiatedProperties = InstantiateProperties(context, state, properties);
+    return InterfaceAction(instantiatedHeritage, instantiatedProperties, options);
 }

package/build/type/engine/intrinsics/{from-template-literal.d.mts → from_template_literal.d.mts}

@@ -1,6 +1,6 @@
 import { type TSchema } from '../../types/schema.mjs';
 import { type TMappingType, type TMappingFunc } from './mapping.mjs';
-import { type TTemplateLiteralDecode } from '../template-literal/decode.mjs';
-import { type TFromType } from './from-type.mjs';
-export type TFromTemplateLiteral<Mapping extends TMappingType, Pattern extends string, Decoded extends TSchema = TTemplateLiteralDecode<Pattern>, Result extends TSchema = TFromType<Mapping, Decoded>> = Result;
+import { type TFromType } from './from_type.mjs';
+import { type TEvaluateTemplateLiteral } from '../evaluate/index.mjs';
+export type TFromTemplateLiteral<Mapping extends TMappingType, Pattern extends string, Evaluated extends TSchema = TEvaluateTemplateLiteral<Pattern>, Result extends TSchema = TFromType<Mapping, Evaluated>> = Result;
 export declare function FromTemplateLiteral(mapping: TMappingFunc, pattern: string): TSchema;

package/build/type/engine/intrinsics/from_template_literal.mjs

@@ -0,0 +1,8 @@
+// deno-fmt-ignore-file
+import { FromType } from './from_type.mjs';
+import { EvaluateTemplateLiteral } from '../evaluate/index.mjs';
+export function FromTemplateLiteral(mapping, pattern) {
+    const evaluated = EvaluateTemplateLiteral(pattern);
+    const result = FromType(mapping, evaluated);
+    return result;
+}

package/build/type/engine/intrinsics/{from-type.d.mts → from_type.d.mts}

@@ -1,10 +1,10 @@
 import { type TSchema } from '../../types/schema.mjs';
 import { type TLiteral, type TLiteralValue } from '../../types/literal.mjs';
-import { type TTemplateLiteral } from '../../types/template-literal.mjs';
+import { type TTemplateLiteral } from '../../types/template_literal.mjs';
 import { type TUnion } from '../../types/union.mjs';
 import { type TMappingType, type TMappingFunc } from './mapping.mjs';
-import { type TFromLiteral } from './from-literal.mjs';
-import { type TFromTemplateLiteral } from './from-template-literal.mjs';
-import { type TFromUnion } from './from-union.mjs';
+import { type TFromLiteral } from './from_literal.mjs';
+import { type TFromTemplateLiteral } from './from_template_literal.mjs';
+import { type TFromUnion } from './from_union.mjs';
 export type TFromType<Mapping extends TMappingType, Type extends TSchema> = (Type extends TLiteral<infer Value extends TLiteralValue> ? TFromLiteral<Mapping, Value> : Type extends TTemplateLiteral<infer Pattern extends string> ? TFromTemplateLiteral<Mapping, Pattern> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Mapping, Types> : Type);
 export declare function FromType(mapping: TMappingFunc, type: TSchema): TSchema;

package/build/type/engine/intrinsics/{from-type.mjs → from_type.mjs}

@@ -1,10 +1,10 @@
 // deno-fmt-ignore-file
 import { IsLiteral } from '../../types/literal.mjs';
-import { IsTemplateLiteral } from '../../types/template-literal.mjs';
+import { IsTemplateLiteral } from '../../types/template_literal.mjs';
 import { IsUnion } from '../../types/union.mjs';
-import { FromLiteral } from './from-literal.mjs';
-import { FromTemplateLiteral } from './from-template-literal.mjs';
-import { FromUnion } from './from-union.mjs';
+import { FromLiteral } from './from_literal.mjs';
+import { FromTemplateLiteral } from './from_template_literal.mjs';
+import { FromUnion } from './from_union.mjs';
 export function FromType(mapping, type) {
     return (IsLiteral(type) ? FromLiteral(mapping, type.const) :
         IsTemplateLiteral(type) ? FromTemplateLiteral(mapping, type.pattern) :

package/build/type/engine/intrinsics/{from-union.d.mts → from_union.d.mts}

@@ -1,6 +1,6 @@
 import { type TSchema } from '../../types/schema.mjs';
 import { type TUnion } from '../../types/union.mjs';
 import { type TMappingType, type TMappingFunc } from './mapping.mjs';
-import { type TFromType } from './from-type.mjs';
+import { type TFromType } from './from_type.mjs';
 export type TFromUnion<Mapping extends TMappingType, Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromUnion<Mapping, Right, [...Result, TFromType<Mapping, Left>]> : TUnion<Result>);
 export declare function FromUnion(mapping: TMappingFunc, types: TSchema[]): TSchema;

package/build/type/engine/intrinsics/{from-union.mjs → from_union.mjs}

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { Union } from '../../types/union.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 export function FromUnion(mapping, types) {
     const result = types.map(type => FromType(mapping, type));
     return Union(result);

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

@@ -1,7 +1,7 @@
 import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 import { type TMappingType } from './mapping.mjs';
-import { type TFromType } from './from-type.mjs';
+import { type TFromType } from './from_type.mjs';
 import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
 import { type TCapitalizeDeferred } from '../../action/capitalize.mjs';
 import { type TLowercaseDeferred } from '../../action/lowercase.mjs';
@@ -19,16 +19,20 @@ interface TUncapitalizeMapping extends TMappingType {
 interface TUppercaseMapping extends TMappingType {
     output: Uppercase<this['input']>;
 }
-type TCapitalizeImmediate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TFromType<TCapitalizeMapping, InstantiatedType>;
-export type TCapitalizeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema> = TCanInstantiate<Context, [Type]> extends true ? TCapitalizeImmediate<Context, State, Type> : TCapitalizeDeferred<Type>;
+export type TCapitalizeAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TFromType<TCapitalizeMapping, Type> : TCapitalizeDeferred<Type>> = Result;
+export declare function CapitalizeAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TCapitalizeAction<Type>;
+export type TLowercaseAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TFromType<TLowercaseMapping, Type> : TLowercaseDeferred<Type>> = Result;
+export declare function LowercaseAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TLowercaseAction<Type>;
+export type TUncapitalizeAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TFromType<TUncapitalizeMapping, Type> : TUncapitalizeDeferred<Type>> = Result;
+export declare function UncapitalizeAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TUncapitalizeAction<Type>;
+export type TUppercaseAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TFromType<TUppercaseMapping, Type> : TUppercaseDeferred<Type>> = Result;
+export declare function UppercaseAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TUppercaseAction<Type>;
+export type TCapitalizeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TCapitalizeAction<InstantiatedType>;
 export declare function CapitalizeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TCapitalizeInstantiate<Context, State, Type>;
-type TLowercaseImmediate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TFromType<TLowercaseMapping, InstantiatedType>;
-export type TLowercaseInstantiate<Context extends TProperties, State extends TState, Type extends TSchema> = TCanInstantiate<Context, [Type]> extends true ? TLowercaseImmediate<Context, State, Type> : TLowercaseDeferred<Type>;
+export type TLowercaseInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TLowercaseAction<InstantiatedType>;
 export declare function LowercaseInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TLowercaseInstantiate<Context, State, Type>;
-type TUncapitalizeImmediate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TFromType<TUncapitalizeMapping, InstantiatedType>;
-export type TUncapitalizeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema> = TCanInstantiate<Context, [Type]> extends true ? TUncapitalizeImmediate<Context, State, Type> : TUncapitalizeDeferred<Type>;
+export type TUncapitalizeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TUncapitalizeAction<InstantiatedType>;
 export declare function UncapitalizeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TUncapitalizeInstantiate<Context, State, Type>;
-type TUppercaseImmediate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TFromType<TUppercaseMapping, InstantiatedType>;
-export type TUppercaseInstantiate<Context extends TProperties, State extends TState, Type extends TSchema> = TCanInstantiate<Context, [Type]> extends true ? TUppercaseImmediate<Context, State, Type> : TUppercaseDeferred<Type>;
+export type TUppercaseInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TUppercaseAction<InstantiatedType>;
 export declare function UppercaseInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TUppercaseInstantiate<Context, State, Type>;
 export {};

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

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { Memory } from '../../../system/memory/index.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
 import { CapitalizeDeferred } from '../../action/capitalize.mjs';
 import { LowercaseDeferred } from '../../action/lowercase.mjs';
@@ -10,39 +10,43 @@ const CapitalizeMapping = (input) => input[0].toUpperCase() + input.slice(1);
 const LowercaseMapping = (input) => input.toLowerCase();
 const UncapitalizeMapping = (input) => input[0].toLowerCase() + input.slice(1);
 const UppercaseMapping = (input) => input.toUpperCase();
-function CapitalizeImmediate(context, state, type, options) {
-    const instantiatedType = InstantiateType(context, state, type);
-    return Memory.Update(FromType(CapitalizeMapping, instantiatedType), {}, options);
+export function CapitalizeAction(type, options) {
+    const result = CanInstantiate([type])
+        ? Memory.Update(FromType(CapitalizeMapping, type), {}, options)
+        : CapitalizeDeferred(type, options);
+    return result;
+}
+export function LowercaseAction(type, options) {
+    const result = CanInstantiate([type])
+        ? Memory.Update(FromType(LowercaseMapping, type), {}, options)
+        : LowercaseDeferred(type, options);
+    return result;
+}
+export function UncapitalizeAction(type, options) {
+    const result = CanInstantiate([type])
+        ? Memory.Update(FromType(UncapitalizeMapping, type), {}, options)
+        : UncapitalizeDeferred(type, options);
+    return result;
+}
+export function UppercaseAction(type, options) {
+    const result = CanInstantiate([type])
+        ? Memory.Update(FromType(UppercaseMapping, type), {}, options)
+        : UppercaseDeferred(type, options);
+    return result;
 }
 export function CapitalizeInstantiate(context, state, type, options) {
-    return (CanInstantiate(context, [type])
-        ? CapitalizeImmediate(context, state, type, options)
-        : CapitalizeDeferred(type, options));
-}
-function LowercaseImmediate(context, state, type, options) {
     const instantiatedType = InstantiateType(context, state, type);
-    return Memory.Update(FromType(LowercaseMapping, instantiatedType), {}, options);
+    return CapitalizeAction(instantiatedType, options);
 }
 export function LowercaseInstantiate(context, state, type, options) {
-    return (CanInstantiate(context, [type])
-        ? LowercaseImmediate(context, state, type, options)
-        : LowercaseDeferred(type, options));
-}
-function UncapitalizeImmediate(context, state, type, options) {
     const instantiatedType = InstantiateType(context, state, type);
-    return Memory.Update(FromType(UncapitalizeMapping, instantiatedType), {}, options);
+    return LowercaseAction(instantiatedType, options);
 }
 export function UncapitalizeInstantiate(context, state, type, options) {
-    return (CanInstantiate(context, [type])
-        ? UncapitalizeImmediate(context, state, type, options)
-        : UncapitalizeDeferred(type, options));
-}
-function UppercaseImmediate(context, state, type, options) {
     const instantiatedType = InstantiateType(context, state, type);
-    return Memory.Update(FromType(UppercaseMapping, instantiatedType), {}, options);
+    return UncapitalizeAction(instantiatedType, options);
 }
 export function UppercaseInstantiate(context, state, type, options) {
-    return (CanInstantiate(context, [type])
-        ? UppercaseImmediate(context, state, type, options)
-        : UppercaseDeferred(type, options));
+    const instantiatedType = InstantiateType(context, state, type);
+    return UppercaseAction(instantiatedType, options);
 }

package/build/type/engine/keyof/from_type.d.mts

@@ -0,0 +1,15 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TAny } from '../../types/any.mjs';
+import { type TArray } from '../../types/array.mjs';
+import { type TNever } from '../../types/never.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TRecord } from '../../types/record.mjs';
+import { type TTuple } from '../../types/tuple.mjs';
+import { type TFromAny } from './from_any.mjs';
+import { type TFromArray } from './from_array.mjs';
+import { type TFromObject } from './from_object.mjs';
+import { type TFromRecord } from './from_record.mjs';
+import { type TFromTuple } from './from_tuple.mjs';
+export type TFromType<Type extends TSchema> = (Type extends TAny ? TFromAny : Type extends TArray<infer Type extends TSchema> ? TFromArray<Type> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<Properties> : Type extends TRecord ? TFromRecord<Type> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple<Types> : TNever);
+export declare function FromType<Type extends TSchema>(type: Type): TFromType<Type>;

package/build/type/engine/keyof/from_type.mjs

@@ -0,0 +1,23 @@
+// deno-fmt-ignore-file
+import { IsAny } from '../../types/any.mjs';
+import { IsArray } from '../../types/array.mjs';
+import { Never } from '../../types/never.mjs';
+import { IsObject } from '../../types/object.mjs';
+import { IsRecord } from '../../types/record.mjs';
+import { IsTuple } from '../../types/tuple.mjs';
+// ------------------------------------------------------------------
+// Computed
+// ------------------------------------------------------------------
+import { FromAny } from './from_any.mjs';
+import { FromArray } from './from_array.mjs';
+import { FromObject } from './from_object.mjs';
+import { FromRecord } from './from_record.mjs';
+import { FromTuple } from './from_tuple.mjs';
+export function FromType(type) {
+    return (IsAny(type) ? FromAny() :
+        IsArray(type) ? FromArray(type.items) :
+            IsObject(type) ? FromObject(type.properties) :
+                IsRecord(type) ? FromRecord(type) :
+                    IsTuple(type) ? FromTuple(type.items) :
+                        Never());
+}

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

@@ -1,27 +1,16 @@
 import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
 import { type TProperties } from '../../types/properties.mjs';
-import { type TAny } from '../../types/any.mjs';
-import { type TArray } from '../../types/array.mjs';
 import { type TCyclic } from '../../types/cyclic.mjs';
+import { type TDependent } from '../../types/dependent.mjs';
 import { type TIntersect } from '../../types/intersect.mjs';
-import { type TNever } from '../../types/never.mjs';
-import { type TObject } from '../../types/object.mjs';
-import { type TRecord } from '../../types/record.mjs';
-import { type TTuple } from '../../types/tuple.mjs';
 import { type TUnion } from '../../types/union.mjs';
 import { type TKeyOfDeferred } from '../../action/keyof.mjs';
 import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
 import { type TCollapseToObject } from '../object/index.mjs';
-import { type TFromAny } from './from-any.mjs';
-import { type TFromArray } from './from-array.mjs';
-import { type TFromObject } from './from-object.mjs';
-import { type TFromRecord } from './from-record.mjs';
-import { type TFromTuple } from './from-tuple.mjs';
-type TNormalizeType<Type extends TSchema, Result extends TSchema = (Type extends TCyclic | TIntersect | TUnion ? TCollapseToObject<Type> : Type)> = Result;
-export type TKeyOfAction<Type extends TSchema, Normal extends TSchema = TNormalizeType<Type>> = (Normal extends TAny ? TFromAny : Normal extends TArray<infer Type extends TSchema> ? TFromArray<Type> : Normal extends TObject<infer Properties extends TProperties> ? TFromObject<Properties> : Normal extends TRecord ? TFromRecord<Normal> : Normal extends TTuple<infer Types extends TSchema[]> ? TFromTuple<Types> : TNever);
-export declare function KeyOfAction<Type extends TSchema>(type: Type): TKeyOfAction<Type>;
-export type TKeyOfImmediate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TKeyOfAction<InstantiatedType>;
-export declare function KeyOfImmediate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TKeyOfImmediate<Context, State, Type>;
-export type TKeyOfInstantiate<Context extends TProperties, State extends TState, Type extends TSchema> = TCanInstantiate<Context, [Type]> extends true ? TKeyOfImmediate<Context, State, Type> : TKeyOfDeferred<Type>;
+import { type TFromType } from './from_type.mjs';
+type TNormalizeType<Type extends TSchema, Result extends TSchema = (Type extends TCyclic ? TCollapseToObject<Type> : Type extends TDependent ? TCollapseToObject<Type> : Type extends TIntersect ? TCollapseToObject<Type> : Type extends TUnion ? TCollapseToObject<Type> : Type)> = Result;
+export type TKeyOfAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TFromType<TNormalizeType<Type>> : TKeyOfDeferred<Type>> = Result;
+export declare function KeyOfAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TKeyOfAction<Type>;
+export type TKeyOfInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TKeyOfAction<InstantiatedType>;
 export declare function KeyOfInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TKeyOfInstantiate<Context, State, Type>;
 export {};