@depup/typebox 1.1.6-depup.0

package/build/type/engine/record/from-key-union.d.mts

@@ -0,0 +1,20 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TLiteral } from '../../types/literal.mjs';
+import { type TNumber } from '../../types/number.mjs';
+import { type TInteger } from '../../types/integer.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TString } from '../../types/string.mjs';
+import { type TRecord, StringKey } from '../../types/record.mjs';
+import { type TFlatten } from '../evaluate/flatten.mjs';
+type TStringOrNumberCheck<Types extends TSchema[]> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? Left extends TString | TNumber | TInteger ? true : TStringOrNumberCheck<Right> : false);
+type TTryBuildRecord<Types extends TSchema[], Value extends TSchema, Result extends TSchema | undefined = (TStringOrNumberCheck<Types> extends true ? TRecord<typeof StringKey, Value> : undefined)> = Result;
+type TCreateProperties<Variants extends TSchema[], Value extends TSchema, Result extends TProperties = {}> = (Variants extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? Left extends TLiteral<string | number> ? TCreateProperties<Right, Value, Result & {
+    [_ in Left['const']]: Value;
+}> : TCreateProperties<Right, Value, Result> : {
+    [Key in keyof Result]: Result[Key];
+});
+type TCreateObject<Variants extends TSchema[], Value extends TSchema, Properties extends TProperties = TCreateProperties<Variants, Value>, Result extends TSchema = TObject<Properties>> = Result;
+export type TFromUnionKey<Types extends TSchema[], Value extends TSchema, Flattened extends TSchema[] = TFlatten<Types>, Record extends TSchema | undefined = TTryBuildRecord<Flattened, Value>, Result extends TSchema = (Record extends TSchema ? Record : TCreateObject<Flattened, Value>)> = Result;
+export declare function FromUnionKey<Types extends TSchema[], Value extends TSchema>(types: [...Types], value: Value): TFromUnionKey<Types, Value>;
+export {};

package/build/type/engine/record/from-key-union.mjs

@@ -0,0 +1,39 @@
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+import { Guard } from '../../../guard/index.mjs';
+import { IsSchema } from '../../types/schema.mjs';
+import { IsLiteral } from '../../types/literal.mjs';
+import { IsNumber } from '../../types/number.mjs';
+import { IsInteger } from '../../types/integer.mjs';
+import { Object } from '../../types/object.mjs';
+import { IsString } from '../../types/string.mjs';
+import { StringKey } from '../../types/record.mjs';
+import { Flatten } from '../evaluate/flatten.mjs';
+import { CreateRecord } from './record-create.mjs';
+function StringOrNumberCheck(types) {
+    return types.some(type => IsString(type) || IsNumber(type) || IsInteger(type));
+}
+function TryBuildRecord(types, value) {
+    return (Guard.IsEqual(StringOrNumberCheck(types), true)
+        ? CreateRecord(StringKey, value)
+        : undefined);
+}
+function CreateProperties(types, value) {
+    return types.reduce((result, left) => {
+        return IsLiteral(left) && (Guard.IsString(left.const) || Guard.IsNumber(left.const))
+            ? { ...result, [left.const]: value }
+            : result;
+    }, {});
+}
+function CreateObject(types, value) {
+    const properties = CreateProperties(types, value);
+    const result = Object(properties);
+    return result;
+}
+export function FromUnionKey(types, value) {
+    const flattened = Flatten(types);
+    const record = TryBuildRecord(flattened, value);
+    return (IsSchema(record) // maybe IsRecord?
+        ? record
+        : CreateObject(flattened, value));
+}

package/build/type/engine/record/from-key.d.mts

@@ -0,0 +1,24 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TAny } from '../../types/any.mjs';
+import { type TBoolean } from '../../types/boolean.mjs';
+import { type TEnum, type TEnumValue } from '../../types/enum.mjs';
+import { type TIntersect } from '../../types/intersect.mjs';
+import { type TInteger } from '../../types/integer.mjs';
+import { type TLiteral, type TLiteralValue } from '../../types/literal.mjs';
+import { type TNumber } from '../../types/number.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TString } from '../../types/string.mjs';
+import { type TTemplateLiteral } from '../../types/template-literal.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TFromAnyKey } from './from-key-any.mjs';
+import { type TFromBooleanKey } from './from-key-boolean.mjs';
+import { type TFromEnumKey } from './from-key-enum.mjs';
+import { type TFromIntegerKey } from './from-key-integer.mjs';
+import { type TFromIntersectKey } from './from-key-intersect.mjs';
+import { type TFromLiteralKey } from './from-key-literal.mjs';
+import { type TFromNumberKey } from './from-key-number.mjs';
+import { type TFromStringKey } from './from-key-string.mjs';
+import { type TFromTemplateKey } from './from-key-template-literal.mjs';
+import { type TFromUnionKey } from './from-key-union.mjs';
+export type TFromKey<Key extends TSchema, Value extends TSchema, Result extends TSchema = (Key extends TAny ? TFromAnyKey<Value> : Key extends TBoolean ? TFromBooleanKey<Value> : Key extends TEnum<infer Values extends TEnumValue[]> ? TFromEnumKey<Values, Value> : Key extends TInteger ? TFromIntegerKey<Key, Value> : Key extends TIntersect<infer Types extends TSchema[]> ? TFromIntersectKey<Types, Value> : Key extends TLiteral<infer LiteralValue extends TLiteralValue> ? TFromLiteralKey<LiteralValue, Value> : Key extends TNumber ? TFromNumberKey<Key, Value> : Key extends TString ? TFromStringKey<Key, Value> : Key extends TTemplateLiteral<infer Pattern extends string> ? TFromTemplateKey<Pattern, Value> : Key extends TUnion<infer Types extends TSchema[]> ? TFromUnionKey<Types, Value> : TObject<{}>)> = Result;
+export declare function FromKey<Key extends TSchema, Value extends TSchema>(key: Key, value: Value): TFromKey<Key, Value>;

package/build/type/engine/record/from-key.mjs

@@ -0,0 +1,40 @@
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+import { IsAny } from '../../types/any.mjs';
+import { IsBoolean } from '../../types/boolean.mjs';
+import { IsEnum } from '../../types/enum.mjs';
+import { IsIntersect } from '../../types/intersect.mjs';
+import { IsInteger } from '../../types/integer.mjs';
+import { IsLiteral } from '../../types/literal.mjs';
+import { IsNumber } from '../../types/number.mjs';
+import { Object } from '../../types/object.mjs';
+import { IsString } from '../../types/string.mjs';
+import { IsTemplateLiteral } from '../../types/template-literal.mjs';
+import { IsUnion } from '../../types/union.mjs';
+// ------------------------------------------------------------------
+// Keys and Deferred
+// ------------------------------------------------------------------
+import { FromAnyKey } from './from-key-any.mjs';
+import { FromBooleanKey } from './from-key-boolean.mjs';
+import { FromEnumKey } from './from-key-enum.mjs';
+import { FromIntegerKey } from './from-key-integer.mjs';
+import { FromIntersectKey } from './from-key-intersect.mjs';
+import { FromLiteralKey } from './from-key-literal.mjs';
+import { FromNumberKey } from './from-key-number.mjs';
+import { FromStringKey } from './from-key-string.mjs';
+import { FromTemplateKey } from './from-key-template-literal.mjs';
+import { FromUnionKey } from './from-key-union.mjs';
+export function FromKey(key, value) {
+    const result = (IsAny(key) ? FromAnyKey(value) :
+        IsBoolean(key) ? FromBooleanKey(value) :
+            IsEnum(key) ? FromEnumKey(key.enum, value) :
+                IsInteger(key) ? FromIntegerKey(key, value) :
+                    IsIntersect(key) ? FromIntersectKey(key.allOf, value) :
+                        IsLiteral(key) ? FromLiteralKey(key.const, value) :
+                            IsNumber(key) ? FromNumberKey(key, value) :
+                                IsUnion(key) ? FromUnionKey(key.anyOf, value) :
+                                    IsString(key) ? FromStringKey(key, value) :
+                                        IsTemplateLiteral(key) ? FromTemplateKey(key.pattern, value) :
+                                            Object({}));
+    return result;
+}

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

@@ -0,0 +1 @@
+export * from './instantiate.mjs';

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

@@ -0,0 +1 @@
+export * from './instantiate.mjs';

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

@@ -0,0 +1,9 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TRecordDeferred } from '../../types/record.mjs';
+import { type TFromKey } from './from-key.mjs';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
+type TRecordImmediate<Context extends TProperties, State extends TState, Key extends TSchema, Value extends TSchema, InstantatedKey extends TSchema = TInstantiateType<Context, State, Key>, InstantiatedValue extends TSchema = TInstantiateType<Context, State, Value>, Result extends TSchema = TFromKey<InstantatedKey, InstantiatedValue>> = Result;
+export type TRecordInstantiate<Context extends TProperties, State extends TState, Key extends TSchema, Value extends TSchema> = TCanInstantiate<Context, [Key]> extends true ? TRecordImmediate<Context, State, Key, Value> : TRecordDeferred<Key, Value>;
+export declare function RecordInstantiate<Context extends TProperties, State extends TState, Key extends TSchema, Value extends TSchema>(context: Context, state: State, key: Key, value: Value, options: TSchemaOptions): TRecordInstantiate<Context, State, Key, Value>;
+export {};

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

@@ -0,0 +1,16 @@
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+import { Memory } from '../../../system/memory/index.mjs';
+import { RecordDeferred } from '../../types/record.mjs';
+import { FromKey } from './from-key.mjs';
+import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
+function RecordImmediate(context, state, key, value, options) {
+    const instanstiatedKey = InstantiateType(context, state, key);
+    const instantiatedValue = InstantiateType(context, state, value);
+    return Memory.Update(FromKey(instanstiatedKey, instantiatedValue), {}, options);
+}
+export function RecordInstantiate(context, state, key, value, options) {
+    return (CanInstantiate(context, [key])
+        ? RecordImmediate(context, state, key, value, options)
+        : RecordDeferred(key, value, options));
+}

package/build/type/engine/record/record-create.d.mts

@@ -0,0 +1,3 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TRecord } from '../../types/record.mjs';
+export declare function CreateRecord<Key extends string, Value extends TSchema>(key: Key, value: Value): TRecord<Key, Value>;

package/build/type/engine/record/record-create.mjs

@@ -0,0 +1,7 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../../system/memory/index.mjs';
+export function CreateRecord(key, value) {
+    const type = 'object';
+    const patternProperties = { [key]: value };
+    return Memory.Create({ ['~kind']: 'Record' }, { type, patternProperties });
+}

package/build/type/engine/ref/index.d.mts

@@ -0,0 +1 @@
+export * from './instantiate.mjs';

package/build/type/engine/ref/index.mjs

@@ -0,0 +1 @@
+export * from './instantiate.mjs';

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

@@ -0,0 +1,6 @@
+import { TProperties } from '../../types/properties.mjs';
+import { type TState, type TInstantiateType } from '../instantiate.mjs';
+import { type TCyclicCheck } from '../cyclic/check.mjs';
+import { type TRef } from '../../types/ref.mjs';
+export type TRefInstantiate<Context extends TProperties, State extends TState, Type extends TRef, Ref extends string> = (Ref extends keyof Context ? TCyclicCheck<[Ref], Context, Context[Ref]> extends true ? Type : TInstantiateType<Context, State, Context[Ref]> : Type);
+export declare function RefInstantiate<Context extends TProperties, State extends TState, Type extends TRef, Ref extends string>(context: Context, state: State, type: Type, ref: Ref): TRefInstantiate<Context, State, Type, Ref>;

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

@@ -0,0 +1,10 @@
+// deno-fmt-ignore-file
+import { InstantiateType } from '../instantiate.mjs';
+import { CyclicCheck } from '../cyclic/check.mjs';
+export function RefInstantiate(context, state, type, ref) {
+    return (ref in context
+        ? CyclicCheck([ref], context, context[ref])
+            ? type
+            : InstantiateType(context, state, context[ref])
+        : type);
+}

package/build/type/engine/required/from-cyclic.d.mts

@@ -0,0 +1,10 @@
+import { Memory } from '../../../system/memory/index.mjs';
+import { type TSchema } from '../../types/schema.mjs';
+import { type TCyclic } from '../../types/cyclic.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TFromType } from './from-type.mjs';
+import { type TCyclicTarget } from '../cyclic/target.mjs';
+export type TFromCyclic<Defs extends TProperties, Ref extends string, Target extends TSchema = TCyclicTarget<Defs, Ref>, Partial extends TSchema = TFromType<Target>, Result extends TSchema = TCyclic<Memory.TAssign<Defs, {
+    [_ in Ref]: Partial;
+}>, Ref>> = Result;
+export declare function FromCyclic<Defs extends TProperties, Ref extends string>(defs: Defs, ref: Ref): TFromCyclic<Defs, Ref>;

package/build/type/engine/required/from-cyclic.mjs

@@ -0,0 +1,11 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../../system/memory/index.mjs';
+import { Cyclic } from '../../types/cyclic.mjs';
+import { FromType } from './from-type.mjs';
+import { CyclicTarget } from '../cyclic/target.mjs';
+export function FromCyclic(defs, ref) {
+    const target = CyclicTarget(defs, ref);
+    const partial = FromType(target);
+    const result = Cyclic(Memory.Assign(defs, { [ref]: partial }), ref);
+    return result;
+}

package/build/type/engine/required/from-intersect.d.mts

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

package/build/type/engine/required/from-intersect.mjs

@@ -0,0 +1,7 @@
+// deno-fmt-ignore-file
+import { FromType } from './from-type.mjs';
+import { EvaluateIntersect } from '../evaluate/evaluate.mjs';
+export function FromIntersect(types) {
+    const result = types.map(type => FromType(type));
+    return EvaluateIntersect(result);
+}

package/build/type/engine/required/from-object.d.mts

@@ -0,0 +1,8 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TOptionalRemove } from '../../types/_optional.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+export type TFromObject<Properties extends TProperties, Mapped extends TProperties = {
+    [Key in keyof Properties]: TOptionalRemove<Properties[Key]>;
+}, Result extends TSchema = TObject<Mapped>> = Result;
+export declare function FromObject<Properties extends TProperties>(properties: Properties): TFromObject<Properties>;

package/build/type/engine/required/from-object.mjs

@@ -0,0 +1,11 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
+import { Object } from '../../types/object.mjs';
+import { OptionalRemove } from '../../types/_optional.mjs';
+export function FromObject(properties) {
+    const mapped = Guard.Keys(properties).reduce((result, left) => {
+        return { ...result, [left]: OptionalRemove(properties[left]) };
+    }, {});
+    const result = Object(mapped);
+    return result;
+}

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

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

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

@@ -0,0 +1,16 @@
+// deno-fmt-ignore-file
+import { IsCyclic } from '../../types/cyclic.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 { 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({}));
+}

package/build/type/engine/required/from-union.d.mts

@@ -0,0 +1,5 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TUnion } from '../../types/union.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

@@ -0,0 +1,7 @@
+// deno-fmt-ignore-file
+import { Union } from '../../types/union.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/index.d.mts

@@ -0,0 +1 @@
+export * from './instantiate.mjs';

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

@@ -0,0 +1 @@
+export * from './instantiate.mjs';

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

@@ -0,0 +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 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 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

@@ -0,0 +1,14 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../../system/memory/index.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 RequiredInstantiate(context, state, type, options) {
+    return (CanInstantiate(context, [type])
+        ? RequiredImmediate(context, state, type, options)
+        : RequiredDeferred(type, options));
+}

package/build/type/engine/rest/index.d.mts

@@ -0,0 +1 @@
+export * from './spread.mjs';

package/build/type/engine/rest/index.mjs

@@ -0,0 +1 @@
+export * from './spread.mjs';

package/build/type/engine/rest/spread.d.mts

@@ -0,0 +1,12 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TInfer } from '../../types/infer.mjs';
+import { type TNever } from '../../types/never.mjs';
+import { type TRest } from '../../types/rest.mjs';
+import { type TRef } from '../../types/ref.mjs';
+import { type TTuple } from '../../types/tuple.mjs';
+type TSpreadElement<Type extends TSchema, Result extends TSchema[] = (Type extends TRest<infer Rest extends TSchema> ? (Rest extends TTuple<infer Elements extends TSchema[]> ? TRestSpread<Elements> : Rest extends TInfer<string, TSchema> ? [Type] : Rest extends TRef<string> ? [Type] : [
+    TNever
+]) : [Type])> = Result;
+export type TRestSpread<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TRestSpread<Right, [...Result, ...TSpreadElement<Left>]> : Result);
+export declare function RestSpread<Types extends TSchema[]>(types: [...Types]): TRestSpread<Types>;
+export {};

package/build/type/engine/rest/spread.mjs

@@ -0,0 +1,19 @@
+// deno-fmt-ignore-file
+import { IsInfer } from '../../types/infer.mjs';
+import { Never } from '../../types/never.mjs';
+import { IsRest } from '../../types/rest.mjs';
+import { IsRef } from '../../types/ref.mjs';
+import { IsTuple } from '../../types/tuple.mjs';
+function SpreadElement(type) {
+    const result = (IsRest(type) ? (IsTuple(type.items) ? RestSpread(type.items.items) :
+        IsInfer(type.items) ? [type] :
+            IsRef(type.items) ? [type] :
+                [Never()]) : [type]);
+    return result;
+}
+export function RestSpread(types) {
+    const result = types.reduce((result, left) => {
+        return [...result, ...SpreadElement(left)];
+    }, []);
+    return result;
+}

package/build/type/engine/return-type/index.d.mts

@@ -0,0 +1 @@
+export * from './instantiate.mjs';

package/build/type/engine/return-type/index.mjs

@@ -0,0 +1 @@
+export * from './instantiate.mjs';

package/build/type/engine/return-type/instantiate.d.mts

@@ -0,0 +1,11 @@
+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 TReturnTypeAction<Type extends TSchema> = Type extends TFunction<TSchema[], infer ReturnType extends TSchema> ? ReturnType : TNever;
+type TReturnTypeImmediate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TReturnTypeAction<InstantiatedType>;
+export type TReturnTypeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema> = TCanInstantiate<Context, [Type]> extends true ? TReturnTypeImmediate<Context, State, Type> : TReturnTypeDeferred<Type>;
+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,18 @@
+// 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 ReturnTypeAction(type) {
+    return (IsFunction(type) ? type.returnType : Never());
+}
+function ReturnTypeImmediate(context, state, type, options) {
+    const instantiatedType = InstantiateType(context, state, type);
+    return Memory.Update(ReturnTypeAction(instantiatedType), {}, options);
+}
+export function ReturnTypeInstantiate(context, state, type, options) {
+    return (CanInstantiate(context, [type])
+        ? ReturnTypeImmediate(context, state, type, options)
+        : ReturnTypeDeferred(type, options));
+}

package/build/type/engine/template-literal/create.d.mts

@@ -0,0 +1 @@
+export declare function TemplateLiteralCreate<Pattern extends string>(pattern: Pattern): never;

package/build/type/engine/template-literal/create.mjs

@@ -0,0 +1,5 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../../system/memory/index.mjs';
+export function TemplateLiteralCreate(pattern) {
+    return Memory.Create({ ['~kind']: 'TemplateLiteral' }, { type: 'string', pattern }, {});
+}

package/build/type/engine/template-literal/decode.d.mts

@@ -0,0 +1,30 @@
+import { TUnreachable } from '../../../system/unreachable/index.mjs';
+import { type TLiteral, type TLiteralValue } from '../../types/literal.mjs';
+import { type TSchema } from '../../types/schema.mjs';
+import { type TString } from '../../types/string.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';
+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;
+type TFromType<Variants extends string[], Type extends TSchema, Result extends string[] = (Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Variants, Types> : Type extends TLiteral<infer Value extends TLiteralValue> ? TFromLiteral<Variants, Value> : TUnreachable)> = Result;
+type TDecodeFromSpan<Variants extends string[], Types extends TSchema[]> = Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TDecodeFromSpan<TFromType<Variants, Left>, Right> : Variants;
+type TVariantsToLiterals<Variants extends string[], Result extends TSchema[] = []> = Variants extends [infer Left extends string, ...infer Right extends string[]] ? TVariantsToLiterals<Right, [...Result, TLiteral<Left>]> : Result;
+type TDecodeTypesAsUnion<Types extends TSchema[], Variants extends string[] = TDecodeFromSpan<[], Types>, Literals extends TSchema[] = TVariantsToLiterals<Variants>, Result extends TSchema = TUnion<Literals>> = Result;
+type TDecodeTypes<Types extends TSchema[], Result extends TSchema = (Types extends [] ? TUnreachable : Types extends [infer Type extends TLiteral] ? Type : TDecodeTypesAsUnion<Types>)> = Result;
+/** Decodes a TemplateLiteral into a Type. */
+export type TTemplateLiteralDecodeUnsafe<Pattern extends string, Types extends TSchema[] = TParsePatternIntoTypes<Pattern>, Result extends TSchema = (Types extends [] ? TString : TIsTemplateLiteralFinite<Types> extends true ? TDecodeTypes<Types> : TTemplateLiteral<Pattern>)> = Result;
+/**
+ * (Internal) Decodes a TemplateLiteral pattern into a Type. This function is unsafe. Decoding a non-finite
+ * TemplateLiteral pattern may produce another TemplateLiteral pattern. During enumeration, this
+ * TemplateLiteral -> TemplateLiteral behavior can cause a StackOverflow. A better in-flight template-literal
+ * decoding algorithm is needed. (for review)
+ */
+export declare function TemplateLiteralDecodeUnsafe<Pattern extends string>(pattern: Pattern): TTemplateLiteralDecodeUnsafe<Pattern>;
+/** Decodes a TemplateLiteral pattern but returns TString if the pattern in non-finite. */
+export type TTemplateLiteralDecode<Pattern extends string, Decoded extends TSchema = TTemplateLiteralDecodeUnsafe<Pattern>, Result extends TSchema = Decoded extends TTemplateLiteral ? TString : Decoded> = Result;
+/** Decodes a TemplateLiteral pattern but returns TString if the pattern in non-finite. */
+export declare function TemplateLiteralDecode<Pattern extends string>(pattern: Pattern): TTemplateLiteralDecode<Pattern>;
+export {};

package/build/type/engine/template-literal/decode.mjs

@@ -0,0 +1,87 @@
+// deno-fmt-ignore-file
+import { Unreachable } from '../../../system/unreachable/index.mjs';
+import { Guard } from '../../../guard/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 { Union, IsUnion } from '../../types/union.mjs';
+import { ParsePatternIntoTypes } from '../patterns/pattern.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);
+}
+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);
+}
+// ------------------------------------------------------------------
+// deno-coverage-ignore-start - symmetric unreachable | internal
+// 
+// Parsed TemplateLiteral patterns only yield Literal or Union but
+// we keep the fall-through to assert that no other types can reach 
+// here without error.
+//
+// ------------------------------------------------------------------
+function FromType(variants, type) {
+    const result = (IsUnion(type) ? FromUnion(variants, type.anyOf) :
+        IsLiteral(type) ? FromLiteral(variants, type.const) :
+            Unreachable() // []
+    );
+    return result;
+}
+function DecodeFromSpan(variants, types) {
+    const [left, ...right] = types;
+    return (IsSchema(left) ? DecodeFromSpan(FromType(variants, left), right) : variants);
+}
+function VariantsToLiterals(variants) {
+    return variants.map(variant => Literal(variant));
+}
+function DecodeTypesAsUnion(types) {
+    const variants = DecodeFromSpan([], types);
+    const literals = VariantsToLiterals(variants);
+    const result = Union(literals);
+    return result;
+}
+// ------------------------------------------------------------------
+// deno-coverage-ignore-start - internal
+// 
+// Cannot invoke the 0-length condition as the TemplateLiteral 
+// parsers always return at least 1 TLiteral or TUnion. We would 
+// return a empty string TLiteral for this case, but will use 
+// Unreachable to catch parse inputs that trigger 0-length.
+//
+// ------------------------------------------------------------------
+function DecodeTypes(types) {
+    return (Guard.IsEqual(types.length, 0) ? Unreachable() : // Literal('') :
+        Guard.IsEqual(types.length, 1) && IsLiteral(types[0]) ? types[0] :
+            DecodeTypesAsUnion(types));
+}
+/**
+ * (Internal) Decodes a TemplateLiteral pattern into a Type. This function is unsafe. Decoding a non-finite
+ * TemplateLiteral pattern may produce another TemplateLiteral pattern. During enumeration, this
+ * TemplateLiteral -> TemplateLiteral behavior can cause a StackOverflow. A better in-flight template-literal
+ * decoding algorithm is needed. (for review)
+ */
+export function TemplateLiteralDecodeUnsafe(pattern) {
+    const types = ParsePatternIntoTypes(pattern);
+    const result = Guard.IsEqual(types.length, 0) // Failed to Parse | IsTemplateLiteralPattern
+        ? String() // ... Pattern cannot be typed, so discard
+        : IsTemplateLiteralFinite(types)
+            ? DecodeTypes(types)
+            : TemplateLiteralCreate(pattern);
+    return result;
+}
+/** Decodes a TemplateLiteral pattern but returns TString if the pattern in non-finite. */
+export function TemplateLiteralDecode(pattern) {
+    const decoded = TemplateLiteralDecodeUnsafe(pattern);
+    const result = IsTemplateLiteral(decoded) ? String() : decoded;
+    return result;
+}

package/build/type/engine/template-literal/encode.d.mts

@@ -0,0 +1,31 @@
+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 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';
+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}`>);
+type TEncodeBigInt<Right extends TSchema[], Pattern extends string> = (TEncodeTypes<Right, `${Pattern}${typeof BigIntPattern}`>);
+type TEncodeInteger<Right extends TSchema[], Pattern extends string> = (TEncodeTypes<Right, `${Pattern}${typeof IntegerPattern}`>);
+type TEncodeNumber<Right extends TSchema[], Pattern extends string> = (TEncodeTypes<Right, `${Pattern}${typeof NumberPattern}`>);
+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 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 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 */
+export type TTemplateLiteralEncode<Types extends TSchema[], Pattern extends string = TEncodePattern<Types>, Result extends TSchema = TTemplateLiteral<Pattern>> = Result;
+/** Encodes a TemplateLiteral type sequence into a TemplateLiteral */
+export declare function TemplateLiteralEncode<Types extends TSchema[]>(types: [...Types]): TTemplateLiteralEncode<Types>;
+export {};