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

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

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

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

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

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

@@ -1,9 +1,9 @@
 import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
 import { type TProperties } from '../../types/properties.mjs';
-import { type TFromType } from './from-type.mjs';
+import { type TFromType } from './from_type.mjs';
 import { type TRequiredDeferred } from '../../action/required.mjs';
 import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
-type TRequiredImmediate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TFromType<InstantiatedType>;
-export type TRequiredInstantiate<Context extends TProperties, State extends TState, Type extends TSchema> = TCanInstantiate<Context, [Type]> extends true ? TRequiredImmediate<Context, State, Type> : TRequiredDeferred<Type>;
+export type TRequiredAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TFromType<Type> : TRequiredDeferred<Type>> = Result;
+export declare function RequiredAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TRequiredAction<Type>;
+export type TRequiredInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TRequiredAction<InstantiatedType>;
 export declare function RequiredInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TRequiredInstantiate<Context, State, Type>;
-export {};

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

@@ -1,14 +1,15 @@
 // deno-fmt-ignore-file
 import { Memory } from '../../../system/memory/index.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 import { RequiredDeferred } from '../../action/required.mjs';
 import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
-function RequiredImmediate(context, state, type, options) {
-    const instaniatedType = InstantiateType(context, state, type);
-    return Memory.Update(FromType(instaniatedType), {}, options);
+export function RequiredAction(type, options) {
+    const result = CanInstantiate([type])
+        ? Memory.Update(FromType(type), {}, options)
+        : RequiredDeferred(type, options);
+    return result;
 }
 export function RequiredInstantiate(context, state, type, options) {
-    return (CanInstantiate(context, [type])
-        ? RequiredImmediate(context, state, type, options)
-        : RequiredDeferred(type, options));
+    const instaniatedType = InstantiateType(context, state, type);
+    return RequiredAction(instaniatedType, options);
 }

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

@@ -0,0 +1,12 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TFunction } from '../../types/function.mjs';
+import { type TNever } from '../../types/never.mjs';
+import { type TReturnTypeDeferred } from '../../action/return_type.mjs';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
+type TReturnTypeOperation<Type extends TSchema> = (Type extends TFunction ? Type['returnType'] : TNever);
+export type TReturnTypeAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TReturnTypeOperation<Type> : TReturnTypeDeferred<Type>> = Result;
+export declare function ReturnTypeAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TReturnTypeAction<Type>;
+export type TReturnTypeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TReturnTypeAction<InstantiatedType>;
+export declare function ReturnTypeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options?: TSchemaOptions): TReturnTypeInstantiate<Context, State, Type>;
+export {};

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

@@ -0,0 +1,21 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../../system/memory/index.mjs';
+import { IsFunction } from '../../types/function.mjs';
+import { Never } from '../../types/never.mjs';
+import { ReturnTypeDeferred } from '../../action/return_type.mjs';
+import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
+function ReturnTypeOperation(type) {
+    return (IsFunction(type)
+        ? type['returnType']
+        : Never());
+}
+export function ReturnTypeAction(type, options) {
+    const result = CanInstantiate([type])
+        ? Memory.Update(ReturnTypeOperation(type), {}, options)
+        : ReturnTypeDeferred(type, options);
+    return result;
+}
+export function ReturnTypeInstantiate(context, state, type, options = {}) {
+    const instantiatedType = InstantiateType(context, state, type);
+    return ReturnTypeAction(instantiatedType, options);
+}

package/build/type/engine/{template-literal → template_literal}/decode.d.mts

@@ -1,11 +1,11 @@
-import { TUnreachable } from '../../../system/unreachable/index.mjs';
-import { type TLiteral, type TLiteralValue } from '../../types/literal.mjs';
+import { type TUnreachable } from '../../../system/unreachable/index.mjs';
 import { type TSchema } from '../../types/schema.mjs';
+import { type TLiteral, type TLiteralValue } from '../../types/literal.mjs';
 import { type TString } from '../../types/string.mjs';
-import { type TTemplateLiteral } from '../../types/template-literal.mjs';
+import { type TTemplateLiteral } from '../../types/template_literal.mjs';
 import { type TUnion } from '../../types/union.mjs';
 import { type TParsePatternIntoTypes } from '../patterns/pattern.mjs';
