typebox 1.1.38 → 1.2.0

package/build/type/engine/instantiate.mjs

@@ -17,6 +17,7 @@ import { Constructor, IsConstructor, ConstructorOptions } from '../types/constru
 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';
@@ -51,7 +52,6 @@ import { MappedInstantiate } from './mapped/instantiate.mjs';
 import { ModuleInstantiate } from './module/instantiate.mjs';
 import { NonNullableInstantiate } from './non_nullable/instantiate.mjs';
 import { OmitInstantiate } from './omit/instantiate.mjs';
-import { OptionsInstantiate } from './options/instantiate.mjs';
 import { ParametersInstantiate } from './parameters/instantiate.mjs';
 import { PartialInstantiate } from './partial/instantiate.mjs';
 import { PickInstantiate } from './pick/instantiate.mjs';
@@ -63,6 +63,7 @@ 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';
 export function CanInstantiate(types) {
     return Guard.TakeLeft(types, (left, right) => IsRef(left)
@@ -116,17 +117,17 @@ function InstantiateDeferred(context, state, action, parameters, 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, '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, '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) {
@@ -140,15 +141,16 @@ export function InstantiateType(context, state, input) {
                     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);
+                                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)) :
+                                        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));
     return withModifiers;

package/build/type/engine/intrinsics/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 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

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

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

@@ -1,13 +1,14 @@
 import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 import { type TCyclic } from '../../types/cyclic.mjs';
+import { type TDependent } from '../../types/dependent.mjs';
 import { type TIntersect } from '../../types/intersect.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 TFromType } from './from_type.mjs';
-type TNormalizeType<Type extends TSchema, Result extends TSchema = (Type extends TCyclic | TIntersect | TUnion ? TCollapseToObject<Type> : Type)> = Result;
+type TNormalizeType<Type extends TSchema, Result extends TSchema = (Type extends TCyclic | TDependent | TIntersect | 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>;

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

@@ -1,6 +1,7 @@
 // deno-fmt-ignore-file
 import { Memory } from '../../../system/memory/index.mjs';
 import { IsCyclic } from '../../types/cyclic.mjs';
+import { IsDependent } from '../../types/dependent.mjs';
 import { IsIntersect } from '../../types/intersect.mjs';
 import { IsUnion } from '../../types/union.mjs';
 import { KeyOfDeferred } from '../../action/keyof.mjs';
@@ -11,7 +12,7 @@ import { CollapseToObject } from '../object/index.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) || IsDependent(type) || IsIntersect(type) || IsUnion(type) ? CollapseToObject(type) : type);
     return result;
 }
 export function KeyOfAction(type, options) {

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

@@ -5,11 +5,11 @@ 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 TInstantiateType, type TState } from '../instantiate.mjs';
+import { type TEvaluateIntersect } from '../evaluate/evaluate.mjs';
+import { type TEvaluateTemplateLiteral } from '../evaluate/evaluate.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 TCanonicalAs<InstantiatedAs extends TSchema, Result extends TSchema = InstantiatedAs extends TTemplateLiteral<infer Pattern extends string> ? TEvaluateTemplateLiteral<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> ? {

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

@@ -4,13 +4,13 @@ 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 { EvaluateIntersect } from '../evaluate/evaluate.mjs';
+import { EvaluateTemplateLiteral } from '../evaluate/evaluate.mjs';
 import { MappedVariants } from './mapped_variants.mjs';
 function CanonicalAs(instantiatedAs) {
     const result = IsTemplateLiteral(instantiatedAs)
-        ? TemplateLiteralDecode(instantiatedAs.pattern)
+        ? EvaluateTemplateLiteral(instantiatedAs.pattern)
         : instantiatedAs;
     return result;
 }

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

@@ -3,12 +3,13 @@ import { type TLiteral, type TLiteralValue } from '../../types/literal.mjs';
 import { type TEnum, type TEnumValue } from '../../types/enum.mjs';
 import { type TTemplateLiteral } from '../../types/template_literal.mjs';
 import { type TUnion } from '../../types/union.mjs';
