pi-proactive 0.2.0-beta.3 → 0.2.0-beta.4

package/node_modules/typebox/build/type/engine/record/record_create.d.mts

@@ -1,3 +0,0 @@
-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/node_modules/typebox/build/type/engine/record/record_create.mjs

@@ -1,7 +0,0 @@
-// 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/node_modules/typebox/build/type/engine/ref/index.d.mts

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

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

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

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

@@ -1,6 +0,0 @@
-import { type TProperties } from '../../types/properties.mjs';
-import { type TInstantiateType } from '../instantiate.mjs';
-import { type TRef } from '../../types/ref.mjs';
-import { type TState } from '../instantiate.mjs';
-export type TRefInstantiate<Context extends TProperties, State extends TState, Type extends TRef, Ref extends string> = (Ref extends State['visited'][number] ? Type : Ref extends keyof Context ? TInstantiateType<Context, TState<State['callstack'], [...State['visited'], Ref]>, 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/node_modules/typebox/build/type/engine/ref/instantiate.mjs

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

package/node_modules/typebox/build/type/engine/required/from_cyclic.d.mts

@@ -1,10 +0,0 @@
-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/node_modules/typebox/build/type/engine/required/from_cyclic.mjs

@@ -1,11 +0,0 @@
-// 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/node_modules/typebox/build/type/engine/required/from_dependent.d.mts

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

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

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

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

@@ -1,5 +0,0 @@
-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[], Evaluated extends TSchema = TEvaluateIntersect<Types>, Result extends TSchema = TFromType<Evaluated>> = Result;
-export declare function FromIntersect<Types extends TSchema[]>(types: [...Types]): TFromIntersect<Types>;

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

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

package/node_modules/typebox/build/type/engine/required/from_object.d.mts

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

package/node_modules/typebox/build/type/engine/required/from_object.mjs

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

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

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

package/node_modules/typebox/build/type/engine/required/from_type.mjs

@@ -1,20 +0,0 @@
-// 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) :
-        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/node_modules/typebox/build/type/engine/required/from_union.d.mts

@@ -1,5 +0,0 @@
-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/node_modules/typebox/build/type/engine/required/from_union.mjs

@@ -1,7 +0,0 @@
-// 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/node_modules/typebox/build/type/engine/required/index.d.mts

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

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

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

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

@@ -1,9 +0,0 @@
-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';
-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>;

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

@@ -1,15 +0,0 @@
-// 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';
-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) {
-    const instaniatedType = InstantiateType(context, state, type);
-    return RequiredAction(instaniatedType, options);
-}

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

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

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

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

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

@@ -1,12 +0,0 @@
-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/node_modules/typebox/build/type/engine/rest/spread.mjs

@@ -1,19 +0,0 @@
-// 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/node_modules/typebox/build/type/engine/return_type/index.d.mts

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

package/node_modules/typebox/build/type/engine/return_type/index.mjs

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

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

@@ -1,12 +0,0 @@
-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/node_modules/typebox/build/type/engine/return_type/instantiate.mjs

@@ -1,21 +0,0 @@
-// 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/node_modules/typebox/build/type/engine/template_literal/create.d.mts

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

package/node_modules/typebox/build/type/engine/template_literal/create.mjs

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

package/node_modules/typebox/build/type/engine/template_literal/decode.d.mts

@@ -1,30 +0,0 @@
-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 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/node_modules/typebox/build/type/engine/template_literal/decode.mjs

@@ -1,81 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../../guard/index.mjs';
-import { Unreachable } from '../../../system/unreachable/index.mjs';
-import { Literal, IsLiteral } from '../../types/literal.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 = []) {
-    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 = []) {
-    return Guard.ShiftLeft(types, (left, right) => 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) {
-    return Guard.ShiftLeft(types, (left, right) => 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/node_modules/typebox/build/type/engine/template_literal/encode.d.mts

@@ -1,33 +0,0 @@
-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, 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 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}`>);
-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 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 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 */
-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 {};

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

@@ -1,81 +0,0 @@
-// deno-fmt-ignore-file
-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, 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';
-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 { EvaluateEnum } from '../evaluate/evaluate.mjs';
-import { TemplateLiteralAction } from './instantiate.mjs';
-function JoinString(input) {
-    return input.join('|');
-}
-function UnwrapTemplateLiteralPattern(pattern) {
-    return pattern.slice(1, pattern.length - 1);
-}
-function EncodeLiteral(value, right, pattern) {
-    return EncodeTypes(right, `${pattern}${value}`);
-}
-function EncodeBigInt(right, pattern) {
-    return EncodeTypes(right, `${pattern}${BigIntPattern}`);
-}
-function EncodeInteger(right, pattern) {
-    return EncodeTypes(right, `${pattern}${IntegerPattern}`);
-}
-function EncodeNumber(right, pattern) {
-    return EncodeTypes(right, `${pattern}${NumberPattern}`);
-}
-function EncodeBoolean(right, pattern) {
-    return EncodeType(Union([Literal('false'), Literal('true')]), right, pattern);
-}
-function EncodeString(right, pattern) {
-    return EncodeTypes(right, `${pattern}${StringPattern}`);
-}
-function EncodeTemplateLiteral(templatePattern, right, pattern) {
-    return EncodeTypes(right, `${pattern}${UnwrapTemplateLiteralPattern(templatePattern)}`);
-}
-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 = []) {
-    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) :
-        IsInteger(type) ? EncodeInteger(right, pattern) :
-            IsLiteral(type) ? EncodeLiteral(type.const, right, pattern) :
-                IsBigInt(type) ? EncodeBigInt(right, pattern) :
-                    IsBoolean(type) ? EncodeBoolean(right, pattern) :
-                        IsNumber(type) ? EncodeNumber(right, pattern) :
-                            IsString(type) ? EncodeString(right, pattern) :
-                                IsTemplateLiteral(type) ? EncodeTemplateLiteral(type.pattern, right, pattern) :
-                                    IsTemplateLiteralDeferred(type) ? EncodeTemplateLiteralDeferred(type.parameters[0], right, pattern) :
-                                        IsUnion(type) ? EncodeUnion(type.anyOf, right, pattern) :
-                                            NeverPattern);
-}
-function EncodeTypes(types, pattern) {
-    return Guard.ShiftLeft(types, (left, right) => EncodeType(left, right, pattern), () => pattern);
-}
-function EncodePattern(types) {
-    const encoded = EncodeTypes(types, '');
-    const result = `^${encoded}$`;
-    return result;
-}
-/** Encodes a TemplateLiteral type sequence into a TemplateLiteral */
-export function TemplateLiteralEncode(types) {
-    const pattern = EncodePattern(types);
-    const result = TemplateLiteralCreate(pattern);
-    return result;
-}

package/node_modules/typebox/build/type/engine/template_literal/index.d.mts

@@ -1,6 +0,0 @@
-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';

package/node_modules/typebox/build/type/engine/template_literal/index.mjs

@@ -1,6 +0,0 @@
-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';

package/node_modules/typebox/build/type/engine/template_literal/instantiate.d.mts

@@ -1,9 +0,0 @@
-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 TTemplateLiteralEncode } from './encode.mjs';
-import { type TState, type TInstantiateTypes, type TCanInstantiate } from '../instantiate.mjs';
-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>;

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

@@ -1,15 +0,0 @@
-// 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/node_modules/typebox/build/type/engine/template_literal/is_finite.d.mts

@@ -1,12 +0,0 @@
-import { type TSchema } from '../../types/schema.mjs';
-import { type TLiteral, type TLiteralValue } from '../../types/literal.mjs';
-import { type TUnion } from '../../types/union.mjs';
-type TFromLiteral<_Value extends TLiteralValue> = true;
-type TFromTypesReduce<Types extends TSchema[]> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromType<Left> extends true ? TFromTypesReduce<Right> : false : true);
-type TFromTypes<Types extends TSchema[], Result extends boolean = Types extends [] ? false : TFromTypesReduce<Types>> = Result;
-type TFromType<Type extends TSchema> = Type extends TUnion<infer Types extends TSchema[]> ? TFromTypes<Types> : Type extends TLiteral<infer Value extends TLiteralValue> ? TFromLiteral<Value> : false;
-/** Returns true if the given TemplateLiteral types yields a finite variant set */
-export type TIsTemplateLiteralFinite<Types extends TSchema[], Result extends boolean = TFromTypes<Types>> = Result;
-/** Returns true if the given TemplateLiteral types yields a finite variant set */
-export declare function IsTemplateLiteralFinite<Types extends TSchema[]>(types: [...Types]): TIsTemplateLiteralFinite<Types>;
-export {};