-import { type TIsTemplateLiteralFinite } from './is-finite.mjs';
+import { type TIsTemplateLiteralFinite } from './is_finite.mjs';
 type TFromLiteralPush<Variants extends string[], Value extends TLiteralValue, Result extends string[] = []> = Variants extends [infer Left extends string, ...infer Right extends string[]] ? TFromLiteralPush<Right, Value, [...Result, `${Left}${Value}`]> : Result;
 type TFromLiteral<Variants extends string[], Value extends TLiteralValue> = Variants extends [] ? [`${Value}`] : TFromLiteralPush<Variants, Value>;
 type TFromUnion<Variants extends string[], Types extends TSchema[], Result extends string[] = []> = Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromUnion<Variants, Right, [...Result, ...TFromType<Variants, Left>]> : Result;

package/build/type/engine/{template-literal → template_literal}/decode.mjs

@@ -1,26 +1,21 @@
 // deno-fmt-ignore-file
-import { Unreachable } from '../../../system/unreachable/index.mjs';
 import { Guard } from '../../../guard/index.mjs';
+import { Unreachable } from '../../../system/unreachable/index.mjs';
 import { Literal, IsLiteral } from '../../types/literal.mjs';
-import { IsSchema } from '../../types/schema.mjs';
 import { String } from '../../types/string.mjs';
-import { IsTemplateLiteral } from '../../types/template-literal.mjs';
+import { IsTemplateLiteral } from '../../types/template_literal.mjs';
 import { Union, IsUnion } from '../../types/union.mjs';
 import { ParsePatternIntoTypes } from '../patterns/pattern.mjs';
-import { IsTemplateLiteralFinite } from './is-finite.mjs';
+import { IsTemplateLiteralFinite } from './is_finite.mjs';
 import { TemplateLiteralCreate } from './create.mjs';
 function FromLiteralPush(variants, value, result = []) {
-    const [left, ...right] = variants;
-    return (Guard.IsString(left) ? FromLiteralPush(right, value, [...result, `${left}${value}`]) : result);
+    return Guard.ShiftLeft(variants, (left, right) => FromLiteralPush(right, value, [...result, `${left}${value}`]), () => result);
 }
 function FromLiteral(variants, value) {
     return (Guard.IsEqual(variants.length, 0) ? [`${value}`] : FromLiteralPush(variants, value));
 }
 function FromUnion(variants, types, result = []) {
-    const [left, ...right] = types;
-    return (IsSchema(left)
-        ? FromUnion(variants, right, [...result, ...FromType(variants, left)])
-        : result);
+    return Guard.ShiftLeft(types, (left, right) => FromUnion(variants, right, [...result, ...FromType(variants, left)]), () => result);
 }
 // ------------------------------------------------------------------
 // deno-coverage-ignore-start - symmetric unreachable | internal
@@ -38,8 +33,7 @@ function FromType(variants, type) {
     return result;
 }
 function DecodeFromSpan(variants, types) {
-    const [left, ...right] = types;
-    return (IsSchema(left) ? DecodeFromSpan(FromType(variants, left), right) : variants);
+    return Guard.ShiftLeft(types, (left, right) => DecodeFromSpan(FromType(variants, left), right), () => variants);
 }
 function VariantsToLiterals(variants) {
     return variants.map(variant => Literal(variant));

package/build/type/engine/{template-literal → template_literal}/encode.d.mts

@@ -2,14 +2,15 @@ import { type TSchema } from '../../types/schema.mjs';
 import { type TEnum, type TEnumValue } from '../../types/enum.mjs';
 import { type TLiteral, type TLiteralValue } from '../../types/literal.mjs';
 import { type TUnion } from '../../types/union.mjs';
-import { type TTemplateLiteral } from '../../types/template-literal.mjs';
+import { type TTemplateLiteral, type TTemplateLiteralDeferred } from '../../types/template_literal.mjs';
 import { type TBigInt, BigIntPattern } from '../../types/bigint.mjs';
 import { type TString, StringPattern } from '../../types/string.mjs';
 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);
 type TEncodeLiteral<Value extends TLiteralValue, Right extends TSchema[], Pattern extends string> = (TEncodeTypes<Right, `${Pattern}${Value}`>);
