typebox 1.1.26 → 1.1.28

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,15 @@
 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 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';
+import { type TFromType } from './from-type.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>;
+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 {};

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

@@ -1,13 +1,7 @@
 // deno-fmt-ignore-file
 import { Memory } from '../../../system/memory/index.mjs';
-import { IsAny } from '../../types/any.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 { IsRecord } from '../../types/record.mjs';
-import { IsTuple } from '../../types/tuple.mjs';
 import { IsUnion } from '../../types/union.mjs';
 import { KeyOfDeferred } from '../../action/keyof.mjs';
 import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
@@ -15,31 +9,17 @@ import { CollapseToObject } from '../object/index.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';
+import { FromType } from './from-type.mjs';
 function NormalizeType(type) {
-    const result = (IsCyclic(type) || IsIntersect(type) || IsUnion(type) ? CollapseToObject(type) :
-        type);
+    const result = (IsCyclic(type) || IsIntersect(type) || IsUnion(type) ? CollapseToObject(type) : type);
     return result;
 }
-export function KeyOfAction(type) {
-    const normal = NormalizeType(type);
-    return (IsAny(normal) ? FromAny() :
-        IsArray(normal) ? FromArray(normal.items) :
-            IsObject(normal) ? FromObject(normal.properties) :
-                IsRecord(normal) ? FromRecord(normal) :
-                    IsTuple(normal) ? FromTuple(normal.items) :
-                        Never());
-}
-export function KeyOfImmediate(context, state, type, options) {
-    const instantiatedType = InstantiateType(context, state, type);
-    return Memory.Update(KeyOfAction(instantiatedType), {}, options);
+export function KeyOfAction(type, options) {
+    return (CanInstantiate([type])
+        ? Memory.Update(FromType(NormalizeType(type)), {}, options)
+        : KeyOfDeferred(type, options));
 }
 export function KeyOfInstantiate(context, state, type, options) {
-    return (CanInstantiate(context, [type])
-        ? KeyOfImmediate(context, state, type, options)
-        : KeyOfDeferred(type, options));
+    const instantiatedType = InstantiateType(context, state, type);
+    return KeyOfAction(instantiatedType, options);
 }

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

@@ -1,25 +1,10 @@
-import { Memory } from '../../../system/memory/index.mjs';
 import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
-import { type TLiteral } from '../../types/literal.mjs';
-import { type TObject } from '../../types/object.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 import { type TIdentifier } from '../../types/identifier.mjs';
-import { type TTemplateLiteral } from '../../types/template-literal.mjs';
 import { type TMappedDeferred } from '../../action/mapped.mjs';
-import { type TTemplateLiteralDecode } from '../template-literal/decode.mjs';
 import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
-import { type TMappedVariants } from './mapped-variants.mjs';
-import { type TEvaluateIntersect } from '../evaluate/index.mjs';
-type TCanonicalAs<InstantiatedAs extends TSchema, Result extends TSchema = InstantiatedAs extends TTemplateLiteral<infer Pattern extends string> ? TTemplateLiteralDecode<Pattern> : InstantiatedAs> = Result;
-type TMappedVariant<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Variant extends TSchema, As extends TSchema, Property extends TSchema, VariantContext extends TProperties = Memory.TAssign<Context, {
-    [_ in Identifier['name']]: Variant;
-}>, InstantiatedAs extends TSchema = TInstantiateType<VariantContext, State, As>, CanonicalAs extends TSchema = TCanonicalAs<InstantiatedAs>, InstantiatedProperty extends TSchema = TInstantiateType<VariantContext, State, Property>, Result extends TProperties = CanonicalAs extends TLiteral<string | number> ? {
-    [_ in CanonicalAs['const']]: InstantiatedProperty;
-} : {}> = Result;
-type TMappedProperties<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Variants extends TSchema[], As extends TSchema, Property extends TSchema, Result extends TProperties[] = []> = (Variants extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TMappedProperties<Context, State, Identifier, Right, As, Property, [...Result, TMappedVariant<Context, State, Identifier, Left, As, Property>]> : Result);
-type TReduceProperties<Properties extends TProperties[], Result extends TSchema[] = []> = (Properties extends [infer Left extends TProperties, ...infer Right extends TProperties[]] ? TReduceProperties<Right, [...Result, TObject<Left>]> : Result);
-type TMappedAction<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema, Variants extends TSchema[] = TMappedVariants<Type>, MappedProperties extends TProperties[] = TMappedProperties<Context, State, Identifier, Variants, As, Property>, MappedObjects extends TSchema[] = TReduceProperties<MappedProperties>, Result extends TSchema = TEvaluateIntersect<MappedObjects>> = Result;
-type TMappedImmediate<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TMappedAction<Context, State, Identifier, InstantiatedType, As, Property>;
-export type TMappedInstantiate<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema> = TCanInstantiate<Context, [Type]> extends true ? TMappedImmediate<Context, State, Identifier, Type, As, Property> : TMappedDeferred<Identifier, Type, As, Property>;
+import { type TMappedOperation } from './mapped-operation.mjs';
+export type TMappedAction<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TMappedOperation<Context, State, Identifier, Type, As, Property> : TMappedDeferred<Identifier, Type, As, Property>> = Result;
+export declare function MappedAction<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema>(context: Context, state: State, identifier: Identifier, type: Type, as: As, property: Property, options: TSchemaOptions): TMappedAction<Context, State, Identifier, Type, As, Property>;
+export type TMappedInstantiate<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema, InstaniatedType extends TSchema = TInstantiateType<Context, State, Type>> = TMappedAction<Context, State, Identifier, InstaniatedType, As, Property>;
 export declare function MappedInstantiate<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema>(context: Context, state: State, identifier: Identifier, type: Type, as: As, property: Property, options: TSchemaOptions): TMappedInstantiate<Context, State, Identifier, Type, As, Property>;
-export {};

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

@@ -1,50 +1,15 @@
-// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Memory } from '../../../system/memory/index.mjs';
-import { IsLiteralNumber, IsLiteralString } from '../../types/literal.mjs';
-import { Object } from '../../types/object.mjs';
-import { IsTemplateLiteral } from '../../types/template-literal.mjs';
 import { MappedDeferred } from '../../action/mapped.mjs';
-import { TemplateLiteralDecode } from '../template-literal/decode.mjs';
 import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
-import { MappedVariants } from './mapped-variants.mjs';
-import { EvaluateIntersect } from '../evaluate/index.mjs';
-function CanonicalAs(instantiatedAs) {
-    const result = IsTemplateLiteral(instantiatedAs) ? TemplateLiteralDecode(instantiatedAs.pattern) : instantiatedAs;
+import { MappedOperation } from './mapped-operation.mjs';
+export function MappedAction(context, state, identifier, type, as, property, options) {
+    const result = CanInstantiate([type])
+        ? Memory.Update(MappedOperation(context, state, identifier, type, as, property), {}, options)
+        : MappedDeferred(identifier, type, as, property, options);
     return result;
 }
-function MappedVariant(context, state, identifier, variant, as, property) {
-    const variantContext = Memory.Assign(context, { [identifier['name']]: variant });
-    const instantiatedAs = InstantiateType(variantContext, state, as);
-    const canonicalAs = CanonicalAs(instantiatedAs);
-    const instantiatedProperty = InstantiateType(variantContext, state, property);
-    return (IsLiteralNumber(canonicalAs) || IsLiteralString(canonicalAs)
-        ? { [canonicalAs.const]: instantiatedProperty }
-        : {});
-}
-function MappedProperties(context, state, identifier, variants, as, property) {
-    return variants.reduce((result, left) => {
-        return [...result, MappedVariant(context, state, identifier, left, as, property)];
-    }, []);
-}
-function MappedObjects(properties) {
-    return properties.reduce((result, left) => {
-        return [...result, Object(left)];
-    }, []);
-}
-function MappedAction(context, state, identifier, type, as, property) {
-    const variants = MappedVariants(type);
-    const mappedProperties = MappedProperties(context, state, identifier, variants, as, property);
-    const mappedObjects = MappedObjects(mappedProperties);
-    const result = EvaluateIntersect(mappedObjects);
-    return result;
-}
-function MappedImmediate(context, state, identifier, type, as, property, options) {
-    const instantiatedType = InstantiateType(context, state, type);
-    return Memory.Update(MappedAction(context, state, identifier, instantiatedType, as, property), {}, options);
-}
 export function MappedInstantiate(context, state, identifier, type, as, property, options) {
-    return (CanInstantiate(context, [type])
-        ? MappedImmediate(context, state, identifier, type, as, property, options)
-        : MappedDeferred(identifier, type, as, property, options));
+    const instantiatedType = InstantiateType(context, state, type);
+    return MappedAction(context, state, identifier, instantiatedType, as, property, options);
 }

package/build/type/engine/mapped/mapped-operation.d.mts

@@ -0,0 +1,22 @@
+import { Memory } from '../../../system/memory/index.mjs';
+import { type TSchema } from '../../types/schema.mjs';
+import { type TLiteral } from '../../types/literal.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TIdentifier } from '../../types/identifier.mjs';
+import { type TTemplateLiteral } from '../../types/template-literal.mjs';
+import { type TTemplateLiteralDecode } from '../template-literal/decode.mjs';
+import { type TState, type TInstantiateType } from '../instantiate.mjs';
+import { type TEvaluateIntersect } from '../evaluate/index.mjs';
+import { type TMappedVariants } from './mapped-variants.mjs';
+type TCanonicalAs<InstantiatedAs extends TSchema, Result extends TSchema = InstantiatedAs extends TTemplateLiteral<infer Pattern extends string> ? TTemplateLiteralDecode<Pattern> : InstantiatedAs> = Result;
+type TMappedVariant<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Variant extends TSchema, As extends TSchema, Property extends TSchema, VariantContext extends TProperties = Memory.TAssign<Context, {
+    [_ in Identifier['name']]: Variant;
+}>, InstantiatedAs extends TSchema = TInstantiateType<VariantContext, State, As>, CanonicalAs extends TSchema = TCanonicalAs<InstantiatedAs>, InstantiatedProperty extends TSchema = TInstantiateType<VariantContext, State, Property>, Result extends TProperties = CanonicalAs extends TLiteral<string | number> ? {
+    [_ in CanonicalAs['const']]: InstantiatedProperty;
+} : {}> = Result;
+type TMappedProperties<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Variants extends TSchema[], As extends TSchema, Property extends TSchema, Result extends TProperties[] = []> = (Variants extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TMappedProperties<Context, State, Identifier, Right, As, Property, [...Result, TMappedVariant<Context, State, Identifier, Left, As, Property>]> : Result);
+type TReduceProperties<Properties extends TProperties[], Result extends TSchema[] = []> = (Properties extends [infer Left extends TProperties, ...infer Right extends TProperties[]] ? TReduceProperties<Right, [...Result, TObject<Left>]> : Result);
+export type TMappedOperation<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema, Variants extends TSchema[] = TMappedVariants<Type>, MappedProperties extends TProperties[] = TMappedProperties<Context, State, Identifier, Variants, As, Property>, MappedObjects extends TSchema[] = TReduceProperties<MappedProperties>, Result extends TSchema = TEvaluateIntersect<MappedObjects>> = Result;
+export declare function MappedOperation<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema>(context: Context, state: State, identifier: Identifier, type: Type, as: As, property: Property): TMappedOperation<Context, State, Identifier, Type, As, Property>;
+export {};

package/build/type/engine/mapped/mapped-operation.mjs

@@ -0,0 +1,42 @@
+// deno-lint-ignore-file ban-types
+// deno-fmt-ignore-file
+import { Memory } from '../../../system/memory/index.mjs';
+import { IsLiteralNumber, IsLiteralString } from '../../types/literal.mjs';
+import { Object } from '../../types/object.mjs';
+import { IsTemplateLiteral } from '../../types/template-literal.mjs';
+import { TemplateLiteralDecode } from '../template-literal/decode.mjs';
+import { InstantiateType } from '../instantiate.mjs';
+import { EvaluateIntersect } from '../evaluate/index.mjs';
+import { MappedVariants } from './mapped-variants.mjs';
+function CanonicalAs(instantiatedAs) {
+    const result = IsTemplateLiteral(instantiatedAs)
+        ? TemplateLiteralDecode(instantiatedAs.pattern)
+        : instantiatedAs;
+    return result;
+}
+function MappedVariant(context, state, identifier, variant, as, property) {
+    const variantContext = Memory.Assign(context, { [identifier['name']]: variant });
+    const instantiatedAs = InstantiateType(variantContext, state, as);
+    const canonicalAs = CanonicalAs(instantiatedAs);
+    const instantiatedProperty = InstantiateType(variantContext, state, property);
+    return (IsLiteralNumber(canonicalAs) || IsLiteralString(canonicalAs)
+        ? { [canonicalAs.const]: instantiatedProperty }
+        : {});
+}
+function MappedProperties(context, state, identifier, variants, as, property) {
+    return variants.reduce((result, left) => {
+        return [...result, MappedVariant(context, state, identifier, left, as, property)];
+    }, []);
+}
+function MappedObjects(properties) {
+    return properties.reduce((result, left) => {
+        return [...result, Object(left)];
+    }, []);
+}
+export function MappedOperation(context, state, identifier, type, as, property) {
+    const variants = MappedVariants(type);
+    const mappedProperties = MappedProperties(context, state, identifier, variants, as, property);
+    const mappedObjects = MappedObjects(mappedProperties);
+    const result = EvaluateIntersect(mappedObjects);
+    return result;
+}

package/build/type/engine/non-nullable/instantiate.d.mts

@@ -3,13 +3,12 @@ import { type TProperties } from '../../types/properties.mjs';
 import { type TNull } from '../../types/null.mjs';
 import { type TUndefined } from '../../types/undefined.mjs';
 import { type TUnion } from '../../types/union.mjs';
-import { type TExcludeInstantiate } from '../exclude/instantiate.mjs';
+import { type TExcludeAction } from '../exclude/instantiate.mjs';
 import { type TNonNullableDeferred } from '../../action/non-nullable.mjs';
 import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
-type TNonNullableAction<Type extends TSchema, Excluded extends TSchema = TUnion<[TNull, TUndefined]>> = TExcludeInstantiate<{}, {
-    callstack: [];
-}, Type, Excluded>;
-type TNonNullableImmediate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>, Result extends TSchema = TNonNullableAction<InstantiatedType>> = Result;
-export type TNonNullableInstantiate<Context extends TProperties, State extends TState, Type extends TSchema> = TCanInstantiate<Context, [Type]> extends true ? TNonNullableImmediate<Context, State, Type> : TNonNullableDeferred<Type>;
+type TNonNullableOperation<Type extends TSchema, Excluded extends TSchema = TUnion<[TNull, TUndefined]>> = TExcludeAction<Type, Excluded>;
+export type TNonNullableAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TNonNullableOperation<Type> : TNonNullableDeferred<Type>> = Result;
+export declare function NonNullableAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TNonNullableAction<Type>;
+export type TNonNullableInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TNonNullableAction<InstantiatedType>;
 export declare function NonNullableInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TNonNullableInstantiate<Context, State, Type>;
 export {};

package/build/type/engine/non-nullable/instantiate.mjs

@@ -1,22 +1,22 @@
-// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Memory } from '../../../system/memory/index.mjs';
 import { Null } from '../../types/null.mjs';
 import { Undefined } from '../../types/undefined.mjs';
 import { Union } from '../../types/union.mjs';
-import { ExcludeInstantiate } from '../exclude/instantiate.mjs';
+import { ExcludeAction } from '../exclude/instantiate.mjs';
 import { NonNullableDeferred } from '../../action/non-nullable.mjs';
 import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
-function NonNullableAction(type) {
+function NonNullableOperation(type) {
     const excluded = Union([Null(), Undefined()]);
-    return ExcludeInstantiate({}, { callstack: [] }, type, excluded, {});
+    return ExcludeAction(type, excluded, {});
 }
-function NonNullableImmediate(context, state, type, options) {
-    const instantiatedType = InstantiateType(context, state, type);
-    return Memory.Update(NonNullableAction(instantiatedType), {}, options);
+export function NonNullableAction(type, options) {
+    const result = CanInstantiate([type])
+        ? Memory.Update(NonNullableOperation(type), {}, options)
+        : NonNullableDeferred(type, options);
+    return result;
 }
 export function NonNullableInstantiate(context, state, type, options) {
-    return (CanInstantiate(context, [type])
-        ? NonNullableImmediate(context, state, type, options)
-        : NonNullableDeferred(type, options));
+    const instantiatedType = InstantiateType(context, state, type);
+    return NonNullableAction(instantiatedType, options);
 }

package/build/type/engine/omit/from-type.d.mts

@@ -0,0 +1,12 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TToIndexableKeys } from '../indexable/to-indexable-keys.mjs';
+import { type TToIndexable } from '../indexable/to-indexable.mjs';
+type TNormalKeys<Keys extends string[], UnionKeys extends string = Keys[number], Result extends string | number = (UnionKeys extends `${infer Value extends number}` ? UnionKeys | Value : UnionKeys)> = Result;
+type TFromKeys<Properties extends TProperties, Keys extends string[], Omitted extends TProperties = Omit<Properties, TNormalKeys<Keys>>, Result extends TProperties = {
+    [Key in keyof Omitted]: Omitted[Key];
+}> = Result;
+export type TFromType<Type extends TSchema, Indexer extends TSchema, Indexable extends TProperties = TToIndexable<Type>, IndexableKeys extends string[] = TToIndexableKeys<Indexer>, Omitted extends TProperties = TFromKeys<Indexable, IndexableKeys>, Result extends TSchema = TObject<Omitted>> = Result;
+export declare function FromType<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer): TFromType<Type, Indexer>;
+export {};

package/build/type/engine/omit/from-type.mjs

@@ -0,0 +1,18 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
+import { Object } from '../../types/object.mjs';
+import { ToIndexableKeys } from '../indexable/to-indexable-keys.mjs';
+import { ToIndexable } from '../indexable/to-indexable.mjs';
+function FromKeys(properties, keys) {
+    const result = Guard.Keys(properties).reduce((result, key) => {
+        return keys.includes(key) ? result : { ...result, [key]: properties[key] };
+    }, {});
+    return result;
+}
+export function FromType(type, indexer) {
+    const indexable = ToIndexable(type);
+    const indexableKeys = ToIndexableKeys(indexer);
+    const omitted = FromKeys(indexable, indexableKeys);
+    const result = Object(omitted);
+    return result;
+}

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

@@ -1,16 +1,9 @@
 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 TToIndexableKeys } from '../indexable/to-indexable-keys.mjs';
-import { type TToIndexable } from '../indexable/to-indexable.mjs';
 import { type TOmitDeferred } from '../../action/omit.mjs';
 import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
-type TNormalKeys<Keys extends string[], UnionKeys extends string = Keys[number], Result extends string | number = (UnionKeys extends `${infer Value extends number}` ? UnionKeys | Value : UnionKeys)> = Result;
-type TFromKeys<Properties extends TProperties, Keys extends string[], Omitted extends TProperties = Omit<Properties, TNormalKeys<Keys>>, Result extends TProperties = {
-    [Key in keyof Omitted]: Omitted[Key];
-}> = Result;
-type TOmitAction<Type extends TSchema, Indexer extends TSchema, Indexable extends TProperties = TToIndexable<Type>, IndexableKeys extends string[] = TToIndexableKeys<Indexer>, Omitted extends TProperties = TFromKeys<Indexable, IndexableKeys>, Result extends TSchema = TObject<Omitted>> = Result;
-type TOmitImmediate<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>, Result extends TSchema = TOmitAction<InstantiatedType, InstantiatedIndexer>> = Result;
-export type TOmitInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, Indexer extends TSchema> = TCanInstantiate<Context, [Type, Indexer]> extends true ? TOmitImmediate<Context, State, Type, Indexer> : TOmitDeferred<Type, Indexer>;
+import { type TFromType } from './from-type.mjs';
+export type TOmitAction<Type extends TSchema, Indexer extends TSchema, Result extends TSchema = TCanInstantiate<[Type, Indexer]> extends true ? TFromType<Type, Indexer> : TOmitDeferred<Type, Indexer>> = Result;
+export declare function OmitAction<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer, options: TSchemaOptions): TOmitAction<Type, Indexer>;
+export type TOmitInstantiate<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>> = TOmitAction<InstantiatedType, InstantiatedIndexer>;
 export declare function OmitInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, Indexer extends TSchema>(context: Context, state: State, type: Type, indexer: Indexer, options: TSchemaOptions): TOmitInstantiate<Context, State, Type, Indexer>;
-export {};

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

@@ -1,31 +1,16 @@
 // deno-fmt-ignore-file
 import { Memory } from '../../../system/memory/index.mjs';
-import { Guard } from '../../../guard/index.mjs';
-import { Object } from '../../types/object.mjs';
-import { ToIndexableKeys } from '../indexable/to-indexable-keys.mjs';
-import { ToIndexable } from '../indexable/to-indexable.mjs';
 import { OmitDeferred } from '../../action/omit.mjs';
 import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
-function FromKeys(properties, keys) {
-    const result = Guard.Keys(properties).reduce((result, key) => {
-        return keys.includes(key) ? result : { ...result, [key]: properties[key] };
-    }, {});
+import { FromType } from './from-type.mjs';
+export function OmitAction(type, indexer, options) {
+    const result = CanInstantiate([type, indexer])
+        ? Memory.Update(FromType(type, indexer), {}, options)
+        : OmitDeferred(type, indexer, options);
     return result;
 }
-function OmitAction(type, indexer) {
-    const indexable = ToIndexable(type);
-    const indexableKeys = ToIndexableKeys(indexer);
-    const omitted = FromKeys(indexable, indexableKeys);
-    const result = Object(omitted);
-    return result;
-}
-function OmitImmediate(context, state, type, indexer, options) {
+export function OmitInstantiate(context, state, type, indexer, options) {
     const instantiatedType = InstantiateType(context, state, type);
     const instantiatedIndexer = InstantiateType(context, state, indexer);
-    return Memory.Update(OmitAction(instantiatedType, instantiatedIndexer), {}, options);
-}
-export function OmitInstantiate(context, state, type, indexer, options) {
-    return (CanInstantiate(context, [type, indexer])
-        ? OmitImmediate(context, state, type, indexer, options)
-        : OmitDeferred(type, indexer, options));
+    return OmitAction(instantiatedType, instantiatedIndexer, options);
 }

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

@@ -1,8 +1,8 @@
 import { type TProperties } from '../../types/properties.mjs';
 import { type TSchema } from '../../types/schema.mjs';
-import { type TState, type TInstantiateType, TCanInstantiate } from '../instantiate.mjs';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
 import { type TOptionsDeferred, type TOptions } from '../../action/options.mjs';
-type TOptionsImmediate<Context extends TProperties, State extends TState, Type extends TSchema, Options extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>, Result extends TSchema = TOptions<InstantiatedType, Options>> = Result;
-export type TOptionsInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, Options extends TSchema> = TCanInstantiate<Context, [Type]> extends true ? TOptionsImmediate<Context, State, Type, Options> : TOptionsDeferred<Type, Options>;
+export type TOptionsAction<Type extends TSchema, Options extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TOptions<Type, Options> : TOptionsDeferred<Type, Options>> = Result;
+export declare function OptionsAction<Type extends TSchema, Options extends TSchema>(type: Type, options: Options): TOptionsAction<Type, Options>;
+export type TOptionsInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, Options extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TOptionsAction<InstantiatedType, Options>;
 export declare function OptionsInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, Options extends TSchema>(context: Context, state: State, type: Type, options: Options): TOptionsInstantiate<Context, State, Type, Options>;
-export {};

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

@@ -1,13 +1,14 @@
 // deno-fmt-ignore-file
 import { Memory } from '../../../system/memory/index.mjs';
-import { CanInstantiate, InstantiateType } from '../instantiate.mjs';
+import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
 import { OptionsDeferred } from '../../action/options.mjs';
-function OptionsImmediate(context, state, type, options) {
-    const instaniatedType = InstantiateType(context, state, type);
-    return Memory.Update(instaniatedType, {}, options);
+export function OptionsAction(type, options) {
+    const result = CanInstantiate([type])
+        ? Memory.Update(type, {}, options)
+        : OptionsDeferred(type, options);
+    return result;
 }
 export function OptionsInstantiate(context, state, type, options) {
-    return (CanInstantiate(context, [type])
-        ? OptionsImmediate(context, state, type, options)
-        : OptionsDeferred(type, options));
+    const instaniatedType = InstantiateType(context, state, type);
+    return OptionsAction(instaniatedType, options);
 }

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

@@ -1,14 +1,15 @@
 import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 import { type TFunction } from '../../types/function.mjs';
-import { type TNever } from '../../types/never.mjs';
 import { type TTuple } from '../../types/tuple.mjs';
 import { type TParametersDeferred } from '../../action/parameters.mjs';
 import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
-type TParametersAction<Type extends TSchema> = (Type extends TFunction<infer Parameters extends TSchema[], infer _ extends TSchema> ? TInstantiateType<{}, {
+import { type TInstantiateElements } from '../instantiate.mjs';
+type TParametersOperation<Type extends TSchema, Parameters extends TSchema[] = Type extends TFunction ? Type['parameters'] : [], InstantiatedParameters extends TSchema[] = TInstantiateElements<{}, {
     callstack: [];
-}, TTuple<Parameters>> : TNever);
-type TParametersImmediate<Context extends TProperties, State extends TState, Type extends TSchema, InstantatedType extends TSchema = TInstantiateType<Context, State, Type>> = TParametersAction<InstantatedType>;
-export type TParametersInstantiate<Context extends TProperties, State extends TState, Type extends TSchema> = (TCanInstantiate<Context, [Type]> extends true ? TParametersImmediate<Context, State, Type> : TParametersDeferred<Type>);
+}, Parameters>, Result extends TSchema = TTuple<InstantiatedParameters>> = Result;
+export type TParametersAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TParametersOperation<Type> : TParametersDeferred<Type>> = Result;
+export declare function ParametersAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TParametersAction<Type>;
+export type TParametersInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TParametersAction<InstantiatedType>;
 export declare function ParametersInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TParametersInstantiate<Context, State, Type>;
 export {};

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

@@ -2,21 +2,23 @@
 // deno-fmt-ignore-file
 import { Memory } from '../../../system/memory/index.mjs';
 import { IsFunction } from '../../types/function.mjs';
-import { Never } from '../../types/never.mjs';
 import { Tuple } from '../../types/tuple.mjs';
 import { ParametersDeferred } from '../../action/parameters.mjs';
 import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
-function ParametersAction(type) {
-    return (IsFunction(type)
-        ? InstantiateType({}, { callstack: [] }, Tuple(type.parameters)) // spread-rest
-        : Never());
+import { InstantiateElements } from '../instantiate.mjs';
+function ParametersOperation(type) {
+    const parameters = IsFunction(type) ? type['parameters'] : [];
+    const instantiatedParameters = InstantiateElements({}, { callstack: [] }, parameters);
+    const result = Tuple(instantiatedParameters);
+    return result;
 }
-function ParametersImmediate(context, state, type, options) {
-    const instantiatedType = InstantiateType(context, state, type);
-    return Memory.Update(ParametersAction(instantiatedType), {}, options);
+export function ParametersAction(type, options) {
+    const result = CanInstantiate([type])
+        ? Memory.Update(ParametersOperation(type), {}, options)
+        : ParametersDeferred(type, options);
+    return result;
 }
 export function ParametersInstantiate(context, state, type, options) {
-    return (CanInstantiate(context, [type])
-        ? ParametersImmediate(context, state, type, options)
-        : ParametersDeferred(type, options));
+    const instantiatedType = InstantiateType(context, state, type);
+    return ParametersAction(instantiatedType, options);
 }

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

@@ -3,7 +3,7 @@ import { type TProperties } from '../../types/properties.mjs';
 import { type TPartialDeferred } from '../../action/partial.mjs';
 import { type TFromType } from './from-type.mjs';
 import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
-type TPartialImmediate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TFromType<InstantiatedType>;
-export type TPartialInstantiate<Context extends TProperties, State extends TState, Type extends TSchema> = TCanInstantiate<Context, [Type]> extends true ? TPartialImmediate<Context, State, Type> : TPartialDeferred<Type>;
+export type TPartialAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TFromType<Type> : TPartialDeferred<Type>> = Result;
+export declare function PartialAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TPartialAction<Type>;
+export type TPartialInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TPartialAction<InstantiatedType>;
 export declare function PartialInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TPartialInstantiate<Context, State, Type>;
-export {};

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

@@ -3,12 +3,13 @@ import { Memory } from '../../../system/memory/index.mjs';
 import { PartialDeferred } from '../../action/partial.mjs';
 import { FromType } from './from-type.mjs';
 import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
-function PartialImmediate(context, state, type, options) {
-    const instantiatedType = InstantiateType(context, state, type);
-    return Memory.Update(FromType(instantiatedType), {}, options);
+export function PartialAction(type, options) {
+    const result = CanInstantiate([type])
+        ? Memory.Update(FromType(type), {}, options)
+        : PartialDeferred(type, options);
+    return result;
 }
 export function PartialInstantiate(context, state, type, options) {
-    return (CanInstantiate(context, [type])
-        ? PartialImmediate(context, state, type, options)
-        : PartialDeferred(type, options));
+    const instantiatedType = InstantiateType(context, state, type);
+    return PartialAction(instantiatedType, options);
 }

package/build/type/engine/pick/from-type.d.mts

@@ -0,0 +1,13 @@
+import { Memory } from '../../../system/memory/index.mjs';
+import { type TSchema } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TToIndexableKeys } from '../indexable/to-indexable-keys.mjs';
+import { type TToIndexable } from '../indexable/to-indexable.mjs';
+type TComparable<Indexable extends TProperties> = (keyof Indexable extends string | number ? `${keyof Indexable}` : never);
+type TFromKeys<Indexable extends TProperties, Keys extends string[], Result extends TProperties = {}> = (Keys extends [infer Left extends string, ...infer Right extends string[]] ? Left extends TComparable<Indexable> ? TFromKeys<Indexable, Right, Memory.TAssign<Result, {
+    [_ in Left]: Indexable[Left];
+}>> : TFromKeys<Indexable, Right, Result> : Result);
+export type TFromType<Type extends TSchema, Indexer extends TSchema, Indexable extends TProperties = TToIndexable<Type>, Keys extends string[] = TToIndexableKeys<Indexer>, Applied extends TProperties = TFromKeys<Indexable, Keys>, Result extends TSchema = TObject<Applied>> = Result;
+export declare function FromType<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer): TFromType<Type, Indexer>;
+export {};

package/build/type/engine/pick/from-type.mjs

@@ -0,0 +1,20 @@
+// deno-lint-ignore-file ban-types
+// deno-fmt-ignore-file
+import { Memory } from '../../../system/memory/index.mjs';
+import { Guard } from '../../../guard/index.mjs';
+import { Object } from '../../types/object.mjs';
+import { ToIndexableKeys } from '../indexable/to-indexable-keys.mjs';
+import { ToIndexable } from '../indexable/to-indexable.mjs';
+function FromKeys(properties, keys) {
+    const result = Guard.Keys(properties).reduce((result, key) => {
+        return keys.includes(key) ? Memory.Assign(result, { [key]: properties[key] }) : result;
+    }, {});
+    return result;
+}
+export function FromType(type, indexer) {
+    const indexable = ToIndexable(type);
+    const keys = ToIndexableKeys(indexer);
+    const applied = FromKeys(indexable, keys);
+    const result = Object(applied);
+    return result;
+}