typebox 1.1.39 → 1.2.0

package/build/type/engine/required/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/template_literal/encode.d.mts

@@ -9,7 +9,7 @@ import { type TNumber, NumberPattern } from '../../types/number.mjs';
 import { type TInteger, IntegerPattern } from '../../types/integer.mjs';
 import { type TBoolean } from '../../types/boolean.mjs';
 import { NeverPattern } from '../../types/never.mjs';
-import { type TEnumValuesToVariants } from '../enum/enum_to_union.mjs';
+import { type TEvaluateEnum } from '../evaluate/evaluate.mjs';
 import { type TTemplateLiteralAction } from './instantiate.mjs';
 type TJoinString<Input extends string[], Result extends string = ''> = (Input extends [infer Left extends string, ...infer Right extends string[]] ? Result extends '' ? TJoinString<Right, Left> : TJoinString<Right, `${Result}|${Left}`> : Result);
 type TUnwrapTemplateLiteralPattern<Pattern extends string> = (Pattern extends `^${infer Pattern extends string}$` ? Pattern : never);
@@ -21,7 +21,7 @@ type TEncodeBoolean<Right extends TSchema[], Pattern extends string> = (TEncodeT
 type TEncodeString<Right extends TSchema[], Pattern extends string> = (TEncodeTypes<Right, `${Pattern}${typeof StringPattern}`>);
 type TEncodeTemplateLiteral<TemplatePattern extends string, Right extends TSchema[], Pattern extends string> = (TEncodeTypes<Right, `${Pattern}${TUnwrapTemplateLiteralPattern<TemplatePattern>}`>);
 type TEncodeTemplateLiteralDeferred<Types extends TSchema[], Right extends TSchema[], Pattern extends string, TemplateLiteral extends TSchema = TTemplateLiteralAction<Types>, Result extends TSchema = TEncodeType<TemplateLiteral, Right, Pattern>> = Result;
-type TEncodeEnum<Types extends TEnumValue[], Right extends TSchema[], Pattern extends string, Variants extends TSchema[] = TEnumValuesToVariants<Types>> = TEncodeUnion<Variants, Right, Pattern>;
+type TEncodeEnum<Values extends TEnumValue[], Right extends TSchema[], Pattern extends string, Evaluated extends TSchema = TEvaluateEnum<Values>> = TEncodeType<Evaluated, Right, Pattern>;
 type TEncodeUnion<Types extends TSchema[], Right extends TSchema[], Pattern extends string, Result extends string[] = []> = Types extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TEncodeUnion<Tail, Right, Pattern, [...Result, TEncodeType<Head, [], ''>]> : TEncodeTypes<Right, `${Pattern}(${TJoinString<Result>})`>;
 type TEncodeType<Type extends TSchema, Right extends TSchema[], Pattern extends string> = (Type extends TEnum<infer Values extends TEnumValue[]> ? TEncodeEnum<Values, Right, Pattern> : Type extends TInteger ? TEncodeInteger<Right, Pattern> : Type extends TLiteral<infer Value extends TLiteralValue> ? TEncodeLiteral<Value, Right, Pattern> : Type extends TBigInt ? TEncodeBigInt<Right, Pattern> : Type extends TBoolean ? TEncodeBoolean<Right, Pattern> : Type extends TNumber ? TEncodeNumber<Right, Pattern> : Type extends TString ? TEncodeString<Right, Pattern> : Type extends TTemplateLiteral<infer TemplatePattern extends string> ? TEncodeTemplateLiteral<TemplatePattern, Right, Pattern> : Type extends TTemplateLiteralDeferred<infer Types extends TSchema[]> ? TEncodeTemplateLiteralDeferred<Types, Right, Pattern> : Type extends TUnion<infer Types extends TSchema[]> ? TEncodeUnion<Types, Right, Pattern> : typeof NeverPattern);
 type TEncodeTypes<Types extends TSchema[], Pattern extends string> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TEncodeType<Left, Right, Pattern> : Pattern);

package/build/type/engine/template_literal/encode.mjs

@@ -11,7 +11,7 @@ import { IsInteger, IntegerPattern } from '../../types/integer.mjs';
 import { IsBoolean } from '../../types/boolean.mjs';
 import { NeverPattern } from '../../types/never.mjs';
 import { TemplateLiteralCreate } from './create.mjs';
-import { EnumValuesToVariants } from '../enum/enum_to_union.mjs';
+import { EvaluateEnum } from '../evaluate/evaluate.mjs';
 import { TemplateLiteralAction } from './instantiate.mjs';
 function JoinString(input) {
     return input.join('|');
@@ -45,9 +45,9 @@ function EncodeTemplateLiteralDeferred(types, right, pattern) {
     const result = EncodeType(templateLiteral, right, pattern);
     return result;
 }
-function EncodeEnum(types, right, pattern) {
-    const variants = EnumValuesToVariants(types);
-    return EncodeUnion(variants, right, pattern);
+function EncodeEnum(values, right, pattern) {
+    const evaluated = EvaluateEnum(values);
+    return EncodeType(evaluated, right, pattern);
 }
 function EncodeUnion(types, right, pattern, result = []) {
     return Guard.TakeLeft(types, (head, tail) => EncodeUnion(tail, right, pattern, [...result, EncodeType(head, [], '')]), () => EncodeTypes(right, `${pattern}(${JoinString(result)})`));

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

@@ -0,0 +1,8 @@
+import { type TProperties } from '../../types/properties.mjs';
+import { type TSchema } from '../../types/schema.mjs';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
+import { type TWithDeferred, type TWith } from '../../action/with.mjs';
+export type TWithAction<Type extends TSchema, Options extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TWith<Type, Options> : TWithDeferred<Type, Options>> = Result;
+export declare function WithAction<Type extends TSchema, Options extends TSchema>(type: Type, options: Options): TWithAction<Type, Options>;
+export type TWithInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, Options extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TWithAction<InstantiatedType, Options>;
+export declare function WithInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, Options extends TSchema>(context: Context, state: State, type: Type, options: Options): TWithInstantiate<Context, State, Type, Options>;

package/build/type/engine/{options → with}/instantiate.mjs

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

package/build/type/extends/dependent.d.mts

@@ -0,0 +1,6 @@
+import { type TProperties } from '../types/properties.mjs';
+import { type TSchema } from '../types/schema.mjs';
+import { type TExtendsLeft } from './extends_left.mjs';
+import * as Result from './result.mjs';
+export type TExtendsDependent<Inferred extends TProperties, If extends TSchema, Then extends TSchema, Else extends TSchema, Right extends TSchema> = (TExtendsLeft<Inferred, If, Right> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? TExtendsLeft<Inferred, Then, Right> : TExtendsLeft<Inferred, Else, Right>);
+export declare function ExtendsDependent<Inferred extends TProperties, If extends TSchema, Then extends TSchema, Else extends TSchema, Right extends TSchema>(inferred: Inferred, if_: If, then_: Then, else_: Else, right: Right): TExtendsDependent<Inferred, If, Then, Else, Right>;

package/build/type/extends/dependent.mjs

@@ -0,0 +1,6 @@
+// deno-fmt-ignore-file
+import { ExtendsLeft } from './extends_left.mjs';
+import * as Result from './result.mjs';
+export function ExtendsDependent(inferred, if_, then_, else_, right) {
+    return Result.Match(ExtendsLeft(inferred, if_, right), () => ExtendsLeft(inferred, then_, right), () => ExtendsLeft(inferred, else_, right));
+}

package/build/type/extends/enum.d.mts

@@ -1,7 +1,7 @@
 import { type TSchema } from '../types/schema.mjs';
 import { type TProperties } from '../types/properties.mjs';
-import { type TEnum } from '../types/enum.mjs';
+import { type TEnumValue } from '../types/enum.mjs';
 import { type TExtendsLeft } from './extends_left.mjs';
-import { type TEnumToUnion } from '../engine/enum/index.mjs';
-export type TExtendsEnum<Inferred extends TProperties, Left extends TEnum, Right extends TSchema> = (TExtendsLeft<Inferred, TEnumToUnion<Left>, Right>);
-export declare function ExtendsEnum<Inferred extends TProperties, Left extends TEnum, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsEnum<Inferred, Left, Right>;
+import { type TEvaluateEnum } from '../engine/evaluate/evaluate.mjs';
+export type TExtendsEnum<Inferred extends TProperties, Left extends TEnumValue[], Right extends TSchema, Evaluated extends TSchema = TEvaluateEnum<Left>> = TExtendsLeft<Inferred, Evaluated, Right>;
+export declare function ExtendsEnum<Inferred extends TProperties, Left extends TEnumValue[], Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsEnum<Inferred, Left, Right>;

package/build/type/extends/enum.mjs

@@ -1,6 +1,7 @@
 // deno-fmt-ignore-file
 import { ExtendsLeft } from './extends_left.mjs';
-import { EnumToUnion } from '../engine/enum/index.mjs';
+import { EvaluateEnum } from '../engine/evaluate/evaluate.mjs';
 export function ExtendsEnum(inferred, left, right) {
-    return ExtendsLeft(inferred, EnumToUnion(left), right);
+    const evaluated = EvaluateEnum(left);
+    return ExtendsLeft(inferred, evaluated, right);
 }

package/build/type/extends/extends_left.d.mts

@@ -4,6 +4,7 @@ import { type TExtendsAsyncIterator } from './async_iterator.mjs';
 import { type TExtendsBigInt } from './bigint.mjs';
 import { type TExtendsBoolean } from './boolean.mjs';
 import { type TExtendsConstructor } from './constructor.mjs';
+import { type TExtendsDependent } from './dependent.mjs';
 import { type TExtendsEnum } from './enum.mjs';
 import { type TExtendsFunction } from './function.mjs';
 import { type TExtendsInteger } from './integer.mjs';
@@ -29,6 +30,7 @@ import { type TAsyncIterator } from '../types/async_iterator.mjs';
 import { type TBigInt } from '../types/bigint.mjs';
 import { type TBoolean } from '../types/boolean.mjs';
 import { type TConstructor } from '../types/constructor.mjs';
+import { type TDependent } from '../types/dependent.mjs';
 import { type TEnum, type TEnumValue } from '../types/enum.mjs';
 import { type TFunction } from '../types/function.mjs';
 import { type TInteger } from '../types/integer.mjs';
@@ -51,5 +53,5 @@ import { type TProperties } from '../types/properties.mjs';
 import { type TUnion } from '../types/union.mjs';
 import { type TVoid } from '../types/void.mjs';
 import * as Result from './result.mjs';
-export type TExtendsLeft<Inferred extends TProperties, Left extends TSchema, Right extends TSchema> = (Left extends TAny ? TExtendsAny<Inferred, Left, Right> : Left extends TArray<infer Items extends TSchema> ? TExtendsArray<Inferred, Left, Items, Right> : Left extends TAsyncIterator<infer Type extends TSchema> ? TExtendsAsyncIterator<Inferred, Type, Right> : Left extends TBigInt ? TExtendsBigInt<Inferred, Left, Right> : Left extends TBoolean ? TExtendsBoolean<Inferred, Left, Right> : Left extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TExtendsConstructor<Inferred, Parameters, InstanceType, Right> : Left extends TEnum<infer Values extends TEnumValue[]> ? TExtendsEnum<Inferred, TEnum<Values>, Right> : Left extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TExtendsFunction<Inferred, Parameters, ReturnType, Right> : Left extends TInteger ? TExtendsInteger<Inferred, Left, Right> : Left extends TIntersect<infer Types extends TSchema[]> ? TExtendsIntersect<Inferred, Types, Right> : Left extends TIterator<infer Type extends TSchema> ? TExtendsIterator<Inferred, Type, Right> : Left extends TLiteral ? TExtendsLiteral<Inferred, Left, Right> : Left extends TNever ? TExtendsNever<Inferred, Left, Right> : Left extends TNull ? TExtendsNull<Inferred, Left, Right> : Left extends TNumber ? TExtendsNumber<Inferred, Left, Right> : Left extends TObject<infer Properties extends TProperties> ? TExtendsObject<Inferred, Properties, Right> : Left extends TPromise<infer Type extends TSchema> ? TExtendsPromise<Inferred, Type, Right> : Left extends TString ? TExtendsString<Inferred, Left, Right> : Left extends TSymbol ? TExtendsSymbol<Inferred, Left, Right> : Left extends TTemplateLiteral<infer Pattern extends string> ? TExtendsTemplateLiteral<Inferred, Pattern, Right> : Left extends TTuple<infer Types extends TSchema[]> ? TExtendsTuple<Inferred, Types, Right> : Left extends TUndefined ? TExtendsUndefined<Inferred, Left, Right> : Left extends TUnion<infer Types extends TSchema[]> ? TExtendsUnion<Inferred, Types, Right> : Left extends TUnknown ? TExtendsUnknown<Inferred, Left, Right> : Left extends TVoid ? TExtendsVoid<Inferred, Left, Right> : Result.TExtendsFalse);
+export type TExtendsLeft<Inferred extends TProperties, Left extends TSchema, Right extends TSchema> = (Left extends TAny ? TExtendsAny<Inferred, Left, Right> : Left extends TArray<infer Items extends TSchema> ? TExtendsArray<Inferred, Left, Items, Right> : Left extends TAsyncIterator<infer Type extends TSchema> ? TExtendsAsyncIterator<Inferred, Type, Right> : Left extends TBigInt ? TExtendsBigInt<Inferred, Left, Right> : Left extends TBoolean ? TExtendsBoolean<Inferred, Left, Right> : Left extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TExtendsConstructor<Inferred, Parameters, InstanceType, Right> : Left extends TDependent<infer If extends TSchema, infer Then extends TSchema, infer Else extends TSchema> ? TExtendsDependent<Inferred, If, Then, Else, Right> : Left extends TEnum<infer Values extends TEnumValue[]> ? TExtendsEnum<Inferred, Values, Right> : Left extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TExtendsFunction<Inferred, Parameters, ReturnType, Right> : Left extends TInteger ? TExtendsInteger<Inferred, Left, Right> : Left extends TIntersect<infer Types extends TSchema[]> ? TExtendsIntersect<Inferred, Types, Right> : Left extends TIterator<infer Type extends TSchema> ? TExtendsIterator<Inferred, Type, Right> : Left extends TLiteral ? TExtendsLiteral<Inferred, Left, Right> : Left extends TNever ? TExtendsNever<Inferred, Left, Right> : Left extends TNull ? TExtendsNull<Inferred, Left, Right> : Left extends TNumber ? TExtendsNumber<Inferred, Left, Right> : Left extends TObject<infer Properties extends TProperties> ? TExtendsObject<Inferred, Properties, Right> : Left extends TPromise<infer Type extends TSchema> ? TExtendsPromise<Inferred, Type, Right> : Left extends TString ? TExtendsString<Inferred, Left, Right> : Left extends TSymbol ? TExtendsSymbol<Inferred, Left, Right> : Left extends TTemplateLiteral<infer Pattern extends string> ? TExtendsTemplateLiteral<Inferred, Pattern, Right> : Left extends TTuple<infer Types extends TSchema[]> ? TExtendsTuple<Inferred, Types, Right> : Left extends TUndefined ? TExtendsUndefined<Inferred, Left, Right> : Left extends TUnion<infer Types extends TSchema[]> ? TExtendsUnion<Inferred, Types, Right> : Left extends TUnknown ? TExtendsUnknown<Inferred, Left, Right> : Left extends TVoid ? TExtendsVoid<Inferred, Left, Right> : Result.TExtendsFalse);
 export declare function ExtendsLeft<Inferred extends TProperties, Left extends TSchema, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsLeft<Inferred, Left, Right>;

package/build/type/extends/extends_left.mjs

@@ -5,6 +5,7 @@ import { ExtendsAsyncIterator } from './async_iterator.mjs';
 import { ExtendsBigInt } from './bigint.mjs';
 import { ExtendsBoolean } from './boolean.mjs';
 import { ExtendsConstructor } from './constructor.mjs';
+import { ExtendsDependent } from './dependent.mjs';
 import { ExtendsEnum } from './enum.mjs';
 import { ExtendsFunction } from './function.mjs';
 import { ExtendsInteger } from './integer.mjs';
@@ -33,6 +34,7 @@ import { IsAsyncIterator } from '../types/async_iterator.mjs';
 import { IsBigInt } from '../types/bigint.mjs';
 import { IsBoolean } from '../types/boolean.mjs';
 import { IsConstructor } from '../types/constructor.mjs';
+import { IsDependent } from '../types/dependent.mjs';
 import { IsEnum } from '../types/enum.mjs';
 import { IsFunction } from '../types/function.mjs';
 import { IsInteger } from '../types/integer.mjs';
@@ -60,24 +62,25 @@ export function ExtendsLeft(inferred, left, right) {
                 IsBigInt(left) ? ExtendsBigInt(inferred, left, right) :
                     IsBoolean(left) ? ExtendsBoolean(inferred, left, right) :
                         IsConstructor(left) ? ExtendsConstructor(inferred, left.parameters, left.instanceType, right) :
-                            IsEnum(left) ? ExtendsEnum(inferred, left, right) :
-                                IsFunction(left) ? ExtendsFunction(inferred, left.parameters, left.returnType, right) :
-                                    IsInteger(left) ? ExtendsInteger(inferred, left, right) :
-                                        IsIntersect(left) ? ExtendsIntersect(inferred, left.allOf, right) :
-                                            IsIterator(left) ? ExtendsIterator(inferred, left.iteratorItems, right) :
-                                                IsLiteral(left) ? ExtendsLiteral(inferred, left, right) :
-                                                    IsNever(left) ? ExtendsNever(inferred, left, right) :
-                                                        IsNull(left) ? ExtendsNull(inferred, left, right) :
-                                                            IsNumber(left) ? ExtendsNumber(inferred, left, right) :
-                                                                IsObject(left) ? ExtendsObject(inferred, left.properties, right) :
-                                                                    IsPromise(left) ? ExtendsPromise(inferred, left.item, right) :
-                                                                        IsString(left) ? ExtendsString(inferred, left, right) :
-                                                                            IsSymbol(left) ? ExtendsSymbol(inferred, left, right) :
-                                                                                IsTemplateLiteral(left) ? ExtendsTemplateLiteral(inferred, left.pattern, right) :
-                                                                                    IsTuple(left) ? ExtendsTuple(inferred, left.items, right) :
-                                                                                        IsUndefined(left) ? ExtendsUndefined(inferred, left, right) :
-                                                                                            IsUnion(left) ? ExtendsUnion(inferred, left.anyOf, right) :
-                                                                                                IsUnknown(left) ? ExtendsUnknown(inferred, left, right) :
-                                                                                                    IsVoid(left) ? ExtendsVoid(inferred, left, right) :
-                                                                                                        Result.ExtendsFalse());
+                            IsDependent(left) ? ExtendsDependent(inferred, left.if, left.then, left.else, right) :
+                                IsEnum(left) ? ExtendsEnum(inferred, left.enum, right) :
+                                    IsFunction(left) ? ExtendsFunction(inferred, left.parameters, left.returnType, right) :
+                                        IsInteger(left) ? ExtendsInteger(inferred, left, right) :
+                                            IsIntersect(left) ? ExtendsIntersect(inferred, left.allOf, right) :
+                                                IsIterator(left) ? ExtendsIterator(inferred, left.iteratorItems, right) :
+                                                    IsLiteral(left) ? ExtendsLiteral(inferred, left, right) :
+                                                        IsNever(left) ? ExtendsNever(inferred, left, right) :
+                                                            IsNull(left) ? ExtendsNull(inferred, left, right) :
+                                                                IsNumber(left) ? ExtendsNumber(inferred, left, right) :
+                                                                    IsObject(left) ? ExtendsObject(inferred, left.properties, right) :
+                                                                        IsPromise(left) ? ExtendsPromise(inferred, left.item, right) :
+                                                                            IsString(left) ? ExtendsString(inferred, left, right) :
+                                                                                IsSymbol(left) ? ExtendsSymbol(inferred, left, right) :
+                                                                                    IsTemplateLiteral(left) ? ExtendsTemplateLiteral(inferred, left.pattern, right) :
+                                                                                        IsTuple(left) ? ExtendsTuple(inferred, left.items, right) :
+                                                                                            IsUndefined(left) ? ExtendsUndefined(inferred, left, right) :
+                                                                                                IsUnion(left) ? ExtendsUnion(inferred, left.anyOf, right) :
+                                                                                                    IsUnknown(left) ? ExtendsUnknown(inferred, left, right) :
+                                                                                                        IsVoid(left) ? ExtendsVoid(inferred, left, right) :
+                                                                                                            Result.ExtendsFalse());
 }

package/build/type/extends/extends_right.d.mts

@@ -2,6 +2,7 @@ import { Memory } from '../../system/memory/index.mjs';
 import { type TSchema } from '../types/schema.mjs';
 import { type TProperties } from '../types/properties.mjs';
 import { type TAny } from '../types/any.mjs';
+import { type TDependent } from '../types/dependent.mjs';
 import { type TEnum, type TEnumValue } from '../types/enum.mjs';
 import { type TInfer } from '../types/infer.mjs';
 import { type TIntersect } from '../types/intersect.mjs';
@@ -10,16 +11,17 @@ import { type TUnion } from '../types/union.mjs';
 import { type TUnknown } from '../types/unknown.mjs';
 import { type TExtendsLeft } from './extends_left.mjs';
 import * as Result from './result.mjs';
-import { type TTemplateLiteralDecode } from '../engine/template_literal/decode.mjs';
-import { type TEnumValuesToUnion } from '../engine/enum/index.mjs';
+import { type TEvaluateEnum } from '../engine/evaluate/evaluate.mjs';
+import { type TEvaluateTemplateLiteral } from '../engine/evaluate/evaluate.mjs';
 type TExtendsRightInfer<Inferred extends TProperties, Name extends string, Left extends TSchema, Right extends TSchema, Result extends Result.TResult = (TExtendsLeft<Inferred, Left, Right> extends Result.TExtendsTrueLike<infer CheckInferred extends TProperties> ? Result.TExtendsTrue<Memory.TAssign<Memory.TAssign<Inferred, CheckInferred>, {
     [_ in Name]: Left;
 }>> : Result.TExtendsFalse)> = Result;
 type TExtendsRightAny<Inferred extends TProperties, _Left extends TSchema, Result extends Result.TResult = Result.TExtendsTrue<Inferred>> = Result;
-type TExtendsRightEnum<Inferred extends TProperties, Left extends TSchema, Right extends TEnumValue[], Union extends TSchema = TEnumValuesToUnion<Right>> = TExtendsLeft<Inferred, Left, Union>;
+type TExtendsRightDependent<Inferred extends TProperties, Left extends TSchema, If extends TSchema, Then extends TSchema, Else extends TSchema, Result extends Result.TResult = TExtendsLeft<Inferred, Left, If> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? (TExtendsLeft<Inferred, Left, Then> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? Result.TExtendsTrue<Inferred> : Result.TExtendsFalse) : (TExtendsLeft<Inferred, Left, Else> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? Result.TExtendsTrue<Inferred> : Result.TExtendsFalse)> = Result;
+type TExtendsRightEnum<Inferred extends TProperties, Left extends TSchema, Right extends TEnumValue[], Evaluated extends TSchema = TEvaluateEnum<Right>> = TExtendsLeft<Inferred, Left, Evaluated>;
 type TExtendsRightIntersect<Inferred extends TProperties, Left extends TSchema, Right extends TSchema[]> = (Right extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExtendsLeft<Inferred, Left, Head> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? TExtendsRightIntersect<Inferred, Left, Tail> : Result.TExtendsFalse : Result.TExtendsTrue<Inferred>);
-type TExtendsRightTemplateLiteral<Inferred extends TProperties, Left extends TSchema, Right extends string, Decoded extends TSchema = TTemplateLiteralDecode<Right>> = TExtendsLeft<Inferred, Left, Decoded>;
+type TExtendsRightTemplateLiteral<Inferred extends TProperties, Left extends TSchema, Right extends string, Evaluated extends TSchema = TEvaluateTemplateLiteral<Right>> = TExtendsLeft<Inferred, Left, Evaluated>;
 type TExtendsRightUnion<Inferred extends TProperties, Left extends TSchema, Right extends TSchema[]> = (Right extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExtendsLeft<Inferred, Left, Head> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? Result.TExtendsTrue<Inferred> : TExtendsRightUnion<Inferred, Left, Tail> : Result.TExtendsFalse);
-export type TExtendsRight<Inferred extends TProperties, Left extends TSchema, Right extends TSchema> = (Right extends TAny ? TExtendsRightAny<Inferred, Left> : Right extends TEnum<infer Values extends TEnumValue[]> ? TExtendsRightEnum<Inferred, Left, Values> : Right extends TInfer<infer Name extends string, infer Type extends TSchema> ? TExtendsRightInfer<Inferred, Name, Left, Type> : Right extends TTemplateLiteral<infer Pattern extends string> ? TExtendsRightTemplateLiteral<Inferred, Left, Pattern> : Right extends TIntersect<infer Types extends TSchema[]> ? TExtendsRightIntersect<Inferred, Left, Types> : Right extends TUnion<infer Types extends TSchema[]> ? TExtendsRightUnion<Inferred, Left, Types> : Right extends TUnknown ? Result.TExtendsTrue<Inferred> : Result.TExtendsFalse);
+export type TExtendsRight<Inferred extends TProperties, Left extends TSchema, Right extends TSchema> = (Right extends TAny ? TExtendsRightAny<Inferred, Left> : Right extends TDependent<infer If extends TSchema, infer Then extends TSchema, infer Else extends TSchema> ? TExtendsRightDependent<Inferred, Left, If, Then, Else> : Right extends TEnum<infer Values extends TEnumValue[]> ? TExtendsRightEnum<Inferred, Left, Values> : Right extends TInfer<infer Name extends string, infer Type extends TSchema> ? TExtendsRightInfer<Inferred, Name, Left, Type> : Right extends TTemplateLiteral<infer Pattern extends string> ? TExtendsRightTemplateLiteral<Inferred, Left, Pattern> : Right extends TIntersect<infer Types extends TSchema[]> ? TExtendsRightIntersect<Inferred, Left, Types> : Right extends TUnion<infer Types extends TSchema[]> ? TExtendsRightUnion<Inferred, Left, Types> : Right extends TUnknown ? Result.TExtendsTrue<Inferred> : Result.TExtendsFalse);
 export declare function ExtendsRight<Inferred extends TProperties, Left extends TSchema, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsRight<Inferred, Left, Right>;
 export {};

package/build/type/extends/extends_right.mjs

@@ -2,6 +2,7 @@
 import { Guard } from '../../guard/index.mjs';
 import { Memory } from '../../system/memory/index.mjs';
 import { IsAny } from '../types/any.mjs';
+import { IsDependent } from '../types/dependent.mjs';
 import { IsEnum } from '../types/enum.mjs';
 import { IsInfer } from '../types/infer.mjs';
 import { IsIntersect } from '../types/intersect.mjs';
@@ -10,35 +11,39 @@ import { IsUnion } from '../types/union.mjs';
 import { IsUnknown } from '../types/unknown.mjs';
 import { ExtendsLeft } from './extends_left.mjs';
 import * as Result from './result.mjs';
-import { TemplateLiteralDecode } from '../engine/template_literal/decode.mjs';
-import { EnumValuesToUnion } from '../engine/enum/index.mjs';
+import { EvaluateEnum } from '../engine/evaluate/evaluate.mjs';
+import { EvaluateTemplateLiteral } from '../engine/evaluate/evaluate.mjs';
 function ExtendsRightInfer(inferred, name, left, right) {
     return Result.Match(ExtendsLeft(inferred, left, right), checkInferred => Result.ExtendsTrue(Memory.Assign(Memory.Assign(inferred, checkInferred), { [name]: left })), () => Result.ExtendsFalse());
 }
 function ExtendsRightAny(inferred, _left) {
     return Result.ExtendsTrue(inferred);
 }
+function ExtendsRightDependent(inferred, left, if_, then_, else_) {
+    return Result.Match(ExtendsLeft(inferred, left, if_), inferred => Result.Match(ExtendsLeft(inferred, left, then_), inferred => Result.ExtendsTrue(inferred), () => Result.ExtendsFalse()), () => Result.Match(ExtendsLeft(inferred, left, else_), inferred => Result.ExtendsTrue(inferred), () => Result.ExtendsFalse()));
+}
 function ExtendsRightEnum(inferred, left, right) {
-    const union = EnumValuesToUnion(right);
-    return ExtendsLeft(inferred, left, union);
+    const evaluated = EvaluateEnum(right);
+    return ExtendsLeft(inferred, left, evaluated);
 }
 function ExtendsRightIntersect(inferred, left, right) {
     return Guard.TakeLeft(right, (head, tail) => Result.Match(ExtendsLeft(inferred, left, head), inferred => ExtendsRightIntersect(inferred, left, tail), () => Result.ExtendsFalse()), () => Result.ExtendsTrue(inferred));
 }
 function ExtendsRightTemplateLiteral(inferred, left, right) {
-    const decoded = TemplateLiteralDecode(right);
-    return ExtendsLeft(inferred, left, decoded);
+    const evaluated = EvaluateTemplateLiteral(right);
+    return ExtendsLeft(inferred, left, evaluated);
 }
 function ExtendsRightUnion(inferred, left, right) {
     return Guard.TakeLeft(right, (head, tail) => Result.Match(ExtendsLeft(inferred, left, head), inferred => Result.ExtendsTrue(inferred), () => ExtendsRightUnion(inferred, left, tail)), () => Result.ExtendsFalse());
 }
 export function ExtendsRight(inferred, left, right) {
     return (IsAny(right) ? ExtendsRightAny(inferred, left) :
-        IsEnum(right) ? ExtendsRightEnum(inferred, left, right.enum) :
-            IsInfer(right) ? ExtendsRightInfer(inferred, right.name, left, right.extends) :
-                IsIntersect(right) ? ExtendsRightIntersect(inferred, left, right.allOf) :
-                    IsTemplateLiteral(right) ? ExtendsRightTemplateLiteral(inferred, left, right.pattern) :
-                        IsUnion(right) ? ExtendsRightUnion(inferred, left, right.anyOf) :
-                            IsUnknown(right) ? Result.ExtendsTrue(inferred) :
-                                Result.ExtendsFalse());
+        IsDependent(right) ? ExtendsRightDependent(inferred, left, right.if, right.then, right.else) :
+            IsEnum(right) ? ExtendsRightEnum(inferred, left, right.enum) :
+                IsInfer(right) ? ExtendsRightInfer(inferred, right.name, left, right.extends) :
+                    IsIntersect(right) ? ExtendsRightIntersect(inferred, left, right.allOf) :
+                        IsTemplateLiteral(right) ? ExtendsRightTemplateLiteral(inferred, left, right.pattern) :
+                            IsUnion(right) ? ExtendsRightUnion(inferred, left, right.anyOf) :
+                                IsUnknown(right) ? Result.ExtendsTrue(inferred) :
+                                    Result.ExtendsFalse());
 }

package/build/type/extends/template_literal.d.mts

@@ -1,6 +1,6 @@
 import { type TSchema } from '../types/schema.mjs';
 import { type TProperties } from '../types/properties.mjs';
 import { type TExtendsLeft } from './extends_left.mjs';
-import { type TTemplateLiteralDecode } from '../engine/template_literal/decode.mjs';
-export type TExtendsTemplateLiteral<Inferred extends TProperties, Left extends string, Right extends TSchema, Decoded extends TSchema = TTemplateLiteralDecode<Left>> = TExtendsLeft<Inferred, Decoded, Right>;
-export declare function ExtendsTemplateLiteral<Inferred extends TProperties, Left extends string, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsTemplateLiteral<Inferred, Left, Right>;
+import { type TEvaluateTemplateLiteral } from '../engine/evaluate/evaluate.mjs';
+export type TExtendsTemplateLiteral<Inferred extends TProperties, Pattern extends string, Right extends TSchema, Evaluated extends TSchema = TEvaluateTemplateLiteral<Pattern>> = TExtendsLeft<Inferred, Evaluated, Right>;
+export declare function ExtendsTemplateLiteral<Inferred extends TProperties, Pattern extends string, Right extends TSchema>(inferred: Inferred, left: Pattern, right: Right): TExtendsTemplateLiteral<Inferred, Pattern, Right>;

package/build/type/extends/template_literal.mjs

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
 import { ExtendsLeft } from './extends_left.mjs';
-import { TemplateLiteralDecode } from '../engine/template_literal/decode.mjs';
+import { EvaluateTemplateLiteral } from '../engine/evaluate/evaluate.mjs';
 export function ExtendsTemplateLiteral(inferred, left, right) {
-    const decoded = TemplateLiteralDecode(left);
-    return ExtendsLeft(inferred, decoded, right);
+    const evaluated = EvaluateTemplateLiteral(left);
+    return ExtendsLeft(inferred, evaluated, right);
 }

package/build/type/script/mapping.d.mts

@@ -52,9 +52,6 @@ type TIntrinsicOrCall<Target extends string, Parameters extends T.TSchema[]> = (
 ] extends ['Omit', [infer Type extends T.TSchema, infer Indexer extends T.TSchema]] ? C.TOmitDeferred<Type, Indexer> : [
     Target,
     Parameters
-] extends ['Options', [infer Type extends T.TSchema, infer Options extends T.TSchema]] ? C.TOptionsDeferred<Type, Options> : [
-    Target,
-    Parameters
 ] extends ['Parameters', [infer Type extends T.TSchema]] ? C.TParametersDeferred<Type> : [
     Target,
     Parameters
@@ -164,11 +161,11 @@ export type TExtendsMapping<Input extends [unknown, unknown, unknown, unknown, u
 export declare function ExtendsMapping(input: [unknown, unknown, unknown, unknown, unknown, unknown] | []): unknown;
 export type TBaseMapping<Input extends [unknown, unknown, unknown] | unknown> = (Input extends ['(', infer Type extends T.TSchema, ')'] ? Type : Input extends infer Type extends T.TSchema ? Type : never);
 export declare function BaseMapping(input: [unknown, unknown, unknown] | unknown): unknown;
-export type TWithMapping<Input extends [unknown, unknown] | []> = (Input extends ['with', infer Options extends Record<PropertyKey, unknown>] ? Options : []);
+export type TWithMapping<Input extends [unknown, unknown] | []> = (Input extends ['with', infer JsonObject extends Record<PropertyKey, unknown>] ? JsonObject : []);
 export declare function WithMapping(input: [unknown, unknown] | []): unknown;
 type TFactorIndexArray<Type extends T.TSchema, IndexArray extends unknown[]> = (IndexArray extends [infer Left extends T.TSchema[], ...infer Right extends unknown[]] ? (Left extends [infer Indexer extends T.TSchema] ? TFactorIndexArray<C.TIndexDeferred<Type, Indexer>, Right> : Left extends [] ? TFactorIndexArray<T.TArray<Type>, Right> : T.TNever) : Type);
 type TFactorExtends<Type extends T.TSchema, Extends extends unknown[]> = (Extends extends [infer Right extends T.TSchema, infer True extends T.TSchema, infer False extends T.TSchema] ? C.TConditionalDeferred<Type, Right, True, False> : Type);
-type TFactorWith<Type extends T.TSchema, With extends unknown> = (With extends Record<PropertyKey, unknown> ? C.TOptionsDeferred<Type, With> : Type);
+type TFactorWith<Type extends T.TSchema, With extends unknown> = (With extends Record<PropertyKey, unknown> ? C.TWithDeferred<Type, With> : Type);
 export type TFactorMapping<Input extends [unknown, unknown, unknown, unknown, unknown]> = (Input extends [infer KeyOf extends boolean, infer Type extends T.TSchema, infer IndexArray extends unknown[], infer Extend extends unknown[], infer WithClause extends unknown] ? TFactorWith<KeyOf extends true ? TFactorExtends<C.TKeyOfDeferred<TFactorIndexArray<Type, IndexArray>>, Extend> : TFactorExtends<TFactorIndexArray<Type, IndexArray>, Extend>, WithClause> : never);
 export declare function FactorMapping(input: [unknown, unknown, unknown, unknown, unknown]): unknown;
 type TExprBinaryMapping<Left extends T.TSchema, Rest extends unknown[]> = (Rest extends [infer Operator extends unknown, infer Right extends T.TSchema, infer Next extends unknown[]] ? (TExprBinaryMapping<Right, Next> extends infer Schema extends T.TSchema ? (Operator extends '&' ? (Schema extends T.TIntersect<infer Types extends T.TSchema[]> ? T.TIntersect<[Left, ...Types]> : T.TIntersect<[Left, Schema]>) : Operator extends '|' ? (Schema extends T.TUnion<infer Types extends T.TSchema[]> ? T.TUnion<[Left, ...Types]> : T.TUnion<[Left, Schema]>) : never) : never) : Left);
@@ -279,10 +276,10 @@ export type TMappedAsMapping<Input extends [unknown, unknown] | []> = (Input ext
 export declare function MappedAsMapping(input: [unknown, unknown] | []): unknown;
 export type TMappedMapping<Input extends [unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown]> = (Input extends ['{', infer Readonly extends TModifierOperation, '[', infer Key extends string, 'in', infer Type extends T.TSchema, infer As extends T.TSchema[], ']', infer Optional extends TModifierOperation, ':', infer Property extends T.TSchema, null, '}'] ? (As extends [infer As extends T.TSchema] ? C.TMappedDeferred<T.TIdentifier<Key>, Type, As, TApplyReadonly<Readonly, TApplyOptional<Optional, Property>>> : C.TMappedDeferred<T.TIdentifier<Key>, Type, T.TRef<Key>, TApplyReadonly<Readonly, TApplyOptional<Optional, Property>>>) : never);
 export declare function MappedMapping(input: [unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown]): unknown;
+export type TDependentMapping<Input extends [unknown, unknown, unknown, unknown, unknown, unknown] | [unknown, unknown, unknown, unknown]> = (Input extends ['if', infer If extends T.TSchema, 'then', infer Then extends T.TSchema, 'else', infer Else extends T.TSchema] ? T.TDependent<If, Then, Else> : Input extends ['if', infer If extends T.TSchema, 'then', infer Then extends T.TSchema] ? T.TDependent<If, Then, T.TUnknown> : never);
+export declare function DependentMapping(input: [unknown, unknown, unknown, unknown, unknown, unknown] | [unknown, unknown, unknown, unknown]): unknown;
 export type TReferenceMapping<Input extends string, Result extends T.TSchema = T.TRef<Input>> = Result;
 export declare function ReferenceMapping(input: string): unknown;
-export type TOptionsMapping<Input extends [unknown, unknown, unknown, unknown, unknown, unknown]> = (Input extends ['Options', '<', infer Type extends T.TSchema, ',', infer Options extends T.TSchemaOptions, '>'] ? C.TOptionsDeferred<Type, Options> : never);
-export declare function OptionsMapping(input: [unknown, unknown, unknown, unknown, unknown, unknown]): unknown;
 export type TJsonNumberMapping<Input extends string> = (Input extends `${infer Value extends number}` ? Value : never);
 export declare function JsonNumberMapping(input: string): unknown;
 export type TJsonBooleanMapping<Input extends 'true' | 'false'> = (Input extends 'true' ? true : false);

package/build/type/script/mapping.mjs

@@ -23,18 +23,17 @@ function IntrinsicOrCall(ref, parameters) {
                                                     Guard.IsEqual(ref, 'Lowercase') ? C.LowercaseDeferred(parameters[0]) :
                                                         Guard.IsEqual(ref, 'NonNullable') ? C.NonNullableDeferred(parameters[0]) :
                                                             Guard.IsEqual(ref, 'Omit') ? C.OmitDeferred(parameters[0], parameters[1]) :
-                                                                Guard.IsEqual(ref, 'Options') ? C.OptionsDeferred(parameters[0], parameters[1]) :
-                                                                    Guard.IsEqual(ref, 'Parameters') ? C.ParametersDeferred(parameters[0]) :
-                                                                        Guard.IsEqual(ref, 'Partial') ? C.PartialDeferred(parameters[0]) :
-                                                                            Guard.IsEqual(ref, 'Pick') ? C.PickDeferred(parameters[0], parameters[1]) :
-                                                                                Guard.IsEqual(ref, 'Readonly') ? C.ReadonlyObjectDeferred(parameters[0]) :
-                                                                                    Guard.IsEqual(ref, 'KeyOf') ? C.KeyOfDeferred(parameters[0]) :
-                                                                                        Guard.IsEqual(ref, 'Record') ? T.RecordDeferred(parameters[0], parameters[1]) :
-                                                                                            Guard.IsEqual(ref, 'Required') ? C.RequiredDeferred(parameters[0]) :
-                                                                                                Guard.IsEqual(ref, 'ReturnType') ? C.ReturnTypeDeferred(parameters[0]) :
-                                                                                                    Guard.IsEqual(ref, 'Uncapitalize') ? C.UncapitalizeDeferred(parameters[0]) :
-                                                                                                        Guard.IsEqual(ref, 'Uppercase') ? C.UppercaseDeferred(parameters[0]) :
-                                                                                                            T.CallConstruct(T.Ref(ref), parameters));
+                                                                Guard.IsEqual(ref, 'Parameters') ? C.ParametersDeferred(parameters[0]) :
+                                                                    Guard.IsEqual(ref, 'Partial') ? C.PartialDeferred(parameters[0]) :
+                                                                        Guard.IsEqual(ref, 'Pick') ? C.PickDeferred(parameters[0], parameters[1]) :
+                                                                            Guard.IsEqual(ref, 'Readonly') ? C.ReadonlyObjectDeferred(parameters[0]) :
+                                                                                Guard.IsEqual(ref, 'KeyOf') ? C.KeyOfDeferred(parameters[0]) :
+                                                                                    Guard.IsEqual(ref, 'Record') ? T.RecordDeferred(parameters[0], parameters[1]) :
+                                                                                        Guard.IsEqual(ref, 'Required') ? C.RequiredDeferred(parameters[0]) :
+                                                                                            Guard.IsEqual(ref, 'ReturnType') ? C.ReturnTypeDeferred(parameters[0]) :
+                                                                                                Guard.IsEqual(ref, 'Uncapitalize') ? C.UncapitalizeDeferred(parameters[0]) :
+                                                                                                    Guard.IsEqual(ref, 'Uppercase') ? C.UppercaseDeferred(parameters[0]) :
+                                                                                                        T.CallConstruct(T.Ref(ref), parameters));
     // deno-coverage-ignore-stop
 }
 // ------------------------------------------------------------------
@@ -206,7 +205,7 @@ function FactorExtends(type, extend) {
 function FactorWith(type, withClause) {
     return Guard.IsArray(withClause) && Guard.IsEqual(withClause.length, 0)
         ? type
-        : C.OptionsDeferred(type, withClause);
+        : C.WithDeferred(type, withClause);
 }
 export function FactorMapping(input) {
     const [keyOf, type, indexArray, extend, withClause] = input;
@@ -413,12 +412,13 @@ export function MappedMapping(input) {
         ? C.MappedDeferred(T.Identifier(input[3]), input[5], input[6][0], ApplyReadonly(input[1], ApplyOptional(input[8], input[10])))
         : C.MappedDeferred(T.Identifier(input[3]), input[5], T.Ref(input[3]), ApplyReadonly(input[1], ApplyOptional(input[8], input[10]))));
 }
+export function DependentMapping(input) {
+    return (Guard.IsEqual(input.length, 6) ? T.Dependent(input[1], input[3], input[5]) :
+        T.Dependent(input[1], input[3], T.Unknown()));
+}
 export function ReferenceMapping(input) {
     return T.Ref(input);
 }
-export function OptionsMapping(input) {
-    return C.OptionsDeferred(input[2], input[4]);
-}
 export function JsonNumberMapping(input) {
     return parseFloat(input);
 }

package/build/type/script/parser.d.mts

@@ -42,7 +42,7 @@ export type TKeyOf<Input extends string> = ((Token.TConst<'keyof', Input> extend
 export type TIndexArray_0<Input extends string, Result extends unknown[] = []> = ((Token.TConst<'[', Input> extends [infer _0, infer Input extends string] ? (TType<Input> extends [infer _1, infer Input extends string] ? (Token.TConst<']', Input> extends [infer _2, infer Input extends string] ? [[_0, _1, _2], Input] : []) : []) : []) extends [infer _0, infer Input extends string] ? [_0, Input] : (Token.TConst<'[', Input> extends [infer _0, infer Input extends string] ? (Token.TConst<']', Input> extends [infer _1, infer Input extends string] ? [[_0, _1], Input] : []) : []) extends [infer _0, infer Input extends string] ? [_0, Input] : []) extends [infer _0, infer Input extends string] ? TIndexArray_0<Input, [...Result, _0]> : [Result, Input];
 export type TIndexArray<Input extends string> = TIndexArray_0<Input> extends [infer _0 extends ([unknown, unknown, unknown] | [unknown, unknown])[], infer Input extends string] ? [S.TIndexArrayMapping<_0>, Input] : [];
 export type TExtends<Input extends string> = ((Token.TConst<'extends', Input> extends [infer _0, infer Input extends string] ? (TType<Input> extends [infer _1, infer Input extends string] ? (Token.TConst<'?', Input> extends [infer _2, infer Input extends string] ? (TType<Input> extends [infer _3, infer Input extends string] ? (Token.TConst<':', Input> extends [infer _4, infer Input extends string] ? (TType<Input> extends [infer _5, infer Input extends string] ? [[_0, _1, _2, _3, _4, _5], Input] : []) : []) : []) : []) : []) : []) extends [infer _0, infer Input extends string] ? [_0, Input] : [[], Input] extends [infer _0, infer Input extends string] ? [_0, Input] : []) extends [infer _0 extends [unknown, unknown, unknown, unknown, unknown, unknown] | [], infer Input extends string] ? [S.TExtendsMapping<_0>, Input] : [];
-export type TBase<Input extends string> = ((Token.TConst<'(', Input> extends [infer _0, infer Input extends string] ? (TType<Input> extends [infer _1, infer Input extends string] ? (Token.TConst<')', Input> extends [infer _2, infer Input extends string] ? [[_0, _1, _2], Input] : []) : []) : []) extends [infer _0, infer Input extends string] ? [_0, Input] : TKeyword<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : T_Object_<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : TTuple<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : TTemplateLiteral<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : TLiteral<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : TConstructor<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : T_Function_<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : TMapped<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : TOptions<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : TGenericCall<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : TReference<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : []) extends [infer _0 extends [unknown, unknown, unknown] | unknown, infer Input extends string] ? [S.TBaseMapping<_0>, Input] : [];
+export type TBase<Input extends string> = ((Token.TConst<'(', Input> extends [infer _0, infer Input extends string] ? (TType<Input> extends [infer _1, infer Input extends string] ? (Token.TConst<')', Input> extends [infer _2, infer Input extends string] ? [[_0, _1, _2], Input] : []) : []) : []) extends [infer _0, infer Input extends string] ? [_0, Input] : TKeyword<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : T_Object_<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : TTuple<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : TTemplateLiteral<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : TLiteral<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : TConstructor<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : T_Function_<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : TMapped<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : TDependent<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : TGenericCall<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : TReference<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : []) extends [infer _0 extends [unknown, unknown, unknown] | unknown, infer Input extends string] ? [S.TBaseMapping<_0>, Input] : [];
 export type TWith<Input extends string> = ((Token.TConst<'with', Input> extends [infer _0, infer Input extends string] ? (TJsonObject<Input> extends [infer _1, infer Input extends string] ? [[_0, _1], Input] : []) : []) extends [infer _0, infer Input extends string] ? [_0, Input] : [[], Input] extends [infer _0, infer Input extends string] ? [_0, Input] : []) extends [infer _0 extends [unknown, unknown] | [], infer Input extends string] ? [S.TWithMapping<_0>, Input] : [];
 export type TFactor<Input extends string> = (TKeyOf<Input> extends [infer _0, infer Input extends string] ? (TBase<Input> extends [infer _1, infer Input extends string] ? (TIndexArray<Input> extends [infer _2, infer Input extends string] ? (TExtends<Input> extends [infer _3, infer Input extends string] ? (TWith<Input> extends [infer _4, infer Input extends string] ? [[_0, _1, _2, _3, _4], Input] : []) : []) : []) : []) : []) extends [infer _0 extends [unknown, unknown, unknown, unknown, unknown], infer Input extends string] ? [S.TFactorMapping<_0>, Input] : [];
 export type TExprTermTail<Input extends string> = ((Token.TConst<'&', Input> extends [infer _0, infer Input extends string] ? (TFactor<Input> extends [infer _1, infer Input extends string] ? (TExprTermTail<Input> extends [infer _2, infer Input extends string] ? [[_0, _1, _2], Input] : []) : []) : []) extends [infer _0, infer Input extends string] ? [_0, Input] : [[], Input] extends [infer _0, infer Input extends string] ? [_0, Input] : []) extends [infer _0 extends [unknown, unknown, unknown] | [], infer Input extends string] ? [S.TExprTermTailMapping<_0>, Input] : [];
@@ -90,8 +90,8 @@ export type TMappedReadonly<Input extends string> = ((Token.TConst<'+', Input> e
 export type TMappedOptional<Input extends string> = ((Token.TConst<'+', Input> extends [infer _0, infer Input extends string] ? (Token.TConst<'?', Input> extends [infer _1, infer Input extends string] ? [[_0, _1], Input] : []) : []) extends [infer _0, infer Input extends string] ? [_0, Input] : (Token.TConst<'-', Input> extends [infer _0, infer Input extends string] ? (Token.TConst<'?', Input> extends [infer _1, infer Input extends string] ? [[_0, _1], Input] : []) : []) extends [infer _0, infer Input extends string] ? [_0, Input] : (Token.TConst<'?', Input> extends [infer _0, infer Input extends string] ? [[_0], Input] : []) extends [infer _0, infer Input extends string] ? [_0, Input] : [[], Input] extends [infer _0, infer Input extends string] ? [_0, Input] : []) extends [infer _0 extends [unknown, unknown] | [unknown] | [], infer Input extends string] ? [S.TMappedOptionalMapping<_0>, Input] : [];
 export type TMappedAs<Input extends string> = ((Token.TConst<'as', Input> extends [infer _0, infer Input extends string] ? (TType<Input> extends [infer _1, infer Input extends string] ? [[_0, _1], Input] : []) : []) extends [infer _0, infer Input extends string] ? [_0, Input] : [[], Input] extends [infer _0, infer Input extends string] ? [_0, Input] : []) extends [infer _0 extends [unknown, unknown] | [], infer Input extends string] ? [S.TMappedAsMapping<_0>, Input] : [];
 export type TMapped<Input extends string> = (Token.TConst<'{', Input> extends [infer _0, infer Input extends string] ? (TMappedReadonly<Input> extends [infer _1, infer Input extends string] ? (Token.TConst<'[', Input> extends [infer _2, infer Input extends string] ? (Token.TIdent<Input> extends [infer _3, infer Input extends string] ? (Token.TConst<'in', Input> extends [infer _4, infer Input extends string] ? (TType<Input> extends [infer _5, infer Input extends string] ? (TMappedAs<Input> extends [infer _6, infer Input extends string] ? (Token.TConst<']', Input> extends [infer _7, infer Input extends string] ? (TMappedOptional<Input> extends [infer _8, infer Input extends string] ? (Token.TConst<':', Input> extends [infer _9, infer Input extends string] ? (TType<Input> extends [infer _10, infer Input extends string] ? (TOptionalSemiColon<Input> extends [infer _11, infer Input extends string] ? (Token.TConst<'}', Input> extends [infer _12, infer Input extends string] ? [[_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12], Input] : []) : []) : []) : []) : []) : []) : []) : []) : []) : []) : []) : []) : []) extends [infer _0 extends [unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown], infer Input extends string] ? [S.TMappedMapping<_0>, Input] : [];
+export type TDependent<Input extends string> = ((Token.TConst<'if', Input> extends [infer _0, infer Input extends string] ? (TType<Input> extends [infer _1, infer Input extends string] ? (Token.TConst<'then', Input> extends [infer _2, infer Input extends string] ? (TType<Input> extends [infer _3, infer Input extends string] ? (Token.TConst<'else', Input> extends [infer _4, infer Input extends string] ? (TType<Input> extends [infer _5, infer Input extends string] ? [[_0, _1, _2, _3, _4, _5], Input] : []) : []) : []) : []) : []) : []) extends [infer _0, infer Input extends string] ? [_0, Input] : (Token.TConst<'if', Input> extends [infer _0, infer Input extends string] ? (TType<Input> extends [infer _1, infer Input extends string] ? (Token.TConst<'then', Input> extends [infer _2, infer Input extends string] ? (TType<Input> extends [infer _3, infer Input extends string] ? [[_0, _1, _2, _3], Input] : []) : []) : []) : []) extends [infer _0, infer Input extends string] ? [_0, Input] : []) extends [infer _0 extends [unknown, unknown, unknown, unknown, unknown, unknown] | [unknown, unknown, unknown, unknown], infer Input extends string] ? [S.TDependentMapping<_0>, Input] : [];
 export type TReference<Input extends string> = Token.TIdent<Input> extends [infer _0 extends string, infer Input extends string] ? [S.TReferenceMapping<_0>, Input] : [];
-export type TOptions<Input extends string> = (Token.TConst<'Options', Input> extends [infer _0, infer Input extends string] ? (Token.TConst<'<', Input> extends [infer _1, infer Input extends string] ? (TType<Input> extends [infer _2, infer Input extends string] ? (Token.TConst<',', Input> extends [infer _3, infer Input extends string] ? (TJsonObject<Input> extends [infer _4, infer Input extends string] ? (Token.TConst<'>', Input> extends [infer _5, infer Input extends string] ? [[_0, _1, _2, _3, _4, _5], Input] : []) : []) : []) : []) : []) : []) extends [infer _0 extends [unknown, unknown, unknown, unknown, unknown, unknown], infer Input extends string] ? [S.TOptionsMapping<_0>, Input] : [];
 export type TJsonNumber<Input extends string> = Token.TNumber<Input> extends [infer _0 extends string, infer Input extends string] ? [S.TJsonNumberMapping<_0>, Input] : [];
 export type TJsonBoolean<Input extends string> = (Token.TConst<'true', Input> extends [infer _0, infer Input extends string] ? [_0, Input] : Token.TConst<'false', Input> extends [infer _0, infer Input extends string] ? [_0, Input] : []) extends [infer _0 extends 'true' | 'false', infer Input extends string] ? [S.TJsonBooleanMapping<_0>, Input] : [];
 export type TJsonString<Input extends string> = Token.TString<['\"', '\''], Input> extends [infer _0 extends string, infer Input extends string] ? [S.TJsonStringMapping<_0>, Input] : [];
@@ -220,8 +220,8 @@ export declare const MappedReadonly: (input: string) => [unknown, string] | [];
 export declare const MappedOptional: (input: string) => [unknown, string] | [];
 export declare const MappedAs: (input: string) => [unknown, string] | [];
 export declare const Mapped: (input: string) => [unknown, string] | [];
+export declare const Dependent: (input: string) => [unknown, string] | [];
 export declare const Reference: (input: string) => [unknown, string] | [];
-export declare const Options: (input: string) => [unknown, string] | [];
 export declare const JsonNumber: (input: string) => [unknown, string] | [];
 export declare const JsonBoolean: (input: string) => [unknown, string] | [];
 export declare const JsonString: (input: string) => [unknown, string] | [];

package/build/type/script/parser.mjs

@@ -46,7 +46,7 @@ export const KeyOf = (input) => If(If(If(Token.Const('keyof', input), ([_0, inpu
 export const IndexArray_0 = (input, result = []) => If(If(If(Token.Const('[', input), ([_0, input]) => If(Type(input), ([_1, input]) => If(Token.Const(']', input), ([_2, input]) => [[_0, _1, _2], input]))), ([_0, input]) => [_0, input], () => If(If(Token.Const('[', input), ([_0, input]) => If(Token.Const(']', input), ([_1, input]) => [[_0, _1], input])), ([_0, input]) => [_0, input], () => [])), ([_0, input]) => IndexArray_0(input, [...result, _0]), () => [result, input]);
 export const IndexArray = (input) => If(IndexArray_0(input), ([_0, input]) => [S.IndexArrayMapping(_0), input]);
 export const Extends = (input) => If(If(If(Token.Const('extends', input), ([_0, input]) => If(Type(input), ([_1, input]) => If(Token.Const('?', input), ([_2, input]) => If(Type(input), ([_3, input]) => If(Token.Const(':', input), ([_4, input]) => If(Type(input), ([_5, input]) => [[_0, _1, _2, _3, _4, _5], input])))))), ([_0, input]) => [_0, input], () => If([[], input], ([_0, input]) => [_0, input], () => [])), ([_0, input]) => [S.ExtendsMapping(_0), input]);
-export const Base = (input) => If(If(If(Token.Const('(', input), ([_0, input]) => If(Type(input), ([_1, input]) => If(Token.Const(')', input), ([_2, input]) => [[_0, _1, _2], input]))), ([_0, input]) => [_0, input], () => If(Keyword(input), ([_0, input]) => [_0, input], () => If(_Object_(input), ([_0, input]) => [_0, input], () => If(Tuple(input), ([_0, input]) => [_0, input], () => If(TemplateLiteral(input), ([_0, input]) => [_0, input], () => If(Literal(input), ([_0, input]) => [_0, input], () => If(Constructor(input), ([_0, input]) => [_0, input], () => If(_Function_(input), ([_0, input]) => [_0, input], () => If(Mapped(input), ([_0, input]) => [_0, input], () => If(Options(input), ([_0, input]) => [_0, input], () => If(GenericCall(input), ([_0, input]) => [_0, input], () => If(Reference(input), ([_0, input]) => [_0, input], () => [])))))))))))), ([_0, input]) => [S.BaseMapping(_0), input]);
+export const Base = (input) => If(If(If(Token.Const('(', input), ([_0, input]) => If(Type(input), ([_1, input]) => If(Token.Const(')', input), ([_2, input]) => [[_0, _1, _2], input]))), ([_0, input]) => [_0, input], () => If(Keyword(input), ([_0, input]) => [_0, input], () => If(_Object_(input), ([_0, input]) => [_0, input], () => If(Tuple(input), ([_0, input]) => [_0, input], () => If(TemplateLiteral(input), ([_0, input]) => [_0, input], () => If(Literal(input), ([_0, input]) => [_0, input], () => If(Constructor(input), ([_0, input]) => [_0, input], () => If(_Function_(input), ([_0, input]) => [_0, input], () => If(Mapped(input), ([_0, input]) => [_0, input], () => If(Dependent(input), ([_0, input]) => [_0, input], () => If(GenericCall(input), ([_0, input]) => [_0, input], () => If(Reference(input), ([_0, input]) => [_0, input], () => [])))))))))))), ([_0, input]) => [S.BaseMapping(_0), input]);
 export const With = (input) => If(If(If(Token.Const('with', input), ([_0, input]) => If(JsonObject(input), ([_1, input]) => [[_0, _1], input])), ([_0, input]) => [_0, input], () => If([[], input], ([_0, input]) => [_0, input], () => [])), ([_0, input]) => [S.WithMapping(_0), input]);
 export const Factor = (input) => If(If(KeyOf(input), ([_0, input]) => If(Base(input), ([_1, input]) => If(IndexArray(input), ([_2, input]) => If(Extends(input), ([_3, input]) => If(With(input), ([_4, input]) => [[_0, _1, _2, _3, _4], input]))))), ([_0, input]) => [S.FactorMapping(_0), input]);
 export const ExprTermTail = (input) => If(If(If(Token.Const('&', input), ([_0, input]) => If(Factor(input), ([_1, input]) => If(ExprTermTail(input), ([_2, input]) => [[_0, _1, _2], input]))), ([_0, input]) => [_0, input], () => If([[], input], ([_0, input]) => [_0, input], () => [])), ([_0, input]) => [S.ExprTermTailMapping(_0), input]);
@@ -94,8 +94,8 @@ export const MappedReadonly = (input) => If(If(If(Token.Const('+', input), ([_0,
 export const MappedOptional = (input) => If(If(If(Token.Const('+', input), ([_0, input]) => If(Token.Const('?', input), ([_1, input]) => [[_0, _1], input])), ([_0, input]) => [_0, input], () => If(If(Token.Const('-', input), ([_0, input]) => If(Token.Const('?', input), ([_1, input]) => [[_0, _1], input])), ([_0, input]) => [_0, input], () => If(If(Token.Const('?', input), ([_0, input]) => [[_0], input]), ([_0, input]) => [_0, input], () => If([[], input], ([_0, input]) => [_0, input], () => [])))), ([_0, input]) => [S.MappedOptionalMapping(_0), input]);
 export const MappedAs = (input) => If(If(If(Token.Const('as', input), ([_0, input]) => If(Type(input), ([_1, input]) => [[_0, _1], input])), ([_0, input]) => [_0, input], () => If([[], input], ([_0, input]) => [_0, input], () => [])), ([_0, input]) => [S.MappedAsMapping(_0), input]);
 export const Mapped = (input) => If(If(Token.Const('{', input), ([_0, input]) => If(MappedReadonly(input), ([_1, input]) => If(Token.Const('[', input), ([_2, input]) => If(Token.Ident(input), ([_3, input]) => If(Token.Const('in', input), ([_4, input]) => If(Type(input), ([_5, input]) => If(MappedAs(input), ([_6, input]) => If(Token.Const(']', input), ([_7, input]) => If(MappedOptional(input), ([_8, input]) => If(Token.Const(':', input), ([_9, input]) => If(Type(input), ([_10, input]) => If(OptionalSemiColon(input), ([_11, input]) => If(Token.Const('}', input), ([_12, input]) => [[_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12], input]))))))))))))), ([_0, input]) => [S.MappedMapping(_0), input]);
+export const Dependent = (input) => If(If(If(Token.Const('if', input), ([_0, input]) => If(Type(input), ([_1, input]) => If(Token.Const('then', input), ([_2, input]) => If(Type(input), ([_3, input]) => If(Token.Const('else', input), ([_4, input]) => If(Type(input), ([_5, input]) => [[_0, _1, _2, _3, _4, _5], input])))))), ([_0, input]) => [_0, input], () => If(If(Token.Const('if', input), ([_0, input]) => If(Type(input), ([_1, input]) => If(Token.Const('then', input), ([_2, input]) => If(Type(input), ([_3, input]) => [[_0, _1, _2, _3], input])))), ([_0, input]) => [_0, input], () => [])), ([_0, input]) => [S.DependentMapping(_0), input]);
 export const Reference = (input) => If(Token.Ident(input), ([_0, input]) => [S.ReferenceMapping(_0), input]);
-export const Options = (input) => If(If(Token.Const('Options', input), ([_0, input]) => If(Token.Const('<', input), ([_1, input]) => If(Type(input), ([_2, input]) => If(Token.Const(',', input), ([_3, input]) => If(JsonObject(input), ([_4, input]) => If(Token.Const('>', input), ([_5, input]) => [[_0, _1, _2, _3, _4, _5], input])))))), ([_0, input]) => [S.OptionsMapping(_0), input]);
 export const JsonNumber = (input) => If(Token.Number(input), ([_0, input]) => [S.JsonNumberMapping(_0), input]);
 export const JsonBoolean = (input) => If(If(Token.Const('true', input), ([_0, input]) => [_0, input], () => If(Token.Const('false', input), ([_0, input]) => [_0, input], () => [])), ([_0, input]) => [S.JsonBooleanMapping(_0), input]);
 export const JsonString = (input) => If(Token.String(['\"', '\''], input), ([_0, input]) => [S.JsonStringMapping(_0), input]);

package/build/type/types/dependent.d.mts

@@ -0,0 +1,17 @@
+import { type StaticType, type StaticDirection } from './static.mjs';
+import { type TSchema, type TSchemaOptions } from './schema.mjs';
+import { type TProperties } from './properties.mjs';
+export type StaticDependent<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, If extends TSchema, Then extends TSchema, Else extends TSchema, StaticIf extends unknown = StaticType<Stack, Direction, Context, This, If>, StaticThen extends unknown = StaticType<Stack, Direction, Context, This, Then>, StaticElse extends unknown = StaticType<Stack, Direction, Context, This, Else>, Result extends unknown = (StaticIf & StaticThen) | Exclude<StaticElse, StaticIf>> = Result;
+/** Represents a Dependent Type */
+export interface TDependent<If extends TSchema = TSchema, Then extends TSchema = TSchema, Else extends TSchema = TSchema> extends TSchema {
+    '~kind': 'Dependent';
+    if: If;
+    then: Then;
+    else: Else;
+}
+/** Creates a Dependent type */
+export declare function Dependent<If extends TSchema, Then extends TSchema, Else extends TSchema>(if_: If, then_: Then, else_: Else, options?: TSchemaOptions): TDependent<If, Then, Else>;
+/** Returns true if the given value is TDependent. */
+export declare function IsDependent(value: unknown): value is TDependent;
+/** Extracts options from a IsDependent. */
+export declare function DependentOptions(type: TDependent): TSchemaOptions;