-import { type TEnumValuesToVariants } from '../enum/index.mjs';
-import { type TTemplateLiteralDecode } from '../template_literal/decode.mjs';
-type TFromTemplateLiteral<Pattern extends string, Decoded extends TSchema = TTemplateLiteralDecode<Pattern>, Result extends TSchema[] = TFromType<Decoded>> = Result;
+import { type TEvaluateEnum } from '../evaluate/evaluate.mjs';
+import { type TEvaluateTemplateLiteral } from '../evaluate/evaluate.mjs';
+type TFromTemplateLiteral<Pattern extends string, Evaluated extends TSchema = TEvaluateTemplateLiteral<Pattern>, Result extends TSchema[] = TFromType<Evaluated>> = Result;
 type TFromUnion<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromUnion<Right, [...Result, ...TFromType<Left>]> : Result);
+type TFromEnum<Values extends TEnumValue[], Evaluated extends TSchema = TEvaluateEnum<Values>, Result extends TSchema[] = TFromType<Evaluated>> = Result;
 type TFromLiteral<Value extends TLiteralValue, Result extends TSchema[] = Value extends number ? [TLiteral<`${Value}`>] : [TLiteral<Value>]> = Result;
-type TFromType<Type extends TSchema, Result extends TSchema[] = (Type extends TEnum<infer Values extends TEnumValue[]> ? TFromUnion<TEnumValuesToVariants<Values>> : Type extends TLiteral<infer Value extends number> ? TFromLiteral<Value> : Type extends TTemplateLiteral<infer Pattern extends string> ? TFromTemplateLiteral<Pattern> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : [
+type TFromType<Type extends TSchema, Result extends TSchema[] = (Type extends TEnum<infer Values extends TEnumValue[]> ? TFromEnum<Values> : Type extends TLiteral<infer Value extends number> ? TFromLiteral<Value> : Type extends TTemplateLiteral<infer Pattern extends string> ? TFromTemplateLiteral<Pattern> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : [
     Type
 ])> = Result;
 export type TMappedVariants<Type extends TSchema, Result extends TSchema[] = TFromType<Type>> = Result;

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

@@ -4,11 +4,11 @@ import { Literal, IsLiteral } from '../../types/literal.mjs';
 import { IsEnum } from '../../types/enum.mjs';
 import { IsTemplateLiteral } from '../../types/template_literal.mjs';
 import { IsUnion } from '../../types/union.mjs';
-import { EnumValuesToVariants } from '../enum/index.mjs';
-import { TemplateLiteralDecode } from '../template_literal/decode.mjs';
+import { EvaluateEnum } from '../evaluate/evaluate.mjs';
+import { EvaluateTemplateLiteral } from '../evaluate/evaluate.mjs';
 function FromTemplateLiteral(pattern) {
-    const decoded = TemplateLiteralDecode(pattern);
-    const result = FromType(decoded);
+    const evaluated = EvaluateTemplateLiteral(pattern);
+    const result = FromType(evaluated);
     return result;
 }
 function FromUnion(types) {
@@ -16,12 +16,17 @@ function FromUnion(types) {
         return [...result, ...FromType(left)];
     }, []);
 }
+function FromEnum(values) {
+    const evaluated = EvaluateEnum(values);
+    const result = FromType(evaluated);
+    return result;
+}
 function FromLiteral(value) {
     const result = Guard.IsNumber(value) ? [Literal(`${value}`)] : [Literal(value)];
     return result;
 }
 function FromType(type) {
-    const result = (IsEnum(type) ? FromUnion(EnumValuesToVariants(type.enum)) :
+    const result = (IsEnum(type) ? FromEnum(type.enum) :
         IsLiteral(type) ? FromLiteral(type.const) :
             IsTemplateLiteral(type) ? FromTemplateLiteral(type.pattern) :
                 IsUnion(type) ? FromUnion(type.anyOf) :

package/build/type/engine/object/from_dependent.d.mts

@@ -0,0 +1,5 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TFromType } from './from_type.mjs';
+import { type TEvaluateDependent } from '../evaluate/evaluate.mjs';
+export type TFromDependent<If extends TSchema, Then extends TSchema, Else extends TSchema, Evaluated extends TSchema = TEvaluateDependent<If, Then, Else>, Result extends TSchema = TFromType<Evaluated>> = Result;
+export declare function FromDependent<If extends TSchema, Then extends TSchema, Else extends TSchema>(if_: If, then_: Then, else_: Else): TFromDependent<If, Then, Else>;

package/build/type/engine/object/from_dependent.mjs

@@ -0,0 +1,8 @@
+// deno-fmt-ignore-file
+import { FromType } from './from_type.mjs';
+import { EvaluateDependent } from '../evaluate/evaluate.mjs';
+export function FromDependent(if_, then_, else_) {
+    const evaluated = EvaluateDependent(if_, then_, else_);
+    const result = FromType(evaluated);
+    return result;
+}

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

@@ -1,14 +1,16 @@
 import { type TSchema } from '../../types/schema.mjs';
 import { type TCyclic } from '../../types/cyclic.mjs';
+import { type TDependent } from '../../types/dependent.mjs';
 import { type TIntersect } from '../../types/intersect.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 import { type TObject } from '../../types/object.mjs';
 import { type TTuple } from '../../types/tuple.mjs';
 import { type TUnion } from '../../types/union.mjs';
 import { type TFromCyclic } from './from_cyclic.mjs';
+import { type TFromDependent } from './from_dependent.mjs';
 import { type TFromIntersect } from './from_intersect.mjs';
 import { type TFromObject } from './from_object.mjs';
 import { type TFromTuple } from './from_tuple.mjs';
 import { type TFromUnion } from './from_union.mjs';
-export type TFromType<Type extends TSchema, Result extends TProperties = (Type extends TCyclic<infer Defs extends TProperties, infer Ref extends string> ? TFromCyclic<Defs, Ref> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<Types> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple<Types> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<Properties> : {})> = Result;
+export type TFromType<Type extends TSchema, Result extends TProperties = (Type extends TCyclic<infer Defs extends TProperties, infer Ref extends string> ? TFromCyclic<Defs, Ref> : Type extends TDependent<infer If extends TSchema, infer Then extends TSchema, infer Else extends TSchema> ? TFromDependent<If, Then, Else> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<Types> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple<Types> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<Properties> : {})> = Result;
 export declare function FromType<Type extends TSchema>(type: Type): TFromType<Type>;

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

@@ -1,20 +1,23 @@
 // deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { IsCyclic } from '../../types/cyclic.mjs';
+import { IsDependent } from '../../types/dependent.mjs';
 import { IsIntersect } from '../../types/intersect.mjs';
 import { IsObject } from '../../types/object.mjs';
 import { IsTuple } from '../../types/tuple.mjs';
 import { IsUnion } from '../../types/union.mjs';
 import { FromCyclic } from './from_cyclic.mjs';
+import { FromDependent } from './from_dependent.mjs';
 import { FromIntersect } from './from_intersect.mjs';
 import { FromObject } from './from_object.mjs';
 import { FromTuple } from './from_tuple.mjs';
 import { FromUnion } from './from_union.mjs';
 export function FromType(type) {
     return (IsCyclic(type) ? FromCyclic(type.$defs, type.$ref) :
-        IsIntersect(type) ? FromIntersect(type.allOf) :
-            IsUnion(type) ? FromUnion(type.anyOf) :
-                IsTuple(type) ? FromTuple(type.items) :
-                    IsObject(type) ? FromObject(type.properties) :
-                        {});
+        IsDependent(type) ? FromDependent(type.if, type.then, type.else) :
+            IsIntersect(type) ? FromIntersect(type.allOf) :
+                IsUnion(type) ? FromUnion(type.anyOf) :
+                    IsTuple(type) ? FromTuple(type.items) :
+                        IsObject(type) ? FromObject(type.properties) :
+                            {});
 }

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

@@ -0,0 +1,5 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TFromType } from './from_type.mjs';
+import { type TEvaluateDependent } from '../evaluate/evaluate.mjs';
+export type TFromDependent<If extends TSchema, Then extends TSchema, Else extends TSchema, Evaluated extends TSchema = TEvaluateDependent<If, Then, Else>, Result extends TSchema = TFromType<Evaluated>> = Result;
+export declare function FromDependent<If extends TSchema, Then extends TSchema, Else extends TSchema>(if_: If, then_: Then, else_: Else): TFromDependent<If, Then, Else>;

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

@@ -0,0 +1,8 @@
+// deno-fmt-ignore-file
+import { FromType } from './from_type.mjs';
+import { EvaluateDependent } from '../evaluate/evaluate.mjs';
+export function FromDependent(if_, then_, else_) {
+    const evaluated = EvaluateDependent(if_, then_, else_);
+    const result = FromType(evaluated);
+    return result;
+}

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

@@ -1,5 +1,5 @@
 import { type TSchema } from '../../types/schema.mjs';
 import { type TFromType } from './from_type.mjs';
 import { type TEvaluateIntersect } from '../evaluate/evaluate.mjs';
-export type TFromIntersect<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromIntersect<Right, [...Result, TFromType<Left>]> : TEvaluateIntersect<Result>);
+export type TFromIntersect<Types extends TSchema[], Evaluated extends TSchema = TEvaluateIntersect<Types>, Result extends TSchema = TFromType<Evaluated>> = Result;
 export declare function FromIntersect<Types extends TSchema[]>(types: [...Types]): TFromIntersect<Types>;

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

@@ -2,6 +2,7 @@
 import { FromType } from './from_type.mjs';
 import { EvaluateIntersect } from '../evaluate/evaluate.mjs';
 export function FromIntersect(types) {
-    const result = types.map(type => FromType(type));
-    return EvaluateIntersect(result);
+    const evaluated = EvaluateIntersect(types);
+    const result = FromType(evaluated);
+    return result;
 }

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

@@ -1,12 +1,14 @@
 import { type TSchema } from '../../types/schema.mjs';
 import { type TCyclic } from '../../types/cyclic.mjs';
+import { type TDependent } from '../../types/dependent.mjs';
 import { type TIntersect } from '../../types/intersect.mjs';
 import { type TObject } from '../../types/object.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 import { type TUnion } from '../../types/union.mjs';
 import { type TFromCyclic } from './from_cyclic.mjs';
+import { type TFromDependent } from './from_dependent.mjs';
 import { type TFromIntersect } from './from_intersect.mjs';
 import { type TFromUnion } from './from_union.mjs';
 import { type TFromObject } from './from_object.mjs';
-export type TFromType<Type extends TSchema> = (Type extends TCyclic<infer Defs extends TProperties, infer Ref extends string> ? TFromCyclic<Defs, Ref> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<Types> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<Properties> : TObject<{}>);
+export type TFromType<Type extends TSchema> = (Type extends TCyclic<infer Defs extends TProperties, infer Ref extends string> ? TFromCyclic<Defs, Ref> : Type extends TDependent<infer If extends TSchema, infer Then extends TSchema, infer Else extends TSchema> ? TFromDependent<If, Then, Else> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<Types> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<Properties> : TObject<{}>);
 export declare function FromType<Type extends TSchema>(type: Type): TFromType<Type>;

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

@@ -1,17 +1,20 @@
 // deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { IsCyclic } from '../../types/cyclic.mjs';
+import { IsDependent } from '../../types/dependent.mjs';
 import { IsIntersect } from '../../types/intersect.mjs';
 import { Object, IsObject } from '../../types/object.mjs';
 import { IsUnion } from '../../types/union.mjs';
 import { FromCyclic } from './from_cyclic.mjs';
+import { FromDependent } from './from_dependent.mjs';
 import { FromIntersect } from './from_intersect.mjs';
 import { FromUnion } from './from_union.mjs';
 import { FromObject } from './from_object.mjs';
 export function FromType(type) {
     return (IsCyclic(type) ? FromCyclic(type.$defs, type.$ref) :
-        IsIntersect(type) ? FromIntersect(type.allOf) :
-            IsUnion(type) ? FromUnion(type.anyOf) :
-                IsObject(type) ? FromObject(type.properties) :
-                    Object({}));
+        IsDependent(type) ? FromDependent(type.if, type.then, type.else) :
+            IsIntersect(type) ? FromIntersect(type.allOf) :
+                IsUnion(type) ? FromUnion(type.anyOf) :
+                    IsObject(type) ? FromObject(type.properties) :
+                        Object({}));
 }

package/build/type/engine/readonly_object/from_dependent.d.mts

@@ -0,0 +1,5 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TFromType } from './from_type.mjs';
+import { type TEvaluateDependent } from '../evaluate/evaluate.mjs';
+export type TFromDependent<If extends TSchema, Then extends TSchema, Else extends TSchema, Evaluated extends TSchema = TEvaluateDependent<If, Then, Else>, Result extends TSchema = TFromType<Evaluated>> = Result;
+export declare function FromDependent<If extends TSchema, Then extends TSchema, Else extends TSchema>(if_: If, then_: Then, else_: Else): TFromDependent<If, Then, Else>;

package/build/type/engine/readonly_object/from_dependent.mjs

@@ -0,0 +1,8 @@
+// deno-fmt-ignore-file
+import { FromType } from './from_type.mjs';
+import { EvaluateDependent } from '../evaluate/evaluate.mjs';
+export function FromDependent(if_, then_, else_) {
+    const evaluated = EvaluateDependent(if_, then_, else_);
+    const result = FromType(evaluated);
+    return result;
+}

package/build/type/engine/readonly_object/from_intersect.d.mts

@@ -1,5 +1,5 @@
 import { type TSchema } from '../../types/schema.mjs';
 import { type TFromType } from './from_type.mjs';
 import { type TEvaluateIntersect } from '../evaluate/evaluate.mjs';
-export type TFromIntersect<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromIntersect<Right, [...Result, TFromType<Left>]> : TEvaluateIntersect<Result>);
+export type TFromIntersect<Types extends TSchema[], Evaluated extends TSchema = TEvaluateIntersect<Types>, Result extends TSchema = TFromType<Evaluated>> = Result;
 export declare function FromIntersect<Types extends TSchema[]>(types: [...Types]): TFromIntersect<Types>;

package/build/type/engine/readonly_object/from_intersect.mjs

@@ -2,6 +2,7 @@
 import { FromType } from './from_type.mjs';
 import { EvaluateIntersect } from '../evaluate/evaluate.mjs';
 export function FromIntersect(types) {
-    const result = types.map(type => FromType(type));
-    return EvaluateIntersect(result);
+    const evaluated = EvaluateIntersect(types);
+    const result = FromType(evaluated);
+    return result;
 }

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

@@ -1,6 +1,7 @@
 import { type TSchema } from '../../types/schema.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 TObject } from '../../types/object.mjs';
 import { type TProperties } from '../../types/properties.mjs';
@@ -8,9 +9,10 @@ import { type TTuple } from '../../types/tuple.mjs';
 import { type TUnion } from '../../types/union.mjs';
 import { type TFromArray } from './from_array.mjs';
 import { type TFromCyclic } from './from_cyclic.mjs';
+import { type TFromDependent } from './from_dependent.mjs';
 import { type TFromIntersect } from './from_intersect.mjs';
 import { type TFromObject } from './from_object.mjs';
 import { type TFromTuple } from './from_tuple.mjs';
 import { type TFromUnion } from './from_union.mjs';
-export type TFromType<Type extends TSchema> = (Type extends TArray<infer Type extends TSchema> ? TFromArray<Type> : Type extends TCyclic<infer Defs extends TProperties, infer Ref extends string> ? TFromCyclic<Defs, Ref> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<Types> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<Properties> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple<Types> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : Type);
+export type TFromType<Type extends TSchema> = (Type extends TArray<infer Type extends TSchema> ? TFromArray<Type> : Type extends TCyclic<infer Defs extends TProperties, infer Ref extends string> ? TFromCyclic<Defs, Ref> : Type extends TDependent<infer If extends TSchema, infer Then extends TSchema, infer Else extends TSchema> ? TFromDependent<If, Then, Else> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<Types> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<Properties> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple<Types> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : Type);
 export declare function FromType<Type extends TSchema>(type: Type): TFromType<Type>;

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

@@ -1,12 +1,14 @@
 // deno-fmt-ignore-file
 import { IsArray } from '../../types/array.mjs';
 import { IsCyclic } from '../../types/cyclic.mjs';
+import { IsDependent } from '../../types/dependent.mjs';
 import { IsIntersect } from '../../types/intersect.mjs';
 import { IsObject } from '../../types/object.mjs';
 import { IsTuple } from '../../types/tuple.mjs';
 import { IsUnion } from '../../types/union.mjs';
 import { FromArray } from './from_array.mjs';
 import { FromCyclic } from './from_cyclic.mjs';
+import { FromDependent } from './from_dependent.mjs';
 import { FromIntersect } from './from_intersect.mjs';
 import { FromObject } from './from_object.mjs';
 import { FromTuple } from './from_tuple.mjs';
@@ -14,9 +16,10 @@ import { FromUnion } from './from_union.mjs';
 export function FromType(type) {
     return (IsArray(type) ? FromArray(type.items) :
         IsCyclic(type) ? FromCyclic(type.$defs, type.$ref) :
-            IsIntersect(type) ? FromIntersect(type.allOf) :
-                IsObject(type) ? FromObject(type.properties) :
-                    IsTuple(type) ? FromTuple(type.items) :
-                        IsUnion(type) ? FromUnion(type.anyOf) :
-                            type);
+            IsDependent(type) ? FromDependent(type.if, type.then, type.else) :
+                IsIntersect(type) ? FromIntersect(type.allOf) :
+                    IsObject(type) ? FromObject(type.properties) :
+                        IsTuple(type) ? FromTuple(type.items) :
+                            IsUnion(type) ? FromUnion(type.anyOf) :
+                                type);
 }

package/build/type/engine/record/from_key_enum.d.mts

@@ -1,6 +1,6 @@
 import { type TSchema } from '../../types/index.mjs';
 import { type TEnumValue } from '../../types/enum.mjs';
-import { type TEnumValuesToUnion } from '../enum/enum_to_union.mjs';
 import { type TFromKey } from './from_key.mjs';
-export type TFromEnumKey<Values extends TEnumValue[], Value extends TSchema, UnionKey extends TSchema = TEnumValuesToUnion<Values>, Result extends TSchema = TFromKey<UnionKey, Value>> = Result;
+import { type TEvaluateEnum } from '../evaluate/evaluate.mjs';
+export type TFromEnumKey<Values extends TEnumValue[], Value extends TSchema, UnionKey extends TSchema = TEvaluateEnum<Values>, Result extends TSchema = TFromKey<UnionKey, Value>> = Result;
 export declare function FromEnumKey<Values extends TEnumValue[], Value extends TSchema>(values: [...Values], value: Value): TFromEnumKey<Values, Value>;

package/build/type/engine/record/from_key_enum.mjs

@@ -1,8 +1,8 @@
 // deno-fmt-ignore-file
-import { EnumValuesToUnion } from '../enum/enum_to_union.mjs';
 import { FromKey } from './from_key.mjs';
+import { EvaluateEnum } from '../evaluate/evaluate.mjs';
 export function FromEnumKey(values, value) {
-    const unionKey = EnumValuesToUnion(values);
+    const unionKey = EvaluateEnum(values);
     const result = FromKey(unionKey, value);
     return result;
 }

package/build/type/engine/record/from_key_template_literal.d.mts

@@ -3,6 +3,6 @@ import { type TRecord } from '../../types/record.mjs';
 import { type TFromKey } from './from_key.mjs';
 import { type TParsePatternIntoTypes } from '../patterns/pattern.mjs';
 import { type TIsTemplateLiteralFinite } from '../template_literal/is_finite.mjs';
-import { type TTemplateLiteralDecode } from '../template_literal/decode.mjs';
-export type TFromTemplateKey<Pattern extends string, Value extends TSchema, Types extends TSchema[] = TParsePatternIntoTypes<Pattern>, Finite extends boolean = TIsTemplateLiteralFinite<Types>, Result extends TSchema = Finite extends true ? TFromKey<TTemplateLiteralDecode<Pattern>, Value> : TRecord<Pattern, Value>> = Result;
+import { type TEvaluateTemplateLiteral } from '../evaluate/evaluate.mjs';
+export type TFromTemplateKey<Pattern extends string, Value extends TSchema, Types extends TSchema[] = TParsePatternIntoTypes<Pattern>, Finite extends boolean = TIsTemplateLiteralFinite<Types>, Result extends TSchema = Finite extends true ? TFromKey<TEvaluateTemplateLiteral<Pattern>, Value> : TRecord<Pattern, Value>> = Result;
 export declare function FromTemplateKey<Pattern extends string, Value extends TSchema>(pattern: Pattern, value: Value): TFromTemplateKey<Pattern, Value>;

package/build/type/engine/record/from_key_template_literal.mjs

@@ -2,11 +2,11 @@
 import { FromKey } from './from_key.mjs';
 import { ParsePatternIntoTypes } from '../patterns/pattern.mjs';
 import { IsTemplateLiteralFinite } from '../template_literal/is_finite.mjs';
-import { TemplateLiteralDecode } from '../template_literal/decode.mjs';
+import { EvaluateTemplateLiteral } from '../evaluate/evaluate.mjs';
 import { CreateRecord } from './record_create.mjs';
 export function FromTemplateKey(pattern, value) {
     const types = ParsePatternIntoTypes(pattern);
     const finite = IsTemplateLiteralFinite(types);
-    const result = finite ? FromKey(TemplateLiteralDecode(pattern), value) : CreateRecord(pattern, value);
+    const result = finite ? FromKey(EvaluateTemplateLiteral(pattern), value) : CreateRecord(pattern, value);
     return result;
 }

package/build/type/engine/required/from_dependent.d.mts

@@ -0,0 +1,5 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TFromType } from './from_type.mjs';
+import { type TEvaluateDependent } from '../evaluate/evaluate.mjs';
+export type TFromDependent<If extends TSchema, Then extends TSchema, Else extends TSchema, Evaluated extends TSchema = TEvaluateDependent<If, Then, Else>, Result extends TSchema = TFromType<Evaluated>> = Result;
+export declare function FromDependent<If extends TSchema, Then extends TSchema, Else extends TSchema>(if_: If, then_: Then, else_: Else): TFromDependent<If, Then, Else>;

package/build/type/engine/required/from_dependent.mjs

@@ -0,0 +1,8 @@
+// deno-fmt-ignore-file
+import { FromType } from './from_type.mjs';
+import { EvaluateDependent } from '../evaluate/evaluate.mjs';
+export function FromDependent(if_, then_, else_) {
+    const evaluated = EvaluateDependent(if_, then_, else_);
+    const result = FromType(evaluated);
+    return result;
+}

package/build/type/engine/required/from_intersect.d.mts

@@ -1,5 +1,5 @@
 import { type TSchema } from '../../types/schema.mjs';
 import { type TFromType } from './from_type.mjs';
 import { type TEvaluateIntersect } from '../evaluate/evaluate.mjs';
-export type TFromIntersect<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromIntersect<Right, [...Result, TFromType<Left>]> : TEvaluateIntersect<Result>);
+export type TFromIntersect<Types extends TSchema[], Evaluated extends TSchema = TEvaluateIntersect<Types>, Result extends TSchema = TFromType<Evaluated>> = Result;
 export declare function FromIntersect<Types extends TSchema[]>(types: [...Types]): TFromIntersect<Types>;

package/build/type/engine/required/from_intersect.mjs

@@ -2,6 +2,7 @@
 import { FromType } from './from_type.mjs';
 import { EvaluateIntersect } from '../evaluate/evaluate.mjs';
 export function FromIntersect(types) {
-    const result = types.map(type => FromType(type));
-    return EvaluateIntersect(result);
+    const evaluated = EvaluateIntersect(types);
+    const result = FromType(evaluated);
+    return result;
 }

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

@@ -1,12 +1,14 @@
 import { type TSchema } from '../../types/schema.mjs';
 import { type TCyclic } from '../../types/cyclic.mjs';
+import { type TDependent } from '../../types/dependent.mjs';
 import { type TIntersect } from '../../types/intersect.mjs';
 import { type TObject } from '../../types/object.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 import { type TUnion } from '../../types/union.mjs';
 import { type TFromCyclic } from './from_cyclic.mjs';
+import { type TFromDependent } from './from_dependent.mjs';
 import { type TFromIntersect } from './from_intersect.mjs';
 import { type TFromUnion } from './from_union.mjs';
 import { type TFromObject } from './from_object.mjs';
-export type TFromType<Type extends TSchema> = (Type extends TCyclic<infer Defs extends TProperties, infer Ref extends string> ? TFromCyclic<Defs, Ref> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<Types> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<Properties> : TObject<{}>);
+export type TFromType<Type extends TSchema> = (Type extends TCyclic<infer Defs extends TProperties, infer Ref extends string> ? TFromCyclic<Defs, Ref> : Type extends TDependent<infer If extends TSchema, infer Then extends TSchema, infer Else extends TSchema> ? TFromDependent<If, Then, Else> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<Types> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<Properties> : TObject<{}>);
 export declare function FromType<Type extends TSchema>(type: Type): TFromType<Type>;