@@ -19,9 +20,10 @@ type TEncodeNumber<Right extends TSchema[], Pattern extends string> = (TEncodeTy
 type TEncodeBoolean<Right extends TSchema[], Pattern extends string> = (TEncodeType<TUnion<[TLiteral<'false'>, TLiteral<'true'>]>, Right, Pattern>);
 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 TEncodeEnum<Types extends TEnumValue[], Right extends TSchema[], Pattern extends string, Variants extends TSchema[] = TEnumValuesToVariants<Types>> = TEncodeUnion<Variants, Right, Pattern>;
+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<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 TUnion<infer Types extends TSchema[]> ? TEncodeUnion<Types, Right, Pattern> : typeof NeverPattern);
+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);
 type TEncodePattern<Types extends TSchema[], Encoded extends string = TEncodeTypes<Types, ''>, Result extends string = `^${Encoded}$`> = Result;
 /** Encodes a TemplateLiteral type sequence into a TemplateLiteral */

package/build/type/engine/{template-literal → template_literal}/encode.mjs

@@ -1,9 +1,9 @@
 // deno-fmt-ignore-file
-import { IsSchema } from '../../types/schema.mjs';
+import { Guard } from '../../../guard/index.mjs';
 import { IsEnum } from '../../types/enum.mjs';
 import { Literal, IsLiteral } from '../../types/literal.mjs';
 import { Union, IsUnion } from '../../types/union.mjs';
-import { IsTemplateLiteral } from '../../types/template-literal.mjs';
+import { IsTemplateLiteral, IsTemplateLiteralDeferred } from '../../types/template_literal.mjs';
 import { IsBigInt, BigIntPattern } from '../../types/bigint.mjs';
 import { IsString, StringPattern } from '../../types/string.mjs';
 import { IsNumber, NumberPattern } from '../../types/number.mjs';
@@ -11,7 +11,8 @@ 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('|');
 }
@@ -39,15 +40,17 @@ function EncodeString(right, pattern) {
 function EncodeTemplateLiteral(templatePattern, right, pattern) {
     return EncodeTypes(right, `${pattern}${UnwrapTemplateLiteralPattern(templatePattern)}`);
 }
-function EncodeEnum(types, right, pattern) {
-    const variants = EnumValuesToVariants(types);
-    return EncodeUnion(variants, right, pattern);
+function EncodeTemplateLiteralDeferred(types, right, pattern) {
+    const templateLiteral = TemplateLiteralAction(types, {});
+    const result = EncodeType(templateLiteral, right, pattern);
+    return result;
+}
+function EncodeEnum(values, right, pattern) {
+    const evaluated = EvaluateEnum(values);
+    return EncodeType(evaluated, right, pattern);
 }
 function EncodeUnion(types, right, pattern, result = []) {
-    const [head, ...tail] = types;
-    return (IsSchema(head)
-        ? EncodeUnion(tail, right, pattern, [...result, EncodeType(head, [], '')])
-        : EncodeTypes(right, `${pattern}(${JoinString(result)})`));
+    return Guard.ShiftLeft(types, (head, tail) => EncodeUnion(tail, right, pattern, [...result, EncodeType(head, [], '')]), () => EncodeTypes(right, `${pattern}(${JoinString(result)})`));
 }
 function EncodeType(type, right, pattern) {
     return (IsEnum(type) ? EncodeEnum(type.enum, right, pattern) :
@@ -58,14 +61,12 @@ function EncodeType(type, right, pattern) {
                         IsNumber(type) ? EncodeNumber(right, pattern) :
                             IsString(type) ? EncodeString(right, pattern) :
                                 IsTemplateLiteral(type) ? EncodeTemplateLiteral(type.pattern, right, pattern) :
-                                    IsUnion(type) ? EncodeUnion(type.anyOf, right, pattern) :
-                                        NeverPattern);
+                                    IsTemplateLiteralDeferred(type) ? EncodeTemplateLiteralDeferred(type.parameters[0], right, pattern) :
+                                        IsUnion(type) ? EncodeUnion(type.anyOf, right, pattern) :
+                                            NeverPattern);
 }
 function EncodeTypes(types, pattern) {
-    const [left, ...right] = types;
-    return (IsSchema(left)
-        ? EncodeType(left, right, pattern)
-        : pattern);
+    return Guard.ShiftLeft(types, (left, right) => EncodeType(left, right, pattern), () => pattern);
 }
 function EncodePattern(types) {
     const encoded = EncodeTypes(types, '');

package/build/type/engine/{template-literal → template_literal}/index.d.mts

@@ -2,5 +2,5 @@ export * from './create.mjs';
 export * from './decode.mjs';
 export * from './encode.mjs';
 export * from './static.mjs';
-export * from './is-finite.mjs';
-export * from './is-pattern.mjs';
+export * from './is_finite.mjs';
+export * from './is_pattern.mjs';

package/build/type/engine/{template-literal → template_literal}/index.mjs

@@ -2,5 +2,5 @@ export * from './create.mjs';
 export * from './decode.mjs';
 export * from './encode.mjs';
 export * from './static.mjs';
-export * from './is-finite.mjs';
-export * from './is-pattern.mjs';
+export * from './is_finite.mjs';
+export * from './is_pattern.mjs';

package/build/type/engine/{template-literal → template_literal}/instantiate.d.mts

@@ -1,9 +1,9 @@
 import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
 import { type TProperties } from '../../types/properties.mjs';
-import { type TTemplateLiteralDeferred } from '../../types/template-literal.mjs';
+import { type TTemplateLiteralDeferred } from '../../types/template_literal.mjs';
 import { type TTemplateLiteralEncode } from './encode.mjs';
 import { type TState, type TInstantiateTypes, type TCanInstantiate } from '../instantiate.mjs';
-type TTemplateLiteralImmediate<Context extends TProperties, State extends TState, Types extends TSchema[], InstantiatedTypes extends TSchema[] = TInstantiateTypes<Context, State, Types>, Result extends TSchema = TTemplateLiteralEncode<InstantiatedTypes>> = Result;
-export type TTemplateLiteralInstantiate<Context extends TProperties, State extends TState, Types extends TSchema[]> = TCanInstantiate<Context, Types> extends true ? TTemplateLiteralImmediate<Context, State, Types> : TTemplateLiteralDeferred<Types>;
+export type TTemplateLiteralAction<Types extends TSchema[], Result extends TSchema = TCanInstantiate<Types> extends true ? TTemplateLiteralEncode<Types> : TTemplateLiteralDeferred<Types>> = Result;
+export declare function TemplateLiteralAction<Types extends TSchema[]>(types: [...Types], options: TSchemaOptions): TTemplateLiteralAction<Types>;
+export type TTemplateLiteralInstantiate<Context extends TProperties, State extends TState, Types extends TSchema[], InstantiatedTypes extends TSchema[] = TInstantiateTypes<Context, State, Types>> = TTemplateLiteralAction<InstantiatedTypes>;
 export declare function TemplateLiteralInstantiate<Context extends TProperties, State extends TState, Types extends TSchema[]>(context: Context, state: State, types: [...Types], options: TSchemaOptions): TTemplateLiteralInstantiate<Context, State, Types>;
-export {};

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

@@ -0,0 +1,15 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../../system/memory/index.mjs';
+import { TemplateLiteralDeferred } from '../../types/template_literal.mjs';
+import { TemplateLiteralEncode } from './encode.mjs';
+import { InstantiateTypes, CanInstantiate } from '../instantiate.mjs';
+export function TemplateLiteralAction(types, options) {
+    const result = CanInstantiate(types)
+        ? Memory.Update(TemplateLiteralEncode(types), {}, options)
+        : TemplateLiteralDeferred(types, options);
+    return result;
+}
+export function TemplateLiteralInstantiate(context, state, types, options) {
+    const instantiatedTypes = InstantiateTypes(context, state, types);
+    return TemplateLiteralAction(instantiatedTypes, options);
+}

package/build/type/engine/{template-literal/is-finite.mjs → template_literal/is_finite.mjs}

@@ -1,18 +1,14 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../../guard/index.mjs';
-import { IsSchema } from '../../types/schema.mjs';
 import { IsLiteral } from '../../types/literal.mjs';
 import { IsUnion } from '../../types/union.mjs';
 function FromLiteral(_value) {
     return true;
 }
 function FromTypesReduce(types) {
-    const [left, ...right] = types;
-    return (IsSchema(left)
-        ? FromType(left)
-            ? FromTypesReduce(right)
-            : false
-        : true);
+    return Guard.ShiftLeft(types, (left, right) => FromType(left)
+        ? FromTypesReduce(right)
+        : false, () => true);
 }
 function FromTypes(types) {
     const result = Guard.IsEqual(types.length, 0) ? false : FromTypesReduce(types);

package/build/type/engine/{template-literal/is-pattern.mjs → template_literal/is_pattern.mjs}

@@ -7,3 +7,4 @@ export function IsTemplateLiteralPattern(pattern) {
     const result = Guard.IsEqual(types.length, 0) ? false : true;
     return result;
 }
+// deno-coverage-ignore-stop

package/build/type/engine/this/expand_this.d.mts

@@ -0,0 +1,16 @@
+import { type TArray } from '../../types/array.mjs';
+import { type TConstructor } from '../../types/constructor.mjs';
+import { type TFunction } from '../../types/function.mjs';
+import { type TIntersect } from '../../types/intersect.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TSchema } from '../../types/schema.mjs';
+import { type TTuple } from '../../types/tuple.mjs';
+import { type TThis } from '../../types/this.mjs';
+import { type TUnion } from '../../types/union.mjs';
+type TFromTypes<Properties extends TProperties, Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromTypes<Properties, Right, [...Result, TFromType<Properties, Left>]> : Result);
+export type TFromType<Properties extends TProperties, Type extends TSchema> = (Type extends TArray<infer Type extends TSchema> ? TArray<TFromType<Properties, Type>> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TConstructor<TFromTypes<Properties, Parameters>, TFromType<Properties, InstanceType>> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFunction<TFromTypes<Properties, Parameters>, TFromType<Properties, ReturnType>> : Type extends TTuple<infer Types extends TSchema[]> ? TTuple<TFromTypes<Properties, Types>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromTypes<Properties, Types>> : Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromTypes<Properties, Types>> : Type extends TThis ? TObject<Properties> : Type);
+export declare function FromType<Properties extends TProperties, Type extends TSchema>(properties: Properties, type: Type): TFromType<Properties, Type>;
+export type TExpandThis<Properties extends TProperties, Type extends TSchema, Result extends TSchema = TFromType<Properties, Type>> = Result;
+export declare function ExpandThis<Properties extends TProperties, Type extends TSchema>(properties: TProperties, type: Type): TExpandThis<Properties, Type>;
+export {};

package/build/type/engine/this/expand_this.mjs

@@ -0,0 +1,26 @@
+// deno-fmt-ignore-file
+import { IsArray, _Array_ } from '../../types/array.mjs';
+import { IsConstructor, Constructor } from '../../types/constructor.mjs';
+import { IsFunction, _Function_ } from '../../types/function.mjs';
+import { IsIntersect, Intersect } from '../../types/intersect.mjs';
+import { _Object_ } from '../../types/object.mjs';
+import { IsTuple, Tuple } from '../../types/tuple.mjs';
+import { IsThis } from '../../types/this.mjs';
+import { IsUnion, Union } from '../../types/union.mjs';
+function FromTypes(properties, types) {
+    return types.map(type => FromType(properties, type));
+}
+export function FromType(properties, type) {
+    return (IsArray(type) ? _Array_(FromType(properties, type.items)) :
+        IsConstructor(type) ? Constructor(FromTypes(properties, type.parameters), FromType(properties, type.instanceType)) :
+            IsFunction(type) ? _Function_(FromTypes(properties, type.parameters), FromType(properties, type.returnType)) :
+                IsTuple(type) ? Tuple(FromTypes(properties, type.items)) :
+                    IsUnion(type) ? Union(FromTypes(properties, type.anyOf)) :
+                        IsIntersect(type) ? Intersect(FromTypes(properties, type.allOf)) :
+                            IsThis(type) ? _Object_(properties) :
+                                type);
+}
+export function ExpandThis(properties, type) {
+    const result = FromType(properties, type);
+    return 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/with/instantiate.mjs

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

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

@@ -3,7 +3,7 @@ import { type TProperties } from '../types/properties.mjs';
 import { type TInfer } from '../types/infer.mjs';
 import { type TAny } from '../types/any.mjs';
 import { type TUnknown } from '../types/unknown.mjs';
-import { type TExtendsRight } from './extends-right.mjs';
+import { type TExtendsRight } from './extends_right.mjs';
 import * as Result from './result.mjs';
 export type TExtendsAny<Inferred extends TProperties, Left extends TAny, Right extends TSchema> = (Right extends TInfer ? TExtendsRight<Inferred, Left, Right> : Right extends TAny ? Result.TExtendsTrue<Inferred> : Right extends TUnknown ? Result.TExtendsTrue<Inferred> : Result.TExtendsUnion<Inferred>);
 export declare function ExtendsAny<Inferred extends TProperties, Left extends TAny, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsAny<Inferred, Left, Right>;

package/build/type/extends/any.mjs

@@ -2,7 +2,7 @@
 import { IsInfer } from '../types/infer.mjs';
 import { IsAny } from '../types/any.mjs';
 import { IsUnknown } from '../types/unknown.mjs';
-import { ExtendsRight } from './extends-right.mjs';
+import { ExtendsRight } from './extends_right.mjs';
 import * as Result from './result.mjs';
 export function ExtendsAny(inferred, left, right) {
     return (IsInfer(right) ? ExtendsRight(inferred, left, right) :

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

@@ -2,8 +2,8 @@ import { type TSchema } from '../types/schema.mjs';
 import { type TProperties } from '../types/properties.mjs';
 import { type TArray } from '../types/array.mjs';
 import { type TImmutable } from '../types/_immutable.mjs';
-import { type TExtendsRight } from './extends-right.mjs';
-import { type TExtendsLeft } from './extends-left.mjs';
+import { type TExtendsRight } from './extends_right.mjs';
+import { type TExtendsLeft } from './extends_left.mjs';
 import * as Result from './result.mjs';
 type TExtendsImmutable<Left extends TSchema, Right extends TSchema, IsImmutableLeft extends boolean = Left extends TImmutable ? true : false, IsImmutableRight extends boolean = Right extends TImmutable ? true : false, Result extends boolean = [
     IsImmutableLeft,

package/build/type/extends/array.mjs

@@ -1,8 +1,8 @@
 // deno-fmt-ignore-file
 import { IsArray } from '../types/array.mjs';
 import { IsImmutable } from '../types/_immutable.mjs';
-import { ExtendsRight } from './extends-right.mjs';
-import { ExtendsLeft } from './extends-left.mjs';
+import { ExtendsRight } from './extends_right.mjs';
+import { ExtendsLeft } from './extends_left.mjs';
 import * as Result from './result.mjs';
 function ExtendsImmutable(left, right) {
     const isImmutableLeft = IsImmutable(left);

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

@@ -1,7 +1,7 @@
 import { type TSchema } from '../types/schema.mjs';
 import { type TProperties } from '../types/properties.mjs';
 import { type TBigInt } from '../types/bigint.mjs';
-import { type TExtendsRight } from './extends-right.mjs';
+import { type TExtendsRight } from './extends_right.mjs';
 import * as Result from './result.mjs';
 export type TExtendsBigInt<Inferred extends TProperties, Left extends TBigInt, Right extends TSchema> = (Right extends TBigInt ? Result.TExtendsTrue<Inferred> : TExtendsRight<Inferred, Left, Right>);
 export declare function ExtendsBigInt<Inferred extends TProperties, Left extends TBigInt, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsBigInt<Inferred, Left, Right>;

package/build/type/extends/bigint.mjs

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { IsBigInt } from '../types/bigint.mjs';
-import { ExtendsRight } from './extends-right.mjs';
+import { ExtendsRight } from './extends_right.mjs';
 import * as Result from './result.mjs';
 export function ExtendsBigInt(inferred, left, right) {
     return (IsBigInt(right)

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

@@ -1,7 +1,7 @@
 import { type TSchema } from '../types/schema.mjs';
 import { type TProperties } from '../types/properties.mjs';
 import { type TBoolean } from '../types/boolean.mjs';
-import { type TExtendsRight } from './extends-right.mjs';
+import { type TExtendsRight } from './extends_right.mjs';
 import * as Result from './result.mjs';
 export type TExtendsBoolean<Inferred extends TProperties, Left extends TBoolean, Right extends TSchema> = (Right extends TBoolean ? Result.TExtendsTrue<Inferred> : TExtendsRight<Inferred, Left, Right>);
 export declare function ExtendsBoolean<Inferred extends TProperties, Left extends TBoolean, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsBoolean<Inferred, Left, Right>;

package/build/type/extends/boolean.mjs

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { IsBoolean } from '../types/boolean.mjs';
-import { ExtendsRight } from './extends-right.mjs';
+import { ExtendsRight } from './extends_right.mjs';
 import * as Result from './result.mjs';
 export function ExtendsBoolean(inferred, left, right) {
     return (IsBoolean(right)

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

@@ -5,6 +5,6 @@ import { type TConstructor } from '../types/constructor.mjs';
 import { type TUnknown } from '../types/unknown.mjs';
 import * as Result from './result.mjs';
 import { type TExtendsParameters } from './parameters.mjs';
-import { type TExtendsReturnType } from './return-type.mjs';
+import { type TExtendsReturnType } from './return_type.mjs';
 export type TExtendsConstructor<Inferred extends TProperties, Parameters extends TSchema[], InstanceType extends TSchema, Right extends TSchema> = (Right extends TAny ? Result.TExtendsTrue<Inferred> : Right extends TUnknown ? Result.TExtendsTrue<Inferred> : Right extends TConstructor ? TExtendsParameters<Inferred, Parameters, Right['parameters']> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? TExtendsReturnType<Inferred, InstanceType, Right['instanceType']> : Result.TExtendsFalse : Result.TExtendsFalse);
 export declare function ExtendsConstructor<Inferred extends TProperties, Parameters extends TSchema[], InstanceType extends TSchema, Right extends TSchema>(inferred: Inferred, parameters: [...Parameters], returnType: InstanceType, right: Right): TExtendsConstructor<Inferred, Parameters, InstanceType, Right>;

package/build/type/extends/constructor.mjs

@@ -7,7 +7,7 @@ import * as Result from './result.mjs';
 // Parameters | ReturnType
 // ------------------------------------------------------------------ 
 import { ExtendsParameters } from './parameters.mjs';
-import { ExtendsReturnType } from './return-type.mjs';
+import { ExtendsReturnType } from './return_type.mjs';
 export function ExtendsConstructor(inferred, parameters, returnType, right) {
     return (IsAny(right) ? Result.ExtendsTrue(inferred) :
         IsUnknown(right) ? Result.ExtendsTrue(inferred) :

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 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 TEnumValue } from '../types/enum.mjs';
+import { type TExtendsLeft } from './extends_left.mjs';
+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 { ExtendsLeft } from './extends_left.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.d.mts

@@ -1,11 +1,13 @@
 import { type TSchema } from '../types/schema.mjs';
 import { type TProperties } from '../types/properties.mjs';
 import { type TCyclic } from '../types/cyclic.mjs';
-import { type TExtendsLeft } from './extends-left.mjs';
+import { type TUnknown } from '../types/unknown.mjs';
+import { type TUnsafe } from '../types/unsafe.mjs';
+import { type TExtendsLeft } from './extends_left.mjs';
 import { type TCyclicExtends } from '../engine/cyclic/index.mjs';
-type TNormal<Type extends TSchema> = (Type extends TCyclic ? TCyclicExtends<Type> : Type);
+type TCanonical<Type extends TSchema> = (Type extends TCyclic ? TCyclicExtends<Type> : Type extends TUnsafe ? TUnknown : Type);
 /** Performs a structural extends check on left and right types and yields inferred types on right if specified. */
-export type TExtends<Inferred extends TProperties, Left extends TSchema, Right extends TSchema, NormalLeft extends TSchema = TNormal<Left>, NormalRight extends TSchema = TNormal<Right>> = TExtendsLeft<Inferred, NormalLeft, NormalRight>;
+export type TExtends<Inferred extends TProperties, Left extends TSchema, Right extends TSchema, CanonicalLeft extends TSchema = TCanonical<Left>, CanonicalRight extends TSchema = TCanonical<Right>> = TExtendsLeft<Inferred, CanonicalLeft, CanonicalRight>;
 /** Performs a structural extends check on left and right types and yields inferred types on right if specified. */
 export declare function Extends<Inferred extends TProperties, Left extends TSchema, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtends<Inferred, Left, Right>;
 export {};