type Append<Text extends string, Segment extends string> = `${Text}${Segment}`;
interface TAppend<Segment extends string | void = void, Text extends string | void = void> extends Fn<{
    0: string;
    1: string;
}> {
    slot: [Segment, Text];
    data: Append<this[1], this[0]>;
}

type Contains<Text extends string, Segment extends Serializable> = Text extends `${string}${Segment}${string}` ? 1 : 0;
interface TContains<Segment extends Serializable | void = void, Text extends string | void = void> extends Fn<{
    0: Serializable;
    1: string;
}> {
    slot: [Segment, Text];
    data: Contains<this[1], this[0]>;
}

type EndsWith<Text extends string, Segment extends Serializable> = Text extends `${string}${Segment}` ? 1 : 0;
interface TEndsWith<Segment extends Serializable | void = void, Text extends string | void = void> extends Fn<{
    0: Serializable;
    1: string;
}> {
    slot: [Segment, Text];
    data: EndsWith<this[1], this[0]>;
}

type Length<Text extends Serializable> = Split<Stringify<Text>>["length"];
interface TLength<Text extends Serializable | void = void> extends Fn<{
    0: Serializable;
}> {
    slot: [Text];
    data: Length<this[0]>;
}

type OccurrenceHelper<Input extends string, Substring extends string, Count extends Substring[] = []> = Input extends `${string}${Substring}${infer Slice}` ? OccurrenceHelper<Slice, Substring, [...Count, Substring]> : Size<Count>;
type Occurrence<Input extends string, Substring extends string> = OccurrenceHelper<Input, Substring>;
interface TOccurrence<Substring extends string | void = void, Input extends string | void = void> extends Fn<{
    0: Substring;
    1: Input;
}> {
    slot: [Substring, Input];
    data: Occurrence<this[1], this[0]>;
}

type PadEnd$1<Text extends string, Size extends number, Suffix extends string = "0"> = Length<Text> extends Size ? Text : PadEnd$1<Append<Text, Suffix>, Size, Suffix>;
interface TPadEnd<Size extends number | void = void, Suffix extends string | void = "0", Text extends string | void = void> extends Fn<{
    0: number;
    1: string;
    2: string;
}> {
    slot: [Size, Suffix, Text];
    data: PadEnd$1<this[2], this[0], this[1]>;
}

type PadStart$1<Text extends string, Size extends number, Prefix extends string = "0"> = Length<Text> extends Size ? Text : PadStart$1<Prepend<Text, Prefix>, Size, Prefix>;
interface TPadStart<Size extends number | void = void, Prefix extends string | void = "0", Text extends string | void = void> extends Fn<{
    0: number;
    1: string;
    2: string;
}> {
    slot: [Size, Prefix, Text];
    data: PadStart$1<this[2], this[0], this[1]>;
}

type Pattern<Text extends Serializable, StartsWith extends Serializable = "", EndsWith extends Serializable = ""> = `${StartsWith}${Text}${EndsWith}`;
interface TPattern<StartsWith extends Serializable | void = "", EndsWith extends Serializable | void = "", Text extends Serializable | void = void> extends Fn<{
    0: Serializable;
    1: Serializable;
    2: Serializable;
}> {
    slot: [StartsWith, EndsWith, Text];
    data: Pattern<this[2], this[0], this[1]>;
}

type PlaceHelper<Text extends string, Segment extends string, Index extends number> = `${Substring<Text, 0, Index>}${Segment}${Substring<Text, Index, Length<Text>>}`;
type Place<Text extends string, Segment extends string, Index extends number> = LastOfUnion<Index> extends infer L ? IsNever<L> extends 1 ? Text : L extends number ? Place<PlaceHelper<Text, Segment, Locate<Length<Text>, L>>, Segment, Exclude<Index, L>> : Text : never;
interface TPlace<Segment extends string | void = void, Index extends number | void = void, Text extends string | void = void> extends Fn<{
    0: string;
    1: number;
    2: string;
}> {
    slot: [Segment, Index, Text];
    data: Place<this[2], this[0], this[1]>;
}

type Prepend<Text extends string, Segment extends string> = `${Segment}${Text}`;
interface TPrepend<Segment extends string | void = void, Text extends string | void = void> extends Fn<{
    0: string;
    1: string;
}> {
    slot: [Segment, Text];
    data: Prepend<this[1], this[0]>;
}

type ReplaceHelper<Text extends string, Search extends string, Replacement extends string> = Text extends `${infer X}${Search}${infer U}` ? `${X}${Replacement}${ReplaceHelper<U, Search, Replacement>}` : Text;
type Replace<Text extends string, Search extends string, Replacement extends string> = LastOfUnion<Search> extends infer L ? IsNever<L> extends 1 ? Text : L extends string ? Replace<ReplaceHelper<Text, L, Replacement>, Exclude<Search, L>, Replacement> : Text : never;
interface TReplace<Search extends string | void = void, Replacement extends string | void = void, Text extends string | void = void> extends Fn<{
    0: string;
    1: string;
    2: string;
}> {
    slot: [Search, Replacement, Text];
    data: Replace<this[2], this[0], this[1]>;
}

type SplitHelper<Text extends string, Delimiter extends string> = Text extends `${infer T}${Delimiter}${infer U}` ? [T, ...SplitHelper<U, Delimiter>] : Text extends Delimiter ? [] : [Text];
type DefaultOptions = {
    removeEmptyEntries: false;
};
type RemoveEmptyEntries<Text extends string[]> = Text extends [
    infer Head,
    ...infer Tail
] ? Tail extends string[] ? Head extends "" ? RemoveEmptyEntries<Tail> : [Head, ...RemoveEmptyEntries<Tail>] : never : Text;
type Split<Text extends string, Delimiter extends string = "", Options extends {
    removeEmptyEntries?: boolean;
} = DefaultOptions> = Options["removeEmptyEntries"] extends true ? RemoveEmptyEntries<SplitHelper<Text, Delimiter>> : SplitHelper<Text, Delimiter>;
interface TSplit<Delimiter extends string | void = void, Options extends {
    removeEmptyEntries?: boolean;
} | void = DefaultOptions, Text extends string | void = void> extends Fn<{
    0: string;
    1: {
        removeEmptyEntries: boolean;
    };
    2: string;
}> {
    slot: [Delimiter, Options, Text];
    data: Split<this[2], this[0], this[1]>;
}

type StartsWith<Text extends string, Segment extends Serializable> = Text extends `${Segment}${string}` ? 1 : 0;
interface TStartsWith<Segment extends Serializable | void = void, Text extends string | void = void> extends Fn<{
    0: Serializable;
    1: string;
}> {
    slot: [Segment, Text];
    data: StartsWith<this[1], this[0]>;
}

type Serializable$1 = string | number | boolean | null;
type ArrayToString<Input extends any[]> = `[${Join$1<Input>}]`;
type ObjectToString<Input extends Record<string, any>> = Join$1<UnionToTuple<{
    [K in keyof Input]: `${Stringify<K>}: ${Stringify<Input[K]>}`;
}[keyof Input]>, ", ">;
type Stringify<Input> = Input extends string ? Input : Input extends Serializable$1 ? `${Input}` : Input extends any[] ? ArrayToString<Input> : Input extends Record<string, any> ? ObjectToString<Input> : never;
interface TStringify<Input extends unknown | void = void> extends Fn<{
    0: unknown;
}> {
    slot: [Input];
    data: Stringify<this[0]>;
}

type Substring<Text extends string, Start extends number, End extends number> = Join$1<Slice<Split<Text>, Start, End>>;
interface TSubstring<Start extends number | void = void, End extends number | void = void, Text extends string | void = void> extends Fn<{
    0: number;
    1: number;
    2: string;
}> {
    slot: [Start, End, Text];
    data: Substring<this[2], this[0], this[1]>;
}

type Template<Stream extends Serializable | Serializable[]> = Stream extends Serializable ? `${Stream}` : Stream extends Serializable[] ? Join$1<Stream> : never;
interface TTemplate<Stream extends Serializable> extends Fn<{
    0: Template<Stream>;
}> {
    slot: [Stream];
    data: Template<this[0]>;
}

type Trim<Text extends string, Letter extends string = "0", Count extends number = -1> = TrimStart<TrimEnd<Text, Letter, Count>, Letter, Count>;
interface TTrim<Letter extends string | void = "0", Count extends number | void = -1, Text extends string | void = void> extends Fn<{
    0: string;
    1: number;
    2: string;
}> {
    slot: [Letter, Count, Text];
    data: Trim<this[2], this[0], this[1]>;
}

type TrimEndHelper<Text extends string, Letter extends string, Count extends number> = Text extends `${infer U}${Letter}` ? TrimEnd<U, Letter, Subtract$1<Count, 1>> : Text;
type TrimEnd<Text extends string, Letter extends string = "0", Count extends number = -1> = Count extends -1 ? Text extends `${infer U}${Letter}` ? TrimEndHelper<U, Letter, Count> : Text : Count extends 0 ? Text : TrimEndHelper<Text, Letter, Count>;
interface TTrimEnd<Letter extends string | void = "0", Count extends number | void = -1, Text extends string | void = void> extends Fn {
    slot: [Letter, Count, Text];
    data: TrimEnd<this[2], this[0], this[1]>;
}

type TrimStartHelper<Text extends string, Letter extends string, Count extends number> = Text extends `${Letter}${infer U}` ? TrimStart<U, Letter, Subtract$1<Count, 1>> : Text;
type TrimStart<Text extends string, Letter extends string = "0", Count extends number = -1> = Count extends -1 ? Text extends `${Letter}${infer U}` ? TrimStartHelper<U, Letter, Count> : Text : Count extends 0 ? Text : TrimStartHelper<Text, Letter, Count>;
interface TTrimStart<Letter extends string | void = "0", Count extends number | void = -1, Text extends string | void = void> extends Fn<{
    0: string;
    1: number;
    2: string;
}> {
    slot: [Letter, Count, Text];
    data: TrimStart<this[2], this[0], this[1]>;
}

type AssignHelper<ObjectType extends Dictionary, PathType extends string, Key extends string, ValueType = never> = PathType extends `${Key}.${infer Rest}` ? ObjectType[Key] extends infer ObjectType ? ObjectType extends Dictionary ? Assign<ObjectType, Rest, ValueType> : Assign<ObjectFromPath<Rest, ValueType>> : never : PathType extends Key ? ValueType : ObjectType[Key] extends Dictionary ? Assign<ObjectType[Key]> : ObjectType[Key];
type Setter<ObjectType extends Dictionary, PathType extends string, ValueType = never> = Intersect<{
    [Key in RequiredKeys<ObjectType> as [ValueType] extends [never] ? Exclude<Key, PathType> : Key]: AssignHelper<ObjectType, PathType, Key, ValueType>;
} & {
    [Key in OptionalKeys<ObjectType> as [ValueType] extends [never] ? Exclude<Key, PathType> : Key]?: AssignHelper<ObjectType, PathType, Key, ValueType>;
}>;
type Assign<ObjectType extends Dictionary, PathType extends Paths<ObjectType> | ArbitraryKey<number> = "", ValueType extends any = never> = PathType extends keyof ObjectType | `${infer Head}.${string}` | "" ? Head extends keyof ObjectType ? Setter<ObjectType, Stringify<PathType>, ValueType> : Intersect<Setter<ObjectType, Stringify<PathType>, ValueType> & ObjectFromPath<Stringify<PathType>, ValueType>> : [ValueType] extends [never] ? Setter<ObjectType, Stringify<PathType>> : ObjectType extends Dictionary ? {
    [Key in keyof ObjectType | PathType]: Key extends keyof ObjectType ? ObjectType[Key] : ValueType;
} : ObjectType;
interface TAssign<PathType extends Paths<Exclude<ObjectType, void>> | ArbitraryKey | void = void, ValueType extends unknown = never, ObjectType extends Dictionary | void = void> extends Fn<{
    0: Paths<Exclude<ObjectType, void>> | ArbitraryKey;
    1: unknown;
    2: Dictionary;
}> {
    slot: [PathType, ValueType, ObjectType];
    data: Assign<this[2], this[0], this[1]>;
}

type ObjectHelper<ObjectType extends Dictionary, PickType extends Dictionary<string, Paths<ObjectType>>> = {
    [Key in keyof PickType]: Get<ObjectType, PickType[Key]>;
};
type ArrayHelper<ObjectType extends Dictionary, PickType extends Paths<ObjectType>[]> = {
    [Key in PickType[number]]: Get<ObjectType, Key>;
};
type StringHelper<ObjectType extends Dictionary, PickType extends string> = {
    [Key in PickType]: Get<ObjectType, Key>;
};
type Collect$1<ObjectType extends Dictionary, PickType extends Dictionary<string, Paths<ObjectType>> | Paths<ObjectType>[] | Paths<ObjectType>> = Unionize<PickType extends Paths<ObjectType>[] ? ArrayHelper<ObjectType, PickType> : PickType extends Dictionary<string, Paths<ObjectType>> ? ObjectHelper<ObjectType, PickType> : PickType extends Paths<ObjectType> ? StringHelper<ObjectType, PickType> : never>;
interface TCollect<PickType extends Dictionary<string, Paths<Exclude<ObjectType, void>>> | Paths<Exclude<ObjectType, void>>[] | Paths<Exclude<ObjectType, void>> | void = void, ObjectType extends Dictionary | void = void> extends Fn<{
    0: Dictionary<string, Paths<Exclude<ObjectType, void>>> | Paths<Exclude<ObjectType, void>>[] | Paths<Exclude<ObjectType, void>>;
    1: Dictionary;
}> {
    slot: [PickType, ObjectType];
    data: Collect$1<this[1], this[0]>;
}

type CombineHelper<Source extends Dictionary[], Result extends Dictionary = {}> = Source extends [
    infer Head extends Dictionary,
    ...infer Rest extends Dictionary[]
] ? CombineHelper<Rest, Merge<Result, Head>> : Source extends Dictionary ? Merge<Result, Source> : Result;
type Combine<Source extends Dictionary[]> = CombineHelper<Source>;
interface TCombine<Source extends Dictionary[] | void = void> extends Fn<{
    0: Dictionary[];
}> {
    slot: [Source];
    data: Combine<this[0]>;
}

type DeepPartialHelper<ObjectType extends Dictionary, PathType extends string, Key extends string> = ObjectType[Key] extends Dictionary ? [PathType] extends [never] ? DeepPartial<ObjectType[Key]> : PathType extends `${Key}.${infer Rest}` ? DeepPartial<ObjectType[Key], Rest> : DeepPartial<ObjectType[Key], ""> : ObjectType[Key];
type DeepPartial<ObjectType extends Dictionary, PathType extends ArbitraryKey | Paths<ObjectType> = never> = [PathType] extends [never] ? {
    [Key in Keys<ObjectType>]?: DeepPartialHelper<ObjectType, PathType, Key>;
} : ObjectType extends Dictionary ? Intersect<{
    [Key in Exclude<RequiredKeys<ObjectType>, PathType>]: DeepPartialHelper<ObjectType, PathType, Key>;
} & {
    [Key in Exclude<OptionalKeys<ObjectType>, PathType>]?: DeepPartialHelper<ObjectType, PathType, Key>;
} & {
    [Key in IncludeKeys<ObjectType, PathType>]?: DeepPartialHelper<ObjectType, PathType, Key>;
}> : ObjectType;
interface TDeepPartial<PathType extends ArbitraryKey | Paths<Exclude<ObjectType, void>> | void = void, ObjectType extends Dictionary | void = void> extends Fn<{
    0: ArbitraryKey | Paths<Exclude<ObjectType, void>>;
    1: Dictionary;
}> {
    slot: [PathType, ObjectType];
    data: DeepPartial<this[1], this[0]>;
}

type DeepRequiredHelper<ObjectType extends Dictionary, PathType extends string, Key extends string> = ObjectType[Key] extends Dictionary ? [PathType] extends [never] ? DeepRequired<ObjectType[Key]> : PathType extends `${Key}.${infer Rest}` ? DeepRequired<ObjectType[Key], Rest> : DeepRequired<ObjectType[Key], ""> : ObjectType[Key];
type DeepRequired<ObjectType extends Dictionary, PathType extends ArbitraryKey | Paths<ObjectType> = never> = [PathType] extends [never] ? {
    [Key in Keys<ObjectType>]: RequireValue<DeepRequiredHelper<ObjectType, PathType, Key>>;
} : ObjectType extends Dictionary ? Intersect<{
    [Key in Exclude<RequiredKeys<ObjectType>, PathType>]: DeepRequiredHelper<ObjectType, PathType, Key>;
} & {
    [Key in Exclude<OptionalKeys<ObjectType>, PathType>]?: DeepRequiredHelper<ObjectType, PathType, Key>;
} & {
    [Key in IncludeKeys<ObjectType, PathType>]: RequireValue<DeepRequiredHelper<ObjectType, PathType, Key>>;
}> : ObjectType;
interface TDeepRequired<PathType extends ArbitraryKey | Paths<Exclude<ObjectType, void>> | void = void, ObjectType extends Dictionary | void = void> extends Fn<{
    0: ArbitraryKey | Paths<Exclude<ObjectType, void>>;
    1: Dictionary;
}> {
    slot: [PathType, ObjectType];
    data: DeepRequired<this[1], this[0]>;
}

type Diff<Left extends Dictionary, Right extends Dictionary> = Merge<Pick<Left, Exclude<keyof Left, keyof Right>>, Pick<Right, Exclude<keyof Right, keyof Left>>>;
interface TDiff<Right extends Dictionary, Left extends Dictionary> extends Fn<{
    0: Dictionary;
    1: Dictionary;
}> {
    slot: [Right, Left];
    data: Diff<this[1], this[0]>;
}

type ExcludeKeys<ObjectType extends Dictionary, PathType extends ArbitraryKey | Paths<ObjectType> = never> = Exclude<Keys<ObjectType>, PathType>;
interface TExcludeKeys<PathType extends ArbitraryKey | Paths<Exclude<ObjectType, void>> | void = void, ObjectType extends Dictionary | void = void> extends Fn<{
    0: ArbitraryKey | Paths<Exclude<ObjectType, void>>;
    1: Dictionary;
}> {
    slot: [PathType, ObjectType];
    data: ExcludeKeys<this[1], this[0]>;
}

type ExtractNestedKeys<Text extends string, Delimiter extends string = "."> = Text extends `${string}${Delimiter}${infer Segment}` ? Segment : Text;
interface TExtractNestedKeys<Delimiter extends string | void = ".", Text extends string | void = void> extends Fn<{
    0: string;
    1: string;
}> {
    slot: [Delimiter, Text];
    data: ExtractNestedKeys<this[1], this[0]>;
}

type ExtractRootKey<Text extends string, Delimiter extends string = "."> = Text extends `${infer Segment}${Delimiter}${string}` ? Segment : Text;
interface TExtractRootKey<Delimiter extends string | void = ".", Text extends string | void = void> extends Fn<{
    0: string;
    1: string;
}> {
    slot: [Delimiter, Text];
    data: ExtractRootKey<this[1], this[0]>;
}

type FromEntries<EntryList extends any[][]> = {
    [Key in EntryList[number][0]]: Extract<EntryList[number], [Key, any]>[1];
};
interface TFromEntries<EntryList extends unknown[][] | void = void> extends Fn<{
    0: unknown[][];
}> {
    slot: [EntryList];
    data: FromEntries<this[0]>;
}

/**
 * Represents the value at a path in an object.
 *
 * @template ObjectType The type of the object.
 * @template Path The type of the path.
 * @template Delimiter The type of the delimiter.
 */
type Get<ObjectType extends Dictionary, Path extends Paths<ObjectType, Delimiter> | ArbitraryKey<number>, Fallback extends unknown = never, Delimiter extends string = "."> = Stringify<Path> extends Keys<ObjectType> ? ObjectType[Stringify<Path>] : Path extends `${infer Key}${Delimiter}${infer Rest}` ? ObjectType[Key] extends Dictionary ? Get<ObjectType[Key], Rest, Fallback> : Fallback : Fallback;
interface TGet<Path extends Paths<Exclude<ObjectType, void>, Exclude<Delimiter, void>> | ArbitraryKey<number> | void = void, Fallback extends unknown = never, Delimiter extends string | void = ".", ObjectType extends Dictionary | void = void> extends Fn<{
    0: Paths<Exclude<ObjectType, void>, Exclude<Delimiter, void>> | ArbitraryKey<number>;
    1: unknown;
    2: string;
    3: Dictionary;
}> {
    slot: [Path, Fallback, Delimiter, ObjectType];
    data: Get<this[3], this[0], this[1], this[2]>;
}

type Has<ObjectType extends Dictionary, Key extends string | number | symbol, Delimiter extends string = "."> = Key extends Paths<ObjectType, Delimiter> ? 1 : 0;
interface THas<Key extends string | number | symbol | void = void, Delimiter extends string | void = ".", ObjectType extends Dictionary | void = void> extends Fn<{
    0: string | number | symbol;
    1: string;
    2: Dictionary;
}> {
    slot: [Key, Delimiter, ObjectType];
    data: Has<this[2], this[0], this[1]>;
}

type ImmutableShallow<T> = {
    readonly [K in keyof T & {}]: T[K];
};
type ImmutableObject<T> = {
    readonly [K in keyof T]: Immutable<T[K]>;
};
type ImmutableArray<T> = ImmutableShallow<ReadonlyArray<Immutable<T>>>;
type ImmutableMap<K, V> = Readonly<ReadonlyMap<Immutable<K>, Immutable<V>>>;
type ImmutableSet<T> = Readonly<ReadonlySet<Immutable<T>>>;
type Immutable<T> = T extends Array<infer U> ? ImmutableArray<U> : T extends Map<infer K, infer V> ? ImmutableMap<K, V> : T extends Set<infer M> ? ImmutableSet<M> : T extends Dictionary ? ImmutableObject<T> : Readonly<T>;
interface TImmutable<T extends unknown | void = void> extends Fn<{
    0: unknown;
}> {
    slot: [T];
    data: Immutable<this[0]>;
}

type IncludeKeys<ObjectType extends Dictionary, PathType extends ArbitraryKey | Paths<ObjectType> = never> = Extract<Keys<ObjectType>, PathType>;
interface TIncludeKeys<PathType extends ArbitraryKey | Paths<Exclude<ObjectType, void>> | void = void, ObjectType extends Dictionary | void = void> extends Fn<{
    0: ArbitraryKey | Paths<Exclude<ObjectType, void>>;
    1: Dictionary;
}> {
    slot: [PathType, ObjectType];
    data: IncludeKeys<this[1], this[0]>;
}

type JoinKeys<RootKey extends string, Key extends string, Delimiter extends string = "."> = RootKey extends "" ? Key : `${RootKey}${Delimiter}${Key}`;
interface TJoinKeys<Key extends string | void = void, Delimiter extends string | void = ".", RootKey extends string | void = void> extends Fn<{
    0: string;
    1: string;
    2: string;
}> {
    slot: [Key, Delimiter, RootKey];
    data: JoinKeys<this[2], this[0], this[1]>;
}

type Keys<ObjectType extends Dictionary> = keyof ObjectType extends undefined ? never : keyof ObjectType extends infer Keys extends string | number ? `${Keys}` : never;
interface TKeys<ObjectType extends Dictionary | void = void> extends Fn {
    slot: [ObjectType];
    data: Keys<this[0]>;
}

type KeysAsTupleHelper<ObjectType extends Dictionary, Keys extends any[] = []> = LastOfUnion<keyof ObjectType> extends infer Key ? [Key] extends [never] ? Keys : Key extends keyof ObjectType ? KeysAsTupleHelper<Omit<ObjectType, Key>, [Key, ...Keys]> : never : Keys;
type KeysAsTuple<ObjectType extends Dictionary> = KeysAsTupleHelper<ObjectType>;
interface TKeysAsTuple<ObjectType extends Dictionary | void = void> extends Fn<{
    0: Dictionary;
}> {
    slot: [ObjectType];
    data: KeysAsTuple<this[0]>;
}

type Merge<Source extends Dictionary, Target extends Dictionary> = Intersect<{
    [Key in keyof Source as Key extends keyof Target ? never : Key]: Source[Key];
} & {
    [Key in keyof Target as Key extends keyof Source ? never : Key]: Target[Key];
} & {
    [Key in keyof Source & keyof Target]: Source[Key] extends Dictionary ? Target[Key] extends Dictionary ? Merge<Source[Key], Target[Key]> : Target[Key] : Target[Key];
}>;
interface TMerge<Target extends Dictionary | void = void, Source extends Dictionary | void = void> extends Fn<{
    0: Dictionary;
    1: Dictionary;
}> {
    slot: [Target, Source];
    data: Merge<this[1], this[0]>;
}

type Mutable<ObjectType extends Dictionary> = ObjectType extends Primitives | Indexable | Structures | Derivatives ? ObjectType : Intersect<{
    -readonly [K in keyof ObjectType]: ObjectType[K] extends Record<string, any> ? Mutable<ObjectType[K]> : ObjectType[K];
}>;
interface TMutable<ObjectType extends Dictionary | void = void> extends Fn<{
    0: Dictionary;
}> {
    slot: [ObjectType];
    data: Mutable<this[0]>;
}

type ObjectFromPath<Path extends string, Value extends any, Delimiter extends string = "."> = Path extends `${infer Head}${Delimiter}${infer Rest}` ? {
    [K in Head]: ObjectFromPath<Rest, Value>;
} : {
    [K in Path]: Value;
};
interface TObjectFromPath<Value extends unknown = void, Delimiter extends string | void = ".", Path extends string | void = void> extends Fn<{
    0: string;
    1: unknown;
    2: string;
}> {
    slot: [Value, Delimiter, Path];
    data: ObjectFromPath<this[2], this[0], this[1]>;
}

type OmitOptionalValues<ObjectType extends Dictionary> = ObjectType extends Dictionary ? Intersect<{
    [K in RequiredKeys<ObjectType>]: ObjectType[K] extends infer T ? T extends Dictionary ? OmitOptionalValues<T> : T : never;
}> : ObjectType;
interface TOmitOptionalValues<ObjectType extends Dictionary | void = void> extends Fn<{
    0: Dictionary;
}> {
    slot: [ObjectType];
    data: OmitOptionalValues<this[0]>;
}

type OmitPathHelper<ObjectType extends Dictionary, PathType extends string, Key extends string> = ObjectType[Key] extends Dictionary ? PathType extends `${Key}.${infer Rest}` ? OmitPath<ObjectType[Key], Rest> : OmitPath<ObjectType[Key]> : ObjectType[Key];
type OmitPath<ObjectType extends Dictionary, PathType extends Paths<ObjectType> | ArbitraryKey = ""> = ObjectType extends Dictionary ? Intersect<{
    [Key in Exclude<RequiredKeys<ObjectType>, PathType>]: OmitPathHelper<ObjectType, PathType, Key>;
} & {
    [Key in Exclude<OptionalKeys<ObjectType>, PathType>]?: OmitPathHelper<ObjectType, PathType, Key>;
}> : ObjectType;
interface TOmitPath<PathType extends Paths<Exclude<ObjectType, void>> | void = void, ObjectType extends Dictionary | void = void> extends Fn<{
    0: Paths<Exclude<ObjectType, void>>;
    1: Dictionary;
}> {
    slot: [PathType, ObjectType];
    data: OmitPath<this[1], this[0]>;
}

type OmitRequiredValues<ObjectType extends Dictionary> = ObjectType extends Dictionary ? Intersect<{
    [K in OptionalKeys<ObjectType>]: ObjectType[K] extends infer T ? T extends Dictionary ? OmitRequiredValues<T> : T : never;
}> : ObjectType;
interface TOmitRequiredValues<ObjectType extends Dictionary | void = void> extends Fn<{
    0: Dictionary;
}> {
    slot: [ObjectType];
    data: OmitRequiredValues<this[0]>;
}

/**
 * Used in filtering out the optional keys in a dictionary.
 *
 * @params ObjectType The type of the store.
 * @params Key The type of the key.
 *
 * @return The keys that are optional in the dictionary.
 *
 * @example
 * { [Key in keyof ObjectType as OptionalKeyMap<ObjectType, Key>]: ObjectType[Key] }
 */
type OptionalKeyMap<ObjectType extends Dictionary, Key extends keyof ObjectType> = ObjectType[Key] extends Required<ObjectType>[Key] ? never : Key;

type OptionalKeys<ObjectType extends Dictionary> = {
    [Key in Keys<ObjectType>]: IsPartial<ObjectType[Key]> extends 1 ? Key : never;
}[Keys<ObjectType>];
interface TOptionalKeys<ObjectType extends Dictionary | void = void> extends Fn<{
    0: Dictionary;
}> {
    slot: [ObjectType];
    data: OptionalKeys<this[0]>;
}

type OptionalKeysDeepHelper<ObjectType extends Dictionary, Root extends string = ""> = Elements<UnionToTuple<{
    [Key in Keys<ObjectType>]: IsPartial<ObjectType[Key]> extends 1 ? ObjectType[Key] extends Dictionary ? Key | OptionalKeysDeepHelper<ObjectType[Key], Key> : JoinKeys<Root, Key> : never;
}[Keys<ObjectType>]>>;
type OptionalKeysDeep<ObjectType extends Dictionary> = OptionalKeysDeepHelper<ObjectType>;
interface TOptionalKeysDeep<ObjectType extends Dictionary | void = void> extends Fn<{
    0: Dictionary;
}> {
    slot: [ObjectType];
    data: OptionalKeysDeep<this[0]>;
}

type PathsHelper<ObjectType extends Dictionary, Key extends string | number, Delimiter extends string, Level extends number> = Level extends 0 ? `${Key}` : Level extends -1 ? `${Key}` | `${Key}${Delimiter}${Paths<ObjectType, Delimiter>}` : `${Key}` | `${Key}${Delimiter}${Paths<ObjectType, Delimiter, Subtract$1<Level, 1>>}`;
/**
 * Get all the possible paths of an object
 *
 * @param ObjectType - The object to get the paths from
 * @param [Delimiter = "."] - The delimiter to use to separate the keys
 * @param [Level = -1] - The level to stop the recursion
 */
type Paths<ObjectType extends Dictionary, Delimiter extends string = ".", Level extends number = -1> = ObjectType extends Dictionary ? {
    [Key in Keys<ObjectType>]: Key extends string | number ? ObjectType[Key] extends infer ObjectType ? ObjectType extends Dictionary ? PathsHelper<ObjectType, Key, Delimiter, Level> : `${Key}` : never : never;
}[Keys<ObjectType>] : never;
interface TPaths<Delimiter extends string | void = ".", Level extends number | void = -1, ObjectType extends Dictionary | void = void> extends Fn<{
    0: string;
    1: number;
    2: Dictionary;
}> {
    slot: [Delimiter, Level, ObjectType];
    data: Paths<this[2], this[0], this[1]>;
}

type RequireValue<Value> = Exclude<Value, undefined> extends infer Required ? IsNever<Required> extends 1 ? undefined : Required : never;
interface TRequireValue<Value extends unknown | void = void> extends Fn<{
    0: unknown;
}> {
    slot: [Value];
    data: RequireValue<this[0]>;
}

/**
 * Used in filtering out the required keys in a dictionary.
 *
 * @params ObjectType The type of the store.
 * @params Key The type of the key.
 *
 * @return The keys that are required in the dictionary.
 *
 * @example
 * { [Key in keyof ObjectType as RequiredKeyMap<ObjectType, Key>]: ObjectType[Key] }
 */
type RequiredKeyMap<ObjectType extends Dictionary, Key extends keyof ObjectType> = ObjectType[Key] extends Required<ObjectType>[Key] ? Key : never;

type RequiredKeys<ObjectType extends Dictionary> = {
    [Key in Keys<ObjectType>]: IsPartial<ObjectType[Key]> extends 1 ? never : Key;
}[Keys<ObjectType>];
interface TRequiredKeys<ObjectType extends Dictionary | void = void> extends Fn<{
    0: Dictionary;
}> {
    slot: [ObjectType];
    data: RequiredKeys<this[0]>;
}

type RequiredKeysDeepHelper<ObjectType extends Dictionary, Root extends string = ""> = Elements<UnionToTuple<{
    [Key in Keys<ObjectType>]: IsPartial<ObjectType[Key]> extends 0 ? ObjectType[Key] extends Dictionary ? Key | RequiredKeysDeepHelper<ObjectType[Key], Key> : JoinKeys<Root, Key> : never;
}[Keys<ObjectType>]>>;
type RequiredKeysDeep<ObjectType extends Dictionary> = RequiredKeysDeepHelper<ObjectType>;
interface TRequiredKeysDeep<ObjectType extends Dictionary | void = void> extends Fn<{
    0: Dictionary;
}> {
    slot: [ObjectType];
    data: RequiredKeysDeep<this[0]>;
}

type ToEntries<ObjectType extends Dictionary> = UnionToTuple<{
    [Key in keyof ObjectType]: [Key, ObjectType[Key]];
}[keyof ObjectType]>;
interface TToEntries<ObjectType extends Dictionary | void = void> extends Fn<{
    0: Dictionary;
}> {
    slot: [ObjectType];
    data: ToEntries<this[0]>;
}

type ValuesHelper<ObjectType extends Dictionary, Values extends any[] = []> = LastOfUnion<keyof ObjectType> extends infer Key ? [Key] extends [never] ? Values : Key extends keyof ObjectType ? ValuesHelper<Omit<ObjectType, Key>, [ObjectType[Key], ...Values]> : never : Values;
type Values<ObjectType extends Dictionary> = ValuesHelper<ObjectType>;
interface TValues<ObjectType extends Dictionary | void = void> extends Fn<{
    0: Dictionary;
}> {
    slot: [ObjectType];
    data: Values<this[0]>;
}

type AnchorStructure<List extends unknown[], Rest extends unknown[][]> = [first: List, ...rest: Rest];
type AnchorHelper<List extends unknown[][], Shank extends unknown, Result extends unknown[] = []> = List extends AnchorStructure<infer First, infer Rest> ? AnchorHelper<Rest, Shank, [...Result, Insert<First, 0, Shank>]> : Result;
type Anchor<List extends unknown[]> = List extends [
    infer Shank extends unknown,
    ...infer Rest extends unknown[]
] ? AnchorHelper<Shuffle<Rest>, Shank> : List;
interface TAnchor<List extends unknown[] | void = void> extends Fn<{
    0: unknown[];
}> {
    slot: [List];
    data: Anchor<this[0]>;
}

type ArrayOfHelper<Length extends number, Element extends unknown, Result extends unknown[] = []> = Result["length"] extends Length ? Result : ArrayOfHelper<Length, Element, [Element, ...Result]>;
type ArrayOf<Length extends number, Element extends unknown = any> = ArrayOfHelper<Length, Element>;
interface TArrayOf<Length extends number | void = void, Element extends unknown | void = void> extends Fn<{
    0: number;
    1: unknown;
}> {
    slot: [Length, Element];
    data: ArrayOf<this[0], this[1]>;
}

type CircleStructure<List extends unknown[][]> = [...circle: List];
type Circle<List extends unknown[], Result extends unknown[][] = []> = Size<Result> extends Size<List> ? Result : Circle<RotateLeft<List>, [...Result, List]>;
interface TCircle<List extends unknown[] | void = void> extends Fn<{
    0: unknown;
}> {
    slot: [List];
    data: Circle<this[0]>;
}

type Concat<Left extends unknown[], Right extends unknown[]> = [
    ...Left,
    ...Right
];
interface TConcat<Right extends unknown[] | void = void, Left extends unknown[] | void = void> extends Fn<{
    0: unknown[];
    1: unknown[];
}> {
    slot: [Right, Left];
    data: Concat<this[1], this[0]>;
}

type Count<List extends unknown[], Value extends unknown> = List extends [] ? 0 : List extends [infer Head, ...infer Rest] ? IsExact<Head, Value> extends 1 ? Add$1<1, Count<Rest, Value>> : Count<Rest, Value> : 0;
interface TCount<Value extends unknown | void = void, List extends unknown[] | void = void> extends Fn<{
    0: unknown;
    1: unknown[];
}> {
    slot: [Value, List];
    data: Count<this[1], this[0]>;
}

type Drop<List extends unknown[], Index extends number> = [
    ...SliceTo<List, Index>,
    ...SliceFrom<List, Add$1<Index, 1>>
];
interface TDrop<Index extends number | void = void, List extends unknown[] | void = void> extends Fn<{
    0: unknown;
    1: unknown[];
}> {
    slot: [Index, List];
    data: Drop<this[1], this[0]>;
}

type Elements<List extends any[]> = List[number];
interface TElements<List extends unknown[]> extends Fn<{
    0: unknown[];
}> {
    slot: [List];
    data: Elements<this[0]>;
}

type Entries<List extends unknown[]> = UnionToTuple<{
    [Key in Exclude<keyof List, keyof any[]>]: [ParseInt<Key>, List[Key]];
}[Exclude<keyof List, keyof any[]>]> extends infer Result extends unknown[][] ? Result : never;
interface TEntries<List extends unknown[]> extends Fn<{
    0: unknown[];
}> {
    slot: [List];
    data: Entries<this[0]>;
}

type Every<Callback extends Fn, List extends Fn.Arguments<Callback>[]> = List extends [] ? 1 : List extends [
    infer Element extends Fn.Arguments<Callback>,
    ...infer Rest extends Fn.Arguments<Callback>[]
] ? Apply<Callback, [Element]> extends 1 ? Every<Callback, Rest> : 0 : 0;
interface TEvery<Callback extends Fn, List extends Fn.Arguments<Callback>[] | void = void> extends Fn<{
    0: Fn;
    1: Fn.Arguments<Callback>[];
}> {
    slot: [Callback, List];
    data: Every<this[0], this[1]>;
}

type Expand<List extends unknown[]> = List extends [
    infer Head,
    ...infer Tail
] ? Head extends unknown[] ? [Expand<Head>, ...Expand<Tail>] : [Head, ...Expand<Tail>] : [];
interface TExpand<List extends unknown[] | void = void> extends Fn<{
    0: unknown[];
}> {
    slot: [List];
    data: Expand<this[0]>;
}

type Filter<Callback extends Fn, List extends Fn.Arguments<Callback>[]> = List extends [
    infer Element extends Fn.Arguments<Callback>,
    ...infer Rest extends Fn.Arguments<Callback>[]
] ? Apply<Callback, [Element]> extends 1 ? [Element, ...Filter<Callback, Rest>] : Filter<Callback, Rest> : [];
interface TFilter<Callback extends Fn, List extends Fn.Arguments<Callback> | void = void> extends Fn<{
    0: Fn;
    1: Fn.Arguments<Callback>;
}> {
    slot: [Callback, List];
    data: Filter<this[0], this[1]>;
}

type InfiniteFlat<List extends unknown[], Result extends unknown[] = []> = List extends [infer Head extends unknown[], ...infer Rest] ? InfiniteFlat<Rest, Concat<Result, Head>> : List extends [infer Head, ...infer Rest] ? InfiniteFlat<Rest, Push<Result, Head>> : Result;
type FiniteFlat<List extends unknown[], Depth extends number = 0> = Depth extends 0 ? List : List extends [infer Head, ...infer Rest] ? Head extends unknown[] ? Concat<FiniteFlat<Head, Decrement<Depth>>, FiniteFlat<Rest, Depth>> : Unshift<FiniteFlat<Rest, Depth>, Head> : List;
type Flat<List extends unknown[], Depth extends number = -1> = Depth extends -1 ? InfiniteFlat<List> : FiniteFlat<List, Depth>;
interface TFlat<Depth extends number | void = -1, List extends unknown[] | void = void> extends Fn<{
    0: number;
    1: unknown[];
}> {
    slot: [Depth, List];
    data: Flat<this[1], this[0]>;
}

type Flip<Pair extends [unknown, unknown]> = [Pair[1], Pair[0]];
interface TFlip<Pair extends [unknown, unknown] | void = void> extends Fn<{
    0: unknown;
    1: unknown;
}> {
    slot: [Pair];
    data: Flip<this[0]>;
}

type Head$1<List extends unknown[]> = List extends [
    ...infer Head extends List[number][],
    unknown
] ? Head : never;
interface THead<List extends unknown[] | void = void> extends Fn<{
    0: unknown[];
}> {
    slot: [List];
    data: Head$1<this[0]>;
}

type Includes<List extends any[], Element> = List extends [] ? 0 : List extends [infer Head, ...infer Rest] ? IsExact<Head, Element> extends 1 ? 1 : Includes<Rest, Element> : 0;
interface TIncludes<Element extends unknown | void = void, List extends unknown[] | void = void> extends Fn<{
    0: unknown;
    1: unknown[];
}> {
    slot: [Element, List];
    data: Includes<this[1], this[0]>;
}

type Indices<List extends unknown[], Result extends "Tuple" | "Union" = "Union"> = Exclude<keyof List, keyof unknown[]> extends `${infer Index extends number}` ? Result extends "Tuple" ? UnionToTuple<Index> : Index : never;
interface TIndices<Result extends "Tuple" | "Union" | void = "Union", List extends unknown[] | void = void> extends Fn<{
    0: "Tuple" | "Union";
    1: unknown[];
}> {
    slot: [Result, List];
    data: Indices<this[1], this[0]>;
}

type Insert<List extends unknown[], Index extends number, Value extends unknown> = [...SliceTo<List, Index>, Value, ...SliceFrom<List, Index>];
interface TInsert<Index extends number | void = 0, Value extends unknown | void = void, List extends unknown[] | void = void> extends Fn<{
    0: number;
    1: unknown;
    2: unknown[];
}> {
    slot: [Index, Value, List];
    data: Insert<this[2], this[0], this[1]>;
}

type Join$1<List extends any[], Separator extends string = ""> = List extends [infer Head, ...infer Rest] ? Rest extends [] ? Head : `${Stringify<Head>}${Separator}${Join$1<Rest, Separator>}` : "";
interface TJoin<Separator extends string | void = void, List extends unknown[] | void = void> extends Fn<{
    0: string;
    1: unknown[];
}> {
    slot: [Separator, List];
    data: Join$1<this[1], this[0]>;
}

type LocateHelper<List extends unknown[], Index extends number> = `${Index}` extends `-${infer Index extends number}` ? Subtract$1<Size<List>, Index> extends infer Index ? Index extends number ? GreaterThanOrEqual<Index, 0> extends 1 ? Index : never : never : never : Indices<List> extends infer Keys ? Index extends Keys ? Index : never : never;
type Locate<List extends unknown, Index extends number> = List extends unknown[] ? LocateHelper<List, Index> : List extends number ? LocateHelper<ArrayOf<List>, Index> : never;
interface TLocate<Index extends number | void = void, List extends unknown[] | number | void = void> extends Fn<{
    0: number;
    1: unknown[] | number;
}> {
    slot: [Index, List];
    data: Locate<this[1], this[0]>;
}

type Map$1<Callback extends Fn, List extends Fn.Arguments<Callback>[]> = List extends [
    infer Element extends Fn.Arguments<Callback>,
    ...infer Rest extends Fn.Arguments<Callback>[]
] ? [Apply<Callback, [Element]>, ...Map$1<Callback, Rest>] : [];
interface TMap<Callback extends Fn, List extends Fn.Arguments<Callback>[] | void = void> extends Fn<{
    0: Fn;
    1: Fn.Arguments<Callback>[];
}> {
    slot: [Callback, List];
    data: Map$1<this[0], this[1]>;
}

type PermutationHelper<List extends unknown[], Result extends unknown[][] = []> = Size<Result> extends Size<List> ? Reduce<Result> : PermutationHelper<RotateLeft<List>, [...Result, Anchor<List>]>;
type Permutation<List extends unknown[]> = Size<List> extends 1 ? Reduce<[[List]]> : PermutationHelper<List>;
interface TPermutation<List extends unknown[] | void = void> extends Fn<{
    0: unknown[];
}> {
    slot: [List];
    data: Permutation<this[0]>;
}

type PivotHelper<List extends unknown[], Value extends unknown, Result extends unknown[][] = []> = Size<Result> extends Size<List> ? [...Result, Insert<List, Size<Result>, Value>] : PivotHelper<List, Value, [...Result, Insert<List, Size<Result>, Value>]>;
type Pivot<List extends unknown[], Axis extends number = 0> = Locate<List, Axis> extends infer Index ? Index extends number ? PivotHelper<Drop<List, Index>, Retrieve<List, Index>> : never : never;
interface TPivot<Head extends unknown | void = void, List extends unknown[] | void = void> extends Fn<{
    0: unknown;
    1: unknown[];
}> {
    slot: [Head, List];
    data: Pivot<this[1], this[0]>;
}

type Pop<List extends unknown[]> = List extends [
    ...unknown[],
    infer Element extends List[number]
] ? Element : never;
interface TPop<List extends unknown[] | void = void> extends Fn<{
    0: unknown[];
}> {
    slot: [List];
    data: Pop<this[0]>;
}

type Push<List extends any[], Element> = [...List, Element];
interface TPush<Element extends unknown | void = void, List extends unknown[] | void = void> extends Fn<{
    0: unknown;
    1: unknown[];
}> {
    slot: [Element, List];
    data: Push<this[1], this[0]>;
}

type ChunkComponent<Start extends number, End extends number, Increment extends number, ChunkSize extends number, Head extends number = Min<Add$1<Start, Increment>, End>, Tail extends number = Min<Add$1<Head, ChunkSize>, End>> = [head: Head, tail: Tail];
type InferChunkParts<Head extends number, Tail extends number> = [
    head: Head,
    tail: Tail
];
type TailNumberArray<Head extends number[], Rest extends unknown[]> = [
    Head,
    ...Rest
];
type EnumerateHelper<Start extends number, End extends number, Result extends number[] = [], Next extends number = Add$1<Start, 1>> = Start extends End ? Result : EnumerateHelper<Next, End, Push<Result, Start>>;
type Enumerate<Start extends number, End extends number, Result extends number[] = [], Limit extends number = Subtract$1<End, Start>, Increment extends number = Min<Limit, 9>, Next extends number = Add$1<Start, Increment>, LastRow extends number[] = EnumerateHelper<Start, Next>> = Start extends End ? Result : Enumerate<Next, End, Concat<Result, LastRow>>;
type GenerateChunks<Start extends number, End extends number, Difference extends number = Subtract$1<End, Start>, Width extends number = Length<Difference>, ChunkSize extends number = Ceil<Divide$1<Difference, Width>>, List extends unknown[] = EnumerateHelper<0, Width>> = {
    [Index in keyof List]: List[Index] extends number ? Multiply$1<ChunkSize, List[Index]> extends InferNumber<infer Increment> ? ChunkComponent<Start, End, Increment, ChunkSize> extends InferChunkParts<infer Head, infer Tail> ? Enumerate<Head, Tail> : never : never : never;
};
type FlatChunk<List extends unknown[], Result extends number[] = []> = List extends TailNumberArray<infer Head, infer Rest> ? FlatChunk<Rest, Concat<Result, Head>> : Result;
type Range<From extends number, To extends number> = GenerateChunks<From, To> extends InferArray<infer Chunk, number[]> ? FlatChunk<Chunk> : never;
interface TRange<From extends number | void = void, To extends number | void = void> extends Fn<{
    0: number;
    1: number;
}> {
    slot: [From, To];
    data: Range<this[0], this[1]>;
}

type Reduce<List extends unknown[]> = {
    [K in Indices<List>]: List[K];
};
interface TReduce<List extends unknown[] | void = void> extends Fn<{
    0: unknown[];
}> {
    slot: [List];
    data: Reduce<this[0]>;
}

type Reject<List extends unknown[], Element> = List extends [
    infer Head,
    ...infer Rest
] ? [Head] extends [Element] ? Reject<Rest, Element> : [Head, ...Reject<Rest, Element>] : [];
interface TReject<Element extends unknown | void = void, List extends unknown[] | void = void> extends Fn<{
    0: unknown;
    1: unknown[];
}> {
    slot: [Element, List];
    data: Reject<this[1], this[0]>;
}

type RetrieveHelper<List extends unknown, Index extends number> = List extends {
    [K in Index]: infer Head;
} ? Head : never;
type Retrieve<List extends unknown, Index extends number = 0> = Locate<List, Index> extends infer Position ? Position extends number ? RetrieveHelper<List, Position> : never : never;
interface TRetrieve<Index extends number | void = 0, List extends unknown | void = void> extends Fn<{
    0: number;
    1: unknown;
}> {
    slot: [Index, List];
    data: Retrieve<this[1], this[0]>;
}

type Reverse<List extends any[]> = List extends [
    infer Head,
    ...infer Rest
] ? [...Reverse<Rest>, Head] : [];
interface TReverse<List extends unknown[] | void = void> extends Fn<{
    0: unknown[];
}> {
    slot: [List];
    data: Reverse<this[0]>;
}

type RotateLeftHelper<List extends unknown[], Pivot extends number = 0> = IsNever<Pivot> extends 0 ? Retrieve<List, Pivot> extends infer Element ? IsNever<Element> extends 1 ? List : Push<Concat<SliceTo<List, Pivot>, SliceFrom<List, Add$1<Pivot, 1>>>, Retrieve<List, Pivot>> : never : List;
type RotateLeft<List extends unknown[], Pivot extends number = 0> = RotateLeftHelper<List, Locate<List, Pivot>>;
interface TRotateLeft<Pivot extends number | void = 0, List extends unknown[] | void = void> extends Fn<{
    0: unknown;
    1: unknown[];
}> {
    slot: [Pivot, List];
    data: RotateLeft<this[1], this[0]>;
}

type RotateRight<List extends unknown[], Addendum extends unknown = never> = List extends [...infer Rest extends unknown[], infer Tail extends unknown] ? [[Addendum] extends [never] ? Tail : Addendum, ...Rest] : never;
interface TRotateRight<Addendum extends unknown | void = never, List extends unknown[] | void = void> extends Fn<{
    0: unknown;
    1: unknown[];
}> {
    slot: [Addendum, List];
    data: RotateRight<this[1], this[0]>;
}

type Shift<List extends unknown[]> = List extends [
    infer Element extends List[number],
    ...unknown[]
] ? Element : never;
interface TShift<List extends unknown[] | void = void> extends Fn<{
    0: unknown[];
}> {
    slot: [List];
    data: Shift<this[0]>;
}

type ShuffleStructure<Head extends unknown, Rest extends unknown[]> = [
    head: Head,
    ...rest: Rest
];
type ShuffleHelper<List extends unknown[][], Head extends unknown, Result extends unknown[] = []> = Size<List> extends Size<Result> ? Result : List extends AnchorStructure<infer First, infer Rest> ? ShuffleHelper<Rest, Head, [...Result, ...Pivot<Unshift<First, Head>>]> : Result;
type Shuffle<List extends unknown[]> = List extends ShuffleStructure<infer Head, infer Rest> ? Circle<Rest> extends CircleStructure<infer Revolution> ? Size<Revolution> extends 0 ? [List] : ShuffleHelper<Revolution, Head> : never : [];
interface TShuffle<List extends unknown[] | void = void> extends Fn<{
    0: unknown[];
}> {
    slot: [List];
    data: Shuffle<this[0]>;
}

type Size<List extends any[]> = List["length"];
interface TSize<List extends unknown[] | void = void> extends Fn<{
    0: unknown[];
}> {
    slot: [List];
    data: Size<this[0]>;
}

type Slice<List extends unknown[], Start extends number = 0, End extends number = Size<List>> = List extends [infer First, ...infer Rest] ? Start extends 0 ? End extends 0 ? [] : [First, ...Slice<Rest, 0, Subtract$1<End, 1>>] : Slice<Rest, Subtract$1<Start, 1>, Subtract$1<End, 1>> : [];
interface TSlice<Start extends number | void = void, End extends number | void = void, List extends unknown[] | void = void> extends Fn<{
    0: number;
    1: number;
    2: unknown[];
}> {
    slot: [Start, End, List];
    data: Slice<this[2], this[0], this[1]>;
}

type SliceFromHelper<List extends unknown[], Start extends number> = List extends [...ArrayOf<Start>, ...infer Rest] ? Rest : never;
type SliceFrom<List extends unknown[], Start extends number> = GreaterThan<Start, Size<List>> extends 1 ? SliceFromHelper<List, Size<List>> : LessThan<Start, 0> extends 1 ? SliceFromHelper<List, 0> : SliceFromHelper<List, Start>;
interface TSliceFrom<Start extends number | void = void, List extends unknown[] | void = void> extends Fn<{
    0: number;
    1: unknown[];
}> {
    slot: [Start, List];
    data: SliceFrom<this[1], this[0]>;
}

type SliceToHelper<List extends unknown[], End extends number> = List extends [
    ...infer Rest,
    ...ArrayOf<Subtract$1<Size<List>, End>>
] ? Rest : never;
type SliceTo<List extends unknown[], End extends number = Size<List>> = GreaterThan<End, Size<List>> extends 1 ? SliceToHelper<List, Size<List>> : LessThan<End, 0> extends 1 ? [] : SliceToHelper<List, End>;
interface TSliceTo<To extends number | void = void, List extends unknown[] | void = void> extends Fn<{
    0: number;
    1: unknown[];
}> {
    slot: [To, List];
    data: SliceTo<this[1], this[0]>;
}

type Some<Callback extends Fn, List extends Fn.Arguments<Callback>[]> = List extends [] ? 0 : List extends [
    infer Element extends Fn.Arguments<Callback>,
    ...infer Rest extends Fn.Arguments<Callback>[]
] ? Apply<Callback, [Element]> extends 1 ? 1 : Some<Callback, Rest> : 0;
interface TSome<Callback extends Fn, List extends Fn.Arguments<Callback> | void = void> extends Fn<{
    0: Fn;
    1: Fn.Arguments<Callback>;
}> {
    slot: [Callback, List];
    data: Some<this[0], this[1]>;
}

type SortOperation<Callback extends Fn, Head extends Fn.Signature<Callback>, Rest extends Fn.Signature<Callback>[]> = [first: Head, ...rest: Rest];
type SortHelper<Callback extends Fn, Check extends Fn.Signature<Callback>, List extends Fn.Signature<Callback>[]> = List extends SortOperation<Callback, infer Head, infer Tail> ? Apply<Callback, [Head, Check]> extends 1 ? Unshift<SortHelper<Callback, Check, Tail>, Head> : Unshift<List, Check> : [Check];
type Sort<Callback extends Fn, List extends Fn.Signature<Callback>[]> = List extends SortOperation<Callback, infer First, infer Rest> ? SortHelper<Callback, First, Sort<Callback, Rest>> : List;
interface TSort<Callback extends Fn, List extends Fn.Signature<Callback>[] | void = void> extends Fn<{
    0: Fn;
    1: Fn.Signature<Callback>[];
}> {
    slot: [Callback, List];
    data: Sort<this[0], this[1]>;
}

type Tail<List extends unknown[]> = List extends [
    unknown,
    ...infer Tail extends List[number][]
] ? Tail : never;
interface TTail<List extends unknown[] | void = void> extends Fn<{
    0: unknown[];
}> {
    slot: [List];
    data: Tail<this[0]>;
}

type TrimHead<List extends unknown[], Element> = List extends [
    infer Head,
    ...infer Rest
] ? [Head] extends [Element] ? TrimHead<Rest, Element> : List : List;
interface TTrimHead<Element extends unknown | void = void, List extends unknown[] | void = void> extends Fn<{
    0: unknown;
    1: unknown[];
}> {
    slot: [Element, List];
    data: TrimHead<this[1], this[0]>;
}

type TrimTail<List extends unknown[], Element> = List extends [
    ...infer Rest,
    infer Tail
] ? [Tail] extends [Element] ? TrimTail<Rest, Element> : List : List;
interface TTrimTail<Element extends unknown | void = void, List extends unknown[] | void = void> extends Fn<{
    0: unknown;
    1: unknown[];
}> {
    slot: [Element, List];
    data: TrimTail<this[1], this[0]>;
}

type Unshift<List extends unknown[], Element> = [Element, ...List];
interface TUnshift<Element extends unknown | void = void, List extends unknown[] | void = void> extends Fn<{
    0: unknown;
    1: unknown[];
}> {
    slot: [Element, List];
    data: Unshift<this[1], this[0]>;
}

type ValueAt<List extends any[], Index extends number> = Locate<List, Index> extends infer Position ? Position extends number ? List[Position] : never : never;
interface TValueAt<Index extends number | void = void, List extends unknown[] | void = void> extends Fn<{
    0: number;
    1: unknown[];
}> {
    slot: [Index, List];
    data: ValueAt<this[1], this[0]>;
}

type WithHelper<List extends any[], Index extends number, Element extends unknown | Fn> = [
    ...SliceTo<List, Index>,
    Element extends Fn ? Apply<Element, [List[Index]]> : Element,
    ...SliceFrom<List, Add$1<Index, 1>>
];
type With<List extends any[], Index extends number, Element extends unknown | Fn> = Locate<List, Index> extends infer Position ? IsNever<Position> extends 1 ? List : Position extends number ? WithHelper<List, Position, Element> : never : never;
interface TWith<Index extends number | void = void, Element extends unknown | Fn | void = void, List extends unknown[] | void = void> extends Fn<{
    0: number;
    1: unknown | Fn;
    2: unknown[];
}> {
    slot: [Index, Element, List];
    data: With<this[2], this[0], this[1]>;
}

type Zip<Left extends unknown[], Right extends unknown[]> = Left extends [infer HeadA, ...infer RestA] ? Right extends [infer HeadB, ...infer RestB] ? [[HeadA, HeadB], ...Zip<RestA, RestB>] : [] : [];
interface TZip<Left extends unknown[] | void = void, Right extends unknown[] | void = void> extends Fn<{
    0: unknown[];
    1: unknown[];
}> {
    slot: [Left, Right];
    data: Zip<this[0], this[1]>;
}

type Digit$1 = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9";
type Float<Value extends number, Decimal extends number> = Pow<10, Decimal> extends infer Divisor extends number ? Divide$1<Value, Divisor> : never;
type Int<Input extends number> = `${Input}` extends `${infer R extends number}.${string}` ? R : Input;
type ParseIntHelper<Input extends string, Outlook extends "Signed" | "Unsigned", Accumulator extends string = "", Decimal extends number = 0, Sign extends "-" | "" = ""> = Input extends `${infer Significand extends number}e-${infer Exponential extends number}` ? Float<Significand, Exponential> : Input extends `${infer Head}${infer Input}` ? Head extends Digit$1 ? ParseIntHelper<Input, Outlook, `${Accumulator}${Head}`, Decimal, Sign> : Every<TIsExact<1>, [
    IsSubtype<Outlook, "Signed">,
    IsSubtype<Head, "-">,
    IsSubtype<Accumulator, "">
]> extends 1 ? ParseIntHelper<Input, Outlook, Accumulator, Decimal, "-"> : Head extends "." ? ParseIntHelper<Input, Outlook, Accumulator, Length<Accumulator>, Sign> : ParseIntHelper<Input, Outlook, Accumulator, Decimal, Sign> : `${Sign}${TrimStart<Accumulator>}` extends `${infer Input extends number}` ? Decimal extends 0 ? Input : Float<Input, Subtract$1<Length<Accumulator>, Decimal>> : Input;
type ParseInt<Input extends Primitives, Outlook extends "Signed" | "Unsigned" = "Unsigned", Output extends "Integer" | "Float" = "Float"> = Input extends number ? Output extends "Float" ? Input : Int<Input> : Input extends string ? ParseIntHelper<Input, Outlook> extends infer Value extends number ? Output extends "Float" ? Value : Int<Value> : 0 : Input extends true | symbol ? 1 : Input extends false | null | undefined ? 0 : Input;
interface TParseInt<Outlook extends "Signed" | "Unsigned" | void = "Unsigned", Output extends "Integer" | "Float" | void = "Float", Input extends string | number | boolean | void = void> extends Fn<{
    0: "Signed" | "Unsigned";
    1: "Integer" | "Float";
    2: string | number | boolean;
}> {
    slot: [Outlook, Output, Input];
    data: ParseInt<this[2], this[0], this[1]>;
}

/**
 * Returns the absolute value of a number.
 *
 * @param Number - The number to get the absolute value of.
 * @returns The absolute value of the number.
 *
 * @example
 * ```ts
 * import type { Absolute } from "@ibnlanre/types";
 *
 * type Test = Absolute<-5>;
 * //   ^? 5
 * ```
 */
type Absolute$1<Number extends number> = Math.Absolute<Number>;
/**
 * Returns the absolute value of a number.
 *
 * @param Number - The number to get the absolute value of.
 * @returns The absolute value of the number.
 *
 * @examples
 * ```ts
 * import type { Apply, TAbsolute } from "@ibnlanre/types";
 *
 * type Test = Apply<TAbsolute, [-5]>;
 * //   ^? 5
 * ```
 */
interface TAbsolute<Number extends number | void = void> extends Fn<{
    0: number;
}> {
    slot: [Number];
    data: Absolute$1<this[0]>;
}

/**
 * Adds two numbers.
 *
 * @param Augend - The number to add to.
 * @param Addend - The number to add.
 *
 * @returns The sum of the two numbers.
 */
type Add$1<Augend extends number, Addend extends number> = Math.Add<Augend, Addend>;
/**
 * Adds two numbers.
 *
 * @param Addend - The number to add.
 * @param Augend - The number to add to.
 *
 * @returns The sum of the two numbers.
 *
 * @example
 * type Test = Call<TAdd<5, 5>>; // 10
 * type Test = Apply<Add<6>, [4]>; // 10
 */
interface TAdd<Addend extends number | void = void, Augend extends number | void = void> extends Fn<{
    0: number;
    1: number;
}> {
    slot: [Addend, Augend];
    data: Add$1<this[1], this[0]>;
}

type Addition$1<Numbers extends number[]> = Math.Addition<Numbers>;
interface TAddition<Numbers extends number[] | void = void> extends Fn<{
    0: number[];
}> {
    slot: [Numbers];
    data: Addition$1<this[0]>;
}

type CeilHelper<Value extends number, DecimalPart extends number = Math.Mod<Value, 1>, IntegerPart extends number = Math.Subtract<Value, DecimalPart>> = DecimalPart extends 0 ? Value : `${Value}` extends `-${number}` ? IntegerPart : Math.Add<IntegerPart, 1>;
type Ceil<Value extends number> = CeilHelper<Value>;
interface TCeil<Value extends number | void = void> extends Fn<{
    0: number;
}> {
    slot: [Value];
    data: Ceil<this[0]>;
}

type Decrement<Number extends number> = Math.Subtract<Number, 1>;
interface TDecrement<Number extends number | void = void> extends Fn<{
    0: number;
}> {
    slot: [Number];
    data: Decrement<this[0]>;
}

type EuclideanDivision<Dividend extends number, Divisor extends number> = Math.Multiply<Math.Signum<Divisor>, Floor$1<Math.Divide<Dividend, Math.Absolute<Divisor>>>>;

type FlooredDivision<Dividend extends number, Divisor extends number> = Floor$1<Math.Divide<Dividend, Divisor>>;

type TruncatingDivision<Dividend extends number, Divisor extends number> = Trunc<Math.Divide<Dividend, Divisor>>;

type TypeOptions = "Euclidean" | "Truncating" | "Floored" | "Integer";
type Divide$1<Dividend extends number, Divisor extends number, Type extends TypeOptions = "Integer"> = Type extends "Integer" ? Math.Divide<Dividend, Divisor> : Type extends "Euclidean" ? EuclideanDivision<Dividend, Divisor> : Type extends "Truncating" ? TruncatingDivision<Dividend, Divisor> : Type extends "Floored" ? FlooredDivision<Dividend, Divisor> : never;
interface TDivide<Divisor extends number | void = void, Type extends TypeOptions | void = "Integer", Dividend extends number | void = void> extends Fn<{
    0: number;
    1: TypeOptions;
    2: number;
}> {
    slot: [Divisor, Type, Dividend];
    data: Divide$1<this[2], this[0], this[1]>;
}

type Division$1<Numbers extends number[]> = Math.Division<Numbers>;
interface TDivision<Numbers extends number[] | void = void> extends Fn<{
    0: number[];
}> {
    slot: [Numbers];
    data: Division$1<this[0]>;
}

type Floor$1<Value extends number> = Math.Floor<Value>;
interface TFloor<Value extends number | void = void> extends Fn<{
    0: number;
}> {
    slot: [Value];
    data: Floor$1<this[0]>;
}

type Increment<Number extends number> = Math.Add<Number, 1>;
interface TIncrement<Number extends number | void = void> extends Fn<{
    0: number;
}> {
    slot: [Number];
    data: Increment<this[0]>;
}

type EuclideanMod<Dividend extends number, Divisor extends number> = Math.Absolute<Divisor> extends infer R extends number ? Math.Mod<Math.Add<Math.Mod<Dividend, R>, R>, R> : never;

type FlooredMod<Dividend extends number, Divisor extends number> = Math.Mod<Math.Add<Math.Mod<Dividend, Divisor>, Divisor>, Divisor>;

/**
 * @description
 * - It is no different from the Floored Modulo operator, except that it uses a different approach.
 */
type KnuthianMod<Dividend extends number, Divisor extends number> = Math.Subtract<Dividend, Math.Multiply<Floor$1<Math.Divide<Dividend, Divisor>>, Divisor>>;

type TruncatingMod<Dividend extends number, Divisor extends number> = Math.Mod<Dividend, Divisor>;

/**
 * Returns the remainder of the division of `Dividend` by `Divisor`.
 *
 * @description
 * - If both dividend and divisor are positive, then all three definitions agree.
 * - If the dividend is positive and the divisor is negative, then the truncating and Euclidean definitions agree.
 * - If the dividend is negative and the divisor is positive, then the flooring and Euclidean definitions agree.
 * - If both dividend and divisor are negative, then the truncating and flooring definitions agree.
 */
type Modulo<Dividend extends number, Divisor extends number, Type extends "Euclidean" | "Knuthian" | "Truncating" | "Floored" = "Truncating"> = Type extends "Euclidean" ? EuclideanMod<Dividend, Divisor> : Type extends "Knuthian" ? KnuthianMod<Dividend, Divisor> : Type extends "Truncating" ? TruncatingMod<Dividend, Divisor> : Type extends "Floored" ? FlooredMod<Dividend, Divisor> : never;
interface TModulo<Divisor extends number | void = void, Type extends "Euclidean" | "Knuthian" | "Truncating" | "Floored" | void = "Truncating", Dividend extends number | void = void> extends Fn<{
    0: number;
    1: "Euclidean" | "Knuthian" | "Truncating" | "Floored";
    2: number;
}> {
    slot: [Divisor, Type, Dividend];
    data: Modulo<this[2], this[0], this[1]>;
}

type Multiplication$1<Numbers extends number[]> = Math.Multiplication<Numbers>;
interface TMultiplication<Numbers extends number[] | void = void> extends Fn<{
    0: number[];
}> {
    slot: [Numbers];
    data: Multiplication$1<this[0]>;
}

type Multiply$1<Multiplicand extends number, Multiplier extends number> = Math.Multiply<Multiplicand, Multiplier>;
interface TMultiply<Multiplier extends number | void = void, Multiplicand extends number | void = void> extends Fn<{
    0: number;
    1: number;
}> {
    slot: [Multiplier, Multiplicand];
    data: Multiply$1<this[1], this[0]>;
}

type Negate$1<Predicate extends number> = Math.Negate<Predicate>;
interface TNegate<Predicate extends number | void = void> extends Fn<{
    0: number;
}> {
    slot: [Predicate];
    data: Negate$1<this[0]>;
}

type NoNumberHelper<Value extends string, Result extends string> = Value extends `${infer Slice}${infer Substring}` ? `${Slice}` extends `${number}` ? NoNumberHelper<Substring, Result> : NoNumberHelper<Substring, `${Result}${Slice}`> : Result;
type NoNumber<Value extends string> = NoNumberHelper<Value, "">;
interface TNoNumber<Value extends string | void = void> extends Fn<{
    0: string;
}> {
    slot: [Value];
    data: NoNumber<this[0]>;
}

type Suffixes = ["th", "st", "nd", "rd"];
type Coordinate<Digit extends number, WithinRange extends Bit = LessThan<Digit, Size<Suffixes>>, NotNegative extends Bit = IsPositive$1<Digit>> = And<WithinRange, NotNegative> extends 1 ? Retrieve<Suffixes, Digit> : Retrieve<Suffixes>;
type OrdinalHelper<NumberToOrdinal extends number, TensDigit extends number = Math.Mod<Math.Absolute<NumberToOrdinal>, 100>, UnitsDigit extends number = GreaterThan<TensDigit, 10> extends 1 ? Math.Mod<Math.Subtract<TensDigit, 20>, 10> : TensDigit> = Stringify<NumberToOrdinal> extends infer Value ? Value extends string ? Includes<Suffixes, Coordinate<UnitsDigit>> extends 1 ? Append<Value, Coordinate<UnitsDigit>> : Includes<Suffixes, Coordinate<TensDigit>> extends 1 ? Append<Value, Coordinate<TensDigit>> : Append<Value, Retrieve<Suffixes>> : never : never;
type Ordinal<Value extends number> = OrdinalHelper<Value>;
interface TOrdinal<Value extends number | void = void> extends Fn<{
    0: number;
}> {
    slot: [Value];
    data: Ordinal<this[0]>;
}

type Pow<Base extends number, Exponent extends number> = Math.Power<Base, Exponent>;
interface TPow<Exponent extends number | void = void, Base extends number | void = void> extends Fn<{
    0: number;
    1: number;
}> {
    slot: [Exponent, Base];
    data: Pow<this[1], this[0]>;
}

type Round$1<Value extends number, MidPointRounding extends "AwayFromZero" | "ToEven" = "ToEven"> = Math.Round<Value, MidPointRounding>;
interface TRound<MidPointRounding extends "AwayFromZero" | "ToEven" | void = "ToEven", Value extends number | void = void> extends Fn<{
    0: "AwayFromZero" | "ToEven";
    1: number;
}> {
    slot: [MidPointRounding, Value];
    data: Round$1<this[1], this[0]>;
}

/**
 * Signum representation of a number.
 *
 * @description
 * The signum function of a number is a mathematical function that extracts the sign of a real number.
 *
 * @summary
 * - If the number is negative, the signum is -1.
 * - If the number is positive, the signum is 1.
 * - If the number is zero, the signum is 0.
 *
 * @param Number The number to get the signum of.
 * @returns The signum of the number.
 */
type Sign$1<Number extends number> = Math.Signum<Number>;
interface TSign<Value extends number | void = void> extends Fn<{
    0: number;
}> {
    slot: [Value];
    data: Sign$1<this[0]>;
}

type SquareRoot$1<Number extends number> = Math.SquareRoot<Number>;
interface TSquareRoot<Number extends number | void = void> extends Fn<{
    0: number;
}> {
    slot: [Number];
    data: SquareRoot$1<this[0]>;
}

type Subtract$1<Left extends number, Right extends number> = Math.Subtract<Left, Right>;
interface TSubtract<Right extends number | void = void, Left extends number | void = void> extends Fn<{
    0: number;
    1: number;
}> {
    slot: [Right, Left];
    data: Subtract$1<this[1], this[0]>;
}

type Subtraction$1<Numbers extends number[]> = Math.Subtraction<Numbers>;
interface TSubtraction<Numbers extends number[] | void = void> extends Fn<{
    0: number[];
}> {
    slot: [Numbers];
    data: Subtraction$1<this[0]>;
}

type ToFixed$1<Value extends number, Digits extends number> = Math.ToFixed<Value, Digits>;
interface TToFixed<Digits extends number | void = void, Value extends number | void = void> extends Fn<{
    0: number;
    1: number;
}> {
    slot: [Digits, Value];
    data: ToFixed$1<this[1], this[0]>;
}

type Trunc<Value extends number> = Math.Subtract<Value, Math.Mod<Value, 1>>;
interface TTrunc<Value extends number | void = void> extends Fn<{
    0: number;
}> {
    slot: [Value];
    data: Trunc<this[0]>;
}

type BitMap<False = unknown, True = unknown> = {
    0: False;
    1: True;
};

type FourBitRowVector = [Bit, Bit, Bit, Bit];

type FourBitSquareMatrix<Nibble extends FourBitRowVector> = BitMap<BitMap<Nibble[0], Nibble[1]>, BitMap<Nibble[2], Nibble[3]>>;

type Bit = 0 | 1;
declare namespace Bit {
    export type { BitMap, FourBitRowVector, FourBitSquareMatrix };
}

/**
 * Negative digit.
 */
type Negative = Negate$1<Digit>;
/**
 * @category Digit
 * @namespace Negative
 * @public
 */
declare namespace Negative {
    type String = `${Negative}`;
}

/**
 * Serialized digits of numbers.
 */
type Serialized = `${number}`;

/**
 * Signed digit.
 */
type Signed = Digit | Negative;
/**
 * @category Digit
 * @namespace Signed
 * @public
 */
declare namespace Signed {
    type String = `${Signed}`;
}

/**
 * Stringified digit.
 */
type String = `${Digit}`;

/**
 * Tuple of digits.
 */
type Tuple = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
/**
 * @category Digit
 * @namespace Tuple
 * @public
 */
declare namespace Tuple {
    type Negative = UnionToTuple<Digit.Negative>;
    namespace Negative {
        type String = UnionToTuple<Digit.Negative.String>;
    }
    type Signed = UnionToTuple<Digit.Signed>;
    namespace Signed {
        type String = UnionToTuple<Digit.Signed.String>;
    }
}

type Digit = Tuple[number];
declare namespace Digit {
    export type { String, Serialized, Negative, Signed, Tuple };
}

/**
 * Checks if a number is even.
 *
 * @param Value The number to check if it is even.
 *
 * @returns
 * `1` if the number is even, `0` otherwise.
 */
type IsEven$1<Value extends number> = Math.IsEven<Value>;
/**
 * Checks if a number is even.
 *
 * @param Value The number to check if it is even.
 *
 * @returns
 * `1` if the number is even, `0` otherwise.
 */
interface TIsEven<Value extends number | void = void> extends Fn<{
    0: number;
}> {
    slot: [Value];
    data: IsEven$1<this[0]>;
}

type IsInteger$1<Value extends unknown> = Value extends number ? Math.IsInteger<Value> : 0;
interface TIsInteger<Value extends unknown | void = void> extends Fn<{
    0: unknown;
}> {
    slot: [Value];
    data: IsInteger$1<this[0]>;
}

type IsNegative$1<Value extends number> = Math.IsNegative<Value>;
interface TIsNegative<Value extends number | void = void> extends Fn<{
    0: number;
}> {
    slot: [Value];
    data: IsNegative$1<this[0]>;
}

type IsNonInteger$1<Value extends unknown> = Value extends number ? Math.IsNonInteger<Value> : 0;
interface TIsNonInteger<Value extends unknown | void = void> extends Fn<{
    0: unknown;
}> {
    slot: [Value];
    data: IsNonInteger$1<this[0]>;
}

type IsOdd$1<Value extends number> = Math.IsOdd<Value>;
interface TIsOdd<Value extends number | void = void> extends Fn<{
    0: number;
}> {
    slot: [Value];
    data: IsOdd$1<this[0]>;
}

type IsPositive$1<Value extends number> = Math.IsPositive<Value>;
interface TIsPositive<Value extends number | void = void> extends Fn<{
    0: number;
}> {
    slot: [Value];
    data: IsPositive$1<this[0]>;
}

type Clamp$1<Value extends number, LowerBound extends number, UpperBound extends number> = Math.Clamp<Value, LowerBound, UpperBound>;

type Max<Left extends number, Right extends number> = Math.Bigger<Left, Right>;

type Maximum$1<Numbers extends number[]> = Math.Maximum<Numbers>;

type Min<Left extends number, Right extends number> = Math.Smaller<Left, Right>;

type Minimum$1<Numbers extends number[]> = Math.Minimum<Numbers>;

type Absolute<Number extends number> = Number extends Number ? `${Number}` extends `-${infer Unsigned extends number}` ? Unsigned : Number : never;

type RowShift$1<TableRow extends Digit[], Addendum extends Digit = never> = TableRow extends [infer Head extends Digit, ...infer Rest extends Digit[]] ? [...Rest, [Addendum] extends [never] ? Head : Addendum] : never;

type TableShift<Table extends Digit[][], Addendum extends Digit = never> = Table extends [infer Head extends Digit[], ...infer Tail extends Digit[][]] ? [RowShift$1<Head, Addendum>, ...TableShift<Tail, Addendum>] : [];

type MakeBinaryTable<Table extends Digit[][], Addendum extends Digit = never> = [Table, TableShift<Table, Addendum>];

type LastRow$1<Table extends Digit[][]> = Table extends [
    ...Digit[][],
    infer LastRow
] ? LastRow : never;

type MakeTableHelper$1<Table extends Digit[][] = [], Addendum extends Digit = never, Row extends Digit[] = LastRow$1<Table>> = Size<Table> extends Size<Row> ? Table : MakeTableHelper$1<[...Table, RowShift$1<Row, Addendum>], Addendum>;
type MakeTable$1<Row extends Digit[] = [], Addendum extends Digit = never> = MakeTableHelper$1<[Row], Addendum>;

type FirstRow$4 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
type AddCarryDigitTable = MakeBinaryTable<MakeTable$1<FirstRow$4, 1>, 1>;

type AddCarryDigit<Left extends Digit, Right extends Digit, Carry extends Bit = 0> = AddCarryDigitTable[Carry][Left][Right];

type FirstRow$3 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
type AddDigitTable = MakeBinaryTable<MakeTable$1<FirstRow$3>>;

type AddDigit<Left extends Digit, Right extends Digit, Carry extends Bit = 0> = AddDigitTable[Carry][Left][Right];

type HeadDigitArray<Rest extends Digit[], Tail extends Digit = Digit> = [
    ...Rest,
    Tail
];

type AddDigitsHelper<NormalisedLeft extends Digit[], NormalisedRight extends Digit[], Carry extends Bit = 0, Result extends Digit[] = []> = NormalisedLeft extends HeadDigitArray<infer NormalisedLeftChunk, infer LastLeftDigit> ? NormalisedRight extends HeadDigitArray<infer NormalisedRightChunk, infer LastRightDigit> ? AddDigitsHelper<NormalisedLeftChunk, NormalisedRightChunk, AddCarryDigit<LastLeftDigit, LastRightDigit, Carry>, [
    AddDigit<LastLeftDigit, LastRightDigit, Carry>,
    ...Result
]> : AddDigitsHelper<NormalisedLeftChunk, [
], AddCarryDigit<LastLeftDigit, 0, Carry>, [
    AddDigit<LastLeftDigit, 0, Carry>,
    ...Result
]> : NormalisedRight extends HeadDigitArray<infer NormalisedRightChunk, infer LastRightDigit> ? AddDigitsHelper<[
], NormalisedRightChunk, AddCarryDigit<0, LastRightDigit, Carry>, [
    AddDigit<0, LastRightDigit, Carry>,
    ...Result
]> : Carry extends 1 ? [1, ...Result] : Result;
type AddDigits<NormalisedLeft extends Digit[], NormalisedRight extends Digit[]> = AddDigitsHelper<NormalisedLeft, NormalisedRight>;

type NormaliseFractionalZeros<X extends Digit[]> = TrimTail<X, 0>;

type NormaliseIntegerZeros<NormalisedIntegers extends Digit[]> = TrimHead<NormalisedIntegers, 0> extends infer Trimmed extends Digit[] ? Trimmed extends [] ? [0] : Trimmed : never;

type UnsignedFloat<IntegerDigits extends Digit[] = Digit[], FractionalDigits extends Digit[] = Digit[]> = [integers: IntegerDigits, fraction: FractionalDigits];

type MakeUnsignedFloat<Integers extends Digit[], Fraction extends Digit[] = []> = UnsignedFloat<NormaliseIntegerZeros<Integers>, NormaliseFractionalZeros<Fraction>>;

type DigitsToUnsignedFloat<Normalised extends Digit[], DecimalPlaces extends number, FractionalDigits extends Digit[] = []> = Size<FractionalDigits> extends DecimalPlaces ? MakeUnsignedFloat<Normalised, FractionalDigits> : Normalised extends HeadDigitArray<infer NormalisedChunk, infer LastDigit> ? DigitsToUnsignedFloat<NormalisedChunk, DecimalPlaces, Unshift<FractionalDigits, LastDigit>> : never;

type CompareLengths<Left extends unknown[], Right extends unknown[]> = Size<Left> extends Size<Right> ? 0 : Size<Left> extends 0 ? -1 : Size<Right> extends 0 ? 1 : CompareLengths<Head$1<Left>, Head$1<Right>>;

type NumberPair<Left extends Digit[], Right extends Digit[]> = [
    left: Left,
    right: Right
];

type PadDirection = "L" | "R";

type PadEnd<List extends Digit[], Length extends number = Size<List>, Value extends Digit = 0> = Size<List> extends Length ? List : PadEnd<[...List, Value], Length, Value>;

type PadStart<List extends Digit[], Length extends number = Size<List>, Value extends Digit = 0> = Size<List> extends Length ? List : PadStart<[Value, ...List], Length, Value>;

type Pad<List extends Digit[], Length extends number, Direction extends PadDirection = PadDirection, Value extends Digit = 0> = {
    L: PadStart<List, Length, Value>;
    R: PadEnd<List, Length, Value>;
}[Direction];

type NormaliseLengths<Left extends Digit[], Right extends Digit[], Direction extends PadDirection = PadDirection, Value extends Digit = 0> = CompareLengths<Left, Right> extends 0 | -1 ? NumberPair<Pad<Left, Size<Right>, Direction, Value>, Right> : NumberPair<Left, Pad<Right, Size<Left>, Direction, Value>>;

type NormaliseFractionalParts<Left extends Digit[], Right extends Digit[]> = NormaliseLengths<Left, Right, "R">;

type NormaliseIntegerParts<Left extends Digit[], Right extends Digit[]> = NormaliseLengths<Left, Right, "L">;

type Normalise<Left extends UnsignedFloat, Right extends UnsignedFloat> = NormaliseIntegerParts<Shift<Left>, Shift<Right>> extends NumberPair<infer LeftIntegerPart, infer RightIntegerPart> ? NormaliseFractionalParts<Pop<Left>, Pop<Right>> extends NumberPair<infer LeftFractionalPart, infer RightFractionalPart> ? [
    normalised_left: Concat<LeftIntegerPart, LeftFractionalPart>,
    normalised_right: Concat<RightIntegerPart, RightFractionalPart>,
    decimal_places: Size<RightFractionalPart>
] : never : never;

type AddUnsignedFloats<Left extends UnsignedFloat, Right extends UnsignedFloat> = Normalise<Left, Right> extends [
    ...NumberPair<infer NormalisedLeft, infer NormalisedRight>,
    infer DecimalPlaces extends number
] ? DigitsToUnsignedFloat<AddDigits<NormalisedLeft, NormalisedRight>, DecimalPlaces> : never;

type Sign = "+" | "-";

type SignMap<Negative = unknown, Positive = unknown> = {
    "-": Negative;
    "+": Positive;
};

type FlipSign<S extends Sign> = SignMap<"+", "-">[S];

type SignedFloat<TSign extends Sign = Sign, TNumber extends UnsignedFloat = UnsignedFloat> = [sign: TSign, float: TNumber];

type NegateSignedFloat<SignedDigits extends SignedFloat> = SignedDigits extends SignedFloat<infer Sign, infer UnsignedFloat> ? SignedFloat<FlipSign<Sign>, UnsignedFloat> : never;

type ComparisonResult = -1 | 0 | 1;

type FirstRow$2 = [1, 1, 1, 1, 1, 1, 1, 1, 1, 0];
type LastRow<Table extends ComparisonResult[][]> = Table extends [
    ...ComparisonResult[][],
    infer LastRow
] ? LastRow : never;
type FlipTable$1<T extends ComparisonResult[][]> = T extends [
    ...infer Head extends ComparisonResult[][],
    infer Tail extends ComparisonResult[]
] ? [Tail, ...FlipTable$1<Head>] : [];
type MakeTableHelper<Table extends ComparisonResult[][] = [], Addendum extends ComparisonResult = never, Row extends ComparisonResult[] = LastRow<Table>> = Size<Table> extends Size<Row> ? Table : MakeTableHelper<[...Table, RowShift<Row, Addendum>], Addendum>;
type RowShift<TableRow extends ComparisonResult[], Addendum extends ComparisonResult = never> = TableRow extends [
    infer Head extends ComparisonResult,
    ...infer Rest extends ComparisonResult[]
] ? [...Rest, [Addendum] extends [never] ? Head : Addendum] : never;
type MakeTable<Row extends ComparisonResult[] = FirstRow$2, Addendum extends ComparisonResult = -1> = MakeTableHelper<[Row], Addendum>;
type CompareDigitTable = FlipTable$1<MakeTable>;

type CompareDigits<Left extends Digit, Right extends Digit> = CompareDigitTable[Left][Right];

type TailDigitArray<Head extends Digit, Rest extends Digit[] = Digit[]> = [Head, ...Rest];

type CompareMagnitudes<NormalisedLeft extends Digit[], NormalisedRight extends Digit[]> = NormalisedLeft extends NormalisedRight ? 0 : [NormalisedLeft, NormalisedRight] extends [
    TailDigitArray<infer FirstLeftDigit, infer NormalisedLeftChunk>,
    TailDigitArray<infer FirstRightDigit, infer NormalisedRightChunk>
] ? CompareDigits<FirstLeftDigit, FirstRightDigit> extends 0 ? CompareMagnitudes<NormalisedLeftChunk, NormalisedRightChunk> : CompareDigits<FirstLeftDigit, FirstRightDigit> : never;

type CompareFloatMagnitudes<Left extends UnsignedFloat, Right extends UnsignedFloat> = Normalise<Left, Right> extends [
    ...NumberPair<infer NormalisedLeft, infer NormalisedRight>,
    number
] ? CompareMagnitudes<NormalisedLeft, NormalisedRight> : never;

type UnsignedFloatZero = MakeUnsignedFloat<[0]>;

type SignedFloatZero = SignedFloat<"+", UnsignedFloatZero>;

type FlipTable<T extends Digit[][]> = T extends [
    ...infer Head extends Digit[][],
    infer Tail extends Digit[]
] ? [Tail, ...FlipTable<Head>] : [];

type FirstRow$1 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
type SubtractCarryDigitTable = MakeBinaryTable<FlipTable<MakeTable$1<FirstRow$1, 1>>, 1>;

type SubtractCarryDigit<Left extends Digit, Right extends Digit, Carry extends Bit = 0> = SubtractCarryDigitTable[Carry][Left][Right];

type FirstRow = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0];
type SubtractDigitTable = MakeBinaryTable<FlipTable<MakeTable$1<FirstRow>>>;

type SubtractDigit<Left extends Digit, Right extends Digit, Carry extends Bit = 0> = SubtractDigitTable[Carry][Left][Right];

type SubtractDigits<NormalisedLeft extends Digit[], NormalisedRight extends Digit[], Carry extends Bit = 0, Result extends Digit[] = []> = NormalisedLeft extends HeadDigitArray<infer NormalisedLeftChunk, infer LastLeftDigit> ? NormalisedRight extends HeadDigitArray<infer NormalisedRightChunk, infer LastRightDigit> ? SubtractDigits<NormalisedLeftChunk, NormalisedRightChunk, SubtractCarryDigit<LastLeftDigit, LastRightDigit, Carry>, [
    SubtractDigit<LastLeftDigit, LastRightDigit, Carry>,
    ...Result
]> : SubtractDigits<NormalisedLeftChunk, [
], SubtractCarryDigit<LastLeftDigit, 0, Carry>, [
    SubtractDigit<LastLeftDigit, 0, Carry>,
    ...Result
]> : NormalisedRight extends HeadDigitArray<infer NormalisedRightChunk, infer LastRightDigit> ? SubtractDigits<[
], NormalisedRightChunk, SubtractCarryDigit<0, LastRightDigit, Carry>, [
    SubtractDigit<0, LastRightDigit, Carry>,
    ...Result
]> : Carry extends 1 ? [...Result, 9] : Result;

type SubtractUnsignedFloatsHelper<X extends UnsignedFloat, Y extends UnsignedFloat> = Normalise<X, Y> extends [
    ...NumberPair<infer TNormalisedX, infer TNormalisedY>,
    infer TDecimalPlaces extends number
] ? DigitsToUnsignedFloat<SubtractDigits<TNormalisedX, TNormalisedY>, TDecimalPlaces> : never;
type SubtractUnsignedFloats<X extends UnsignedFloat, Y extends UnsignedFloat> = CompareFloatMagnitudes<X, Y> extends 1 ? SignedFloat<"+", SubtractUnsignedFloatsHelper<X, Y>> : CompareFloatMagnitudes<X, Y> extends 0 ? SignedFloatZero : SignedFloat<"-", SubtractUnsignedFloatsHelper<Y, X>>;

type AddSignedFloats<LeftSignedDigits extends SignedFloat, RightSignedDigits extends SignedFloat> = LeftSignedDigits extends SignedFloat<infer LeftSign, infer LeftUnsignedFloat> ? RightSignedDigits extends SignedFloat<infer RightSign, infer RightUnsignedFloat> ? LeftSign extends "-" ? RightSign extends "-" ? SignedFloat<"-", AddUnsignedFloats<LeftUnsignedFloat, RightUnsignedFloat>> : NegateSignedFloat<SubtractUnsignedFloats<LeftUnsignedFloat, RightUnsignedFloat>> : RightSign extends "-" ? SubtractUnsignedFloats<LeftUnsignedFloat, RightUnsignedFloat> : SignedFloat<"+", AddUnsignedFloats<LeftUnsignedFloat, RightUnsignedFloat>> : never : never;

type EmptyStringAsZero<Input extends string> = Input extends "" ? "0" : Input;

/**
 * Tuple of digits representing the components of a number.
 */
type NumberComponents<TSign extends Sign, Integers extends string, Fraction extends string> = [
    sign: Integers | Fraction extends "" ? "+" : TSign,
    integers: Integers,
    fraction: Fraction
];

type SplitComponentParts<Input extends string | number> = Template<Input> extends `${infer Integer}.${infer Fraction}` ? NumberComponents<never, Integer, Fraction> : NumberComponents<never, Template<Input>, "">;

type ScientificNotationAsDecimal<Input extends string | number> = Template<Input> extends `${infer Significand extends number}e-${infer Exponent extends number}` ? SplitComponentParts<Significand> extends NumberComponents<never, infer Integer, infer Fraction> ? ArrayOf<Exponent, 0> extends [
    infer TIntZero extends 0,
    ...infer TFractionZeros extends 0[]
] ? Join$1<[TIntZero, ".", ...TFractionZeros, Integer, Fraction]> : never : never : Template<Input>;

type SeparateSign<Input extends string> = Input extends `${infer TSign extends Sign}${infer Number}` ? [sign: TSign, float: Number] : [sign: "+", float: Input];

type TrimLeadingZeros<Input extends string> = Input extends `0${infer Rest}` ? TrimLeadingZeros<Rest> : Input;

type TrimTrailingZeros<Input extends string> = Input extends `${infer Rest}0` ? TrimTrailingZeros<Rest> : Input;

type DecomposeNumber<Number extends string | number> = SeparateSign<`${Number}`> extends [
    infer TSign extends Sign,
    infer TValue extends string
] ? SplitComponentParts<ScientificNotationAsDecimal<TValue>> extends NumberComponents<never, infer Integer, infer Fraction> ? NumberComponents<TSign, EmptyStringAsZero<TrimLeadingZeros<Integer>>, TrimTrailingZeros<Fraction>> : never : never;

type SplitIntoDigits<Number extends string> = Number extends "" ? [] : Number extends `${infer Head extends Digit}${infer Rest}` ? [Head, ...SplitIntoDigits<Rest>] : never;

type ToSignedFloat<N extends number> = DecomposeNumber<N> extends NumberComponents<infer TSign, infer Integer, infer Float> ? SignedFloat<TSign, UnsignedFloat<SplitIntoDigits<Integer>, SplitIntoDigits<Float>>> : never;

type SplitAndNormalise<Left extends number, Right extends number> = Normalise<Pop<ToSignedFloat<Left>>, Pop<ToSignedFloat<Right>>>;

type CompareNumberMagnitudes<Left extends number, Right extends number> = SplitAndNormalise<Left, Right> extends [
    ...NumberPair<infer NormalisedLeft, infer NormalisedRight>,
    number
] ? CompareMagnitudes<NormalisedLeft, NormalisedRight> : never;

type IsPositive<Number extends number> = number extends Number ? Bit : Number extends Number ? Sign$1<Number> extends 1 ? 1 : 0 : never;

type CompareNumbers<Left extends number, Right extends number> = IsPositive<Left> extends 1 ? IsPositive<Right> extends 1 ? CompareNumberMagnitudes<Left, Right> : 1 : IsPositive<Right> extends 1 ? -1 : CompareNumberMagnitudes<Right, Left>;

type FloatDigitCount<UnsignedDigits extends UnsignedFloat> = Flat<UnsignedDigits> extends infer Digits extends Digit[] ? Size<Digits> : never;

type FloatMaxDigits = 15;

type ToUnsignedFloat<Number extends number> = DecomposeNumber<Number> extends [
    Sign,
    infer Integer extends string,
    infer Float extends string
] ? UnsignedFloat<SplitIntoDigits<Integer>, SplitIntoDigits<Float>> : never;

type FloatMaxDigitsAsUnsignedFloat = ToUnsignedFloat<FloatMaxDigits>;

type MakeSignedFloat<TSign extends Sign, UnsignedDigits extends UnsignedFloat> = MakeUnsignedFloat<Shift<UnsignedDigits>, Pop<UnsignedDigits>> extends infer ActualUnsignedFloat extends UnsignedFloat ? ActualUnsignedFloat extends UnsignedFloatZero ? SignedFloatZero : SignedFloat<TSign, ActualUnsignedFloat> : never;

type AddUnsignedIntegers<NormalisedLeft extends Digit[], NormalisedRight extends Digit[]> = NormaliseIntegerParts<NormalisedLeft, NormalisedRight> extends NumberPair<infer NormalisedLeftChunk, infer NormalisedRightChunk> ? AddDigits<NormalisedLeftChunk, NormalisedRightChunk> : never;

type RoundFractionalDigits<Floats extends Digit[], RoundingMap extends Digit[], TargetFractionLength extends number> = Floats extends HeadDigitArray<infer Rest, infer Head> ? Size<Rest> extends TargetFractionLength ? TargetFractionLength extends 0 ? [RoundingMap[Head]] : AddUnsignedIntegers<Rest, [RoundingMap[Head]]> : RoundFractionalDigits<Rest, RoundingMap, TargetFractionLength> : never;

type RoundingCarryMap = SignMap<[
    0,
    0,
    0,
    0,
    0,
    0,
    1,
    1,
    1,
    1
], [
    0,
    0,
    0,
    0,
    0,
    1,
    1,
    1,
    1,
    1
]>;

type SmallEnoughForScientificNotation<TFractionalDigits extends Digit[]> = TFractionalDigits extends [0, 0, 0, 0, 0, 0, ...Digit[]] ? 1 : 0;

type SignToNumber<TSign extends Sign> = TSign extends "+" ? "" : TSign;

type MakeSignedNumber<S extends string, TSign extends Sign> = S extends "0" ? 0 : Template<[SignToNumber<TSign>, S]> extends `${infer Number extends number}` ? Number : never;

type Join<List extends Serializable[], Delimiter extends string = ""> = List extends [
    infer Head extends Serializable,
    ...infer Rest extends Serializable[]
] ? Join<Rest, `${Delimiter}${Head}`> : Delimiter;

type ToDecimalString<IntegerDigits extends Digit[], FractionalDigits extends Digit[]> = FractionalDigits extends [] ? Join<IntegerDigits> : `${Join<IntegerDigits>}.${Join<FractionalDigits>}`;

type SplitLeadingElements<List extends Digit[], Element, Last extends Digit[] = []> = List extends [infer Head extends Digit, ...infer Rest extends Digit[]] ? [Head] extends [Element] ? SplitLeadingElements<Rest, Element, [...Last, Head]> : [Last, List] : [Last, []];

type ToSmallFractionString<FractionalDigits extends Digit[]> = SmallEnoughForScientificNotation<FractionalDigits> extends 1 ? SplitLeadingElements<FractionalDigits, 0> extends [
    infer FractionalZeros extends 0[],
    infer Significand extends Digit[]
] ? Significand extends TailDigitArray<infer SignificandInteger, infer SignificandFraction> ? Size<[0, ...FractionalZeros]> extends infer Exponent extends number ? `${SignedFloatToNumber<RoundFloat<SignedFloat<"+", [[SignificandInteger], SignificandFraction]>>>}e-${Exponent}` : never : never : never : ToDecimalString<[0], FractionalDigits>;

type UnsignedFloatToNumber<UnsignedNormalisedDigits extends UnsignedFloat, TSign extends Sign> = UnsignedNormalisedDigits extends UnsignedFloat<infer IntegerDigits, infer FractionalDigits> ? IntegerDigits extends [0] ? MakeSignedNumber<ToSmallFractionString<FractionalDigits>, TSign> : MakeSignedNumber<ToDecimalString<IntegerDigits, FractionalDigits>, TSign> : never;

type UnsignedNumbers<Unsigned extends Digit[]> = Unsigned;

type RoundFloat<SignedNormalisedDigits extends SignedFloat> = SmallEnoughForScientificNotation<SignedNormalisedDigits[1][1]> extends 1 ? SignedNormalisedDigits : SignedNormalisedDigits extends SignedFloat<infer TSign, infer UnsignedDigits> ? CompareNumbers<FloatDigitCount<UnsignedDigits>, FloatMaxDigits> extends -1 | 0 ? SignedNormalisedDigits : SubtractUnsignedFloats<FloatMaxDigitsAsUnsignedFloat, ToUnsignedFloat<Size<Shift<UnsignedDigits>>>> extends SignedFloat<infer TargetFractionLengthSign, infer TargetFractionLength> ? TargetFractionLengthSign extends "-" ? SignedNormalisedDigits : RoundFractionalDigits<Pop<UnsignedDigits>, RoundingCarryMap[TSign], UnsignedFloatToNumber<TargetFractionLength, "+">> extends UnsignedNumbers<infer RoundedFraction> ? MakeSignedFloat<TSign, UnsignedFloat<Shift<UnsignedDigits>, RoundedFraction>> : never : never : never;

type SignedFloatToNumber<SignedDigits extends SignedFloat> = RoundFloat<SignedDigits> extends SignedFloat<infer TSign, infer UnsignedDigits> ? UnsignedFloatToNumber<UnsignedDigits, TSign> : never;

type AddNumbers<Left extends number, Right extends number> = SignedFloatToNumber<AddSignedFloats<ToSignedFloat<Left>, ToSignedFloat<Right>>>;

type Add<Left extends number, Right extends number> = AnyExtend<[
    Left,
    Right
], never> extends 1 ? never : Left extends 0 ? Right : Right extends 0 ? Left : number extends Left | Right ? number : AddNumbers<Left, Right>;

type OperationResult<Carry extends Digit = Digit, Result extends Digit = Digit> = [carry: Carry, result: Result];

type AddDigitsOperation<Left extends Digit, Right extends Digit> = OperationResult<AddCarryDigit<Left, Right>, AddDigit<Left, Right>>;

type AddThrough<List extends unknown[], Adder extends number> = {
    [Index in keyof List]: List[Index] extends number ? Add<List[Index], Adder> : never;
};

type Addition<Numbers extends number[]> = Numbers extends [
    infer Head extends number,
    ...infer Rest extends number[]
] ? Add<Head, Addition<Rest>> : 0;

type Compare$1<Left extends number, Right extends number> = AnyExtend<[
    Left,
    Right
], never> extends 1 ? never : number extends Left | Right ? ComparisonResult : Left extends Left ? Right extends Right ? CompareNumbers<Left, Right> : never : never;

type GreaterThan$1<Left extends number, Right extends number> = Compare$1<Left, Right> extends -1 ? 0 : Compare$1<Left, Right> extends 0 ? 0 : 1;

type Bigger<Left extends number, Right extends number> = number extends Left | Right ? number : Left extends Right ? Left : Right extends Left ? Right : GreaterThan$1<Left, Right> extends 1 ? Left : Right;

type Branch$1<Comparison extends ComparisonResult, Positive extends unknown = never, Zero extends unknown = never, Negative extends unknown = never> = Comparison extends 1 ? Positive : Comparison extends 0 ? Zero : Negative;

type Clamp<Value extends number, LowerBound extends number, UpperBound extends number> = Branch$1<Compare$1<LowerBound, Value>, LowerBound, Branch$1<Compare$1<Value, UpperBound>, UpperBound, Value>>;

type CompareIntegerMagnitudes<NormalisedLeft extends Digit[], NormalisedRight extends Digit[]> = NormaliseIntegerParts<NormalisedLeft, NormalisedRight> extends NumberPair<infer NormalisedLeftChunk, infer NormalisedRightChunk> ? CompareMagnitudes<NormalisedLeftChunk, NormalisedRightChunk> : never;

type MultiplyCarryDigitTable = [
    [
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0
    ],
    [
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0
    ],
    [
        0,
        0,
        0,
        0,
        0,
        1,
        1,
        1,
        1,
        1
    ],
    [
        0,
        0,
        0,
        0,
        1,
        1,
        1,
        2,
        2,
        2
    ],
    [
        0,
        0,
        0,
        1,
        1,
        2,
        2,
        2,
        3,
        3
    ],
    [
        0,
        0,
        1,
        1,
        2,
        2,
        3,
        3,
        4,
        4
    ],
    [
        0,
        0,
        1,
        1,
        2,
        3,
        3,
        4,
        4,
        5
    ],
    [
        0,
        0,
        1,
        2,
        2,
        3,
        4,
        4,
        5,
        6
    ],
    [
        0,
        0,
        1,
        2,
        3,
        4,
        4,
        5,
        6,
        7
    ],
    [
        0,
        0,
        1,
        2,
        3,
        4,
        5,
        6,
        7,
        8
    ]
];

type MultiplyCarryDigit<Left extends Digit, Right extends Digit> = MultiplyCarryDigitTable[Left][Right];

type MultiplyDigitTable = [
    [
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0
    ],
    [
        0,
        1,
        2,
        3,
        4,
        5,
        6,
        7,
        8,
        9
    ],
    [
        0,
        2,
        4,
        6,
        8,
        0,
        2,
        4,
        6,
        8
    ],
    [
        0,
        3,
        6,
        9,
        2,
        5,
        8,
        1,
        4,
        7
    ],
    [
        0,
        4,
        8,
        2,
        6,
        0,
        4,
        8,
        2,
        6
    ],
    [
        0,
        5,
        0,
        5,
        0,
        5,
        0,
        5,
        0,
        5
    ],
    [
        0,
        6,
        2,
        8,
        4,
        0,
        6,
        2,
        8,
        4
    ],
    [
        0,
        7,
        4,
        1,
        8,
        5,
        2,
        9,
        6,
        3
    ],
    [
        0,
        8,
        6,
        4,
        2,
        0,
        8,
        6,
        4,
        2
    ],
    [
        0,
        9,
        8,
        7,
        6,
        5,
        4,
        3,
        2,
        1
    ]
];

type MultiplyDigit<Left extends Digit, Right extends Digit> = MultiplyDigitTable[Left][Right];

type MultiplyDigitsOperation<Left extends Digit, Right extends Digit> = OperationResult<MultiplyCarryDigit<Left, Right>, MultiplyDigit<Left, Right>>;

type MultiplyRow<TableRow extends Digit[], Multiplier extends Digit, CarryIn extends Digit = 0, FinalResult extends Digit[] = []> = TableRow extends HeadDigitArray<infer RowHead, infer LastDigit> ? MultiplyDigitsOperation<LastDigit, Multiplier> extends OperationResult<infer ResultingCarryOut, infer MultiplicationResult> ? AddDigitsOperation<MultiplicationResult, CarryIn> extends OperationResult<infer MultiplierCarryOut, infer TResult> ? AddDigitsOperation<ResultingCarryOut, MultiplierCarryOut> extends OperationResult<0, infer FinalCarryOut> ? MultiplyRow<RowHead, Multiplier, FinalCarryOut, [
    TResult,
    ...FinalResult
]> : never : never : never : CarryIn extends 0 ? FinalResult : [CarryIn, ...FinalResult];

type CrossMultiply<Left extends Digit[], Right extends Digit[], Shift extends 0[] = [], PreviousRowResult extends Digit[] = []> = Right extends HeadDigitArray<infer RightHead, infer RightLastDigit> ? CrossMultiply<Left, RightHead, [
    ...Shift,
    0
], NormaliseIntegerZeros<AddUnsignedIntegers<PreviousRowResult, [
    ...MultiplyRow<Left, RightLastDigit>,
    ...Shift
]>>> : NormaliseIntegerZeros<PreviousRowResult>;

type ModResult<Remainder extends Digit[], Quotient extends Digit[]> = [
    remainder: Remainder,
    quotient: Quotient
];

type MakeModResult<Remainder extends Digit[], Quotient extends Digit[]> = ModResult<NormaliseIntegerZeros<Remainder>, NormaliseIntegerZeros<Quotient>>;

type SubtractUnsignedIntegers<NormalisedLeft extends Digit[], NormalisedRight extends Digit[]> = NormaliseIntegerParts<NormalisedLeft, NormalisedRight> extends NumberPair<infer NormalisedLeftChunk, infer NormalisedRightChunk> ? SubtractDigits<NormalisedLeftChunk, NormalisedRightChunk> : never;

type EuclideanDivideHelper<Divisor extends Digit[], Remainder extends Digit[], Quotient extends Digit[]> = CompareIntegerMagnitudes<Remainder, Divisor> extends Bit ? EuclideanDivideHelper<Divisor, SubtractUnsignedIntegers<Remainder, Divisor>, AddUnsignedIntegers<Quotient, [1]>> : MakeModResult<Remainder, Quotient>;
type EuclideanDivide<TNumerator extends Digit[], Divisor extends Digit[]> = EuclideanDivideHelper<Divisor, TNumerator, [0]>;

type EuclideanDivideResult<Remainder extends Digit[], Quotient extends Digit> = ModResult<Remainder, [Quotient]>;

type DivideMaxDigits = 13;

type LongDivideFraction<Divisor extends Digit[], Numerator extends Digit[], Quotient extends Digit[] = []> = CompareNumbers<Size<Quotient>, DivideMaxDigits> extends 1 ? Quotient : EuclideanDivide<Numerator, Divisor> extends EuclideanDivideResult<infer Remainder, infer NextQuotientDigit> ? Remainder extends [0] ? Push<Quotient, NextQuotientDigit> : LongDivideFraction<Divisor, Push<Remainder, 0>, Push<Quotient, NextQuotientDigit>> : never;

type LongDivide<Divisor extends Digit[], NumeratorHead extends Digit[], NumeratorTail extends Digit[], Quotient extends Digit[] = [], WithRemainder extends boolean = false> = EuclideanDivide<NumeratorHead, Divisor> extends EuclideanDivideResult<infer Remainder, infer NextQuotientDigit> ? [...Quotient, NextQuotientDigit] extends infer NextQuotient extends Digit[] ? NumeratorTail extends TailDigitArray<infer NextDigit, infer NextTail> ? LongDivide<Divisor, [
    ...Remainder,
    NextDigit
], NextTail, NextQuotient, WithRemainder> : WithRemainder extends false ? MakeUnsignedFloat<NextQuotient, Remainder extends [0] ? [] : LongDivideFraction<Divisor, [...Remainder, 0]>> : MakeModResult<Remainder, NextQuotient> : never : never;

type DivideUnsignedFloats<Numerator extends UnsignedFloat, Divisor extends UnsignedFloat, WithRemainder extends boolean = false> = Normalise<Numerator, Divisor> extends [
    ...NumberPair<infer NumeratorDigits, infer DivisorDigits>,
    infer DecimalPlaces
] ? NumeratorDigits extends TailDigitArray<infer NumeratorHead, infer NumeratorTail> ? [
    LongDivide<DivisorDigits, [
        NumeratorHead
    ], NumeratorTail, [
    ], WithRemainder>,
    DecimalPlaces
] : never : never;

type MultiplySignsHelper = SignMap<SignMap<"+", "-">, SignMap<"-", "+">>;
type MultiplySigns<Left extends Sign, Right extends Sign> = MultiplySignsHelper[Left][Right];

type DivideSignedFloats<Numerator extends SignedFloat, Divisor extends SignedFloat> = Numerator extends SignedFloat<infer NumeratorSign, infer NumeratorUnsignedFloat> ? Divisor extends SignedFloat<infer DivisorSign, infer DivisorUnsignedFloat> ? SignedFloat<MultiplySigns<NumeratorSign, DivisorSign>, Shift<DivideUnsignedFloats<NumeratorUnsignedFloat, DivisorUnsignedFloat>>> : never : never;

type DivideNumbers<Numerator extends number, Divisor extends number> = SignedFloatToNumber<DivideSignedFloats<ToSignedFloat<Numerator>, ToSignedFloat<Divisor>>>;

type Negate<Number extends number> = Number extends 0 ? 0 : number extends Number ? number : `${Number}` extends `-${infer Number extends number}` ? Number : `-${Number}` extends `${infer Number extends number}` ? Number : never;

type Divide<Numerator extends number, Divisor extends number> = AnyExtend<[Numerator, Divisor], never> extends 1 ? never : Divisor extends 0 ? never : Numerator extends 0 ? 0 : Divisor extends 1 ? Numerator : number extends Numerator | Divisor ? number : Divisor extends -1 ? Negate<Numerator> : DivideNumbers<Numerator, Divisor>;

type LessThan$1<Left extends number, Right extends number> = GreaterThan$1<Right, Left>;

type Smaller<Left extends number, Right extends number> = number extends Left | Right ? number : Left extends Right ? Left : Right extends Left ? Right : LessThan$1<Left, Right> extends 1 ? Left : Right;

type Minimum<Numbers extends number[]> = Numbers extends [
    ...infer Rest extends number[],
    infer Tail extends number
] ? Rest extends [] ? Tail : Smaller<Minimum<Rest>, Tail> : 0;

type NormaliseForCrossMultiply<Left extends UnsignedFloat, Right extends UnsignedFloat> = Left extends UnsignedFloat<infer LeftIntegerPart, infer LeftFractionalPart> ? Right extends UnsignedFloat<infer RightIntegerPart, infer RightFractionalPart> ? [
    xDigits: NormaliseIntegerZeros<Concat<LeftIntegerPart, LeftFractionalPart>>,
    yDigits: NormaliseIntegerZeros<Concat<RightIntegerPart, RightFractionalPart>>,
    decimalPlaces: AddNumbers<Size<LeftFractionalPart>, Size<RightFractionalPart>>
] : never : never;

type SafeDigitsToUnsignedFloat<Digits extends Digit[], DecimalPlaces extends number> = CompareNumbers<Size<Digits>, DecimalPlaces> extends -1 ? DigitsToUnsignedFloat<PadStart<Digits, DecimalPlaces>, DecimalPlaces> : DigitsToUnsignedFloat<Digits, DecimalPlaces>;

type MultiplyUnsignedFloats<Left extends UnsignedFloat, Right extends UnsignedFloat> = NormaliseForCrossMultiply<Left, Right> extends [
    ...NumberPair<infer NormalisedLeft, infer NormalisedRight>,
    infer DecimalPlaces extends number
] ? SafeDigitsToUnsignedFloat<CrossMultiply<NormalisedLeft, NormalisedRight>, DecimalPlaces> : never;

type MultiplySignedFloats<Left extends SignedFloat, Right extends SignedFloat> = Left extends SignedFloat<infer LeftSign, infer LeftUnsignedFloat> ? Right extends SignedFloat<infer RightSign, infer RightUnsignedFloat> ? SignedFloat<MultiplySigns<LeftSign, RightSign>, MultiplyUnsignedFloats<LeftUnsignedFloat, RightUnsignedFloat>> : never : never;

type MultiplyNumbers<Left extends number, Right extends number> = SignedFloatToNumber<MultiplySignedFloats<ToSignedFloat<Left>, ToSignedFloat<Right>>>;

type Multiply<Left extends number, Right extends number> = AnyExtend<[
    Left,
    Right
], never> extends 1 ? never : Left extends 0 ? 0 : Right extends 0 ? 0 : Left extends 1 ? Right : Right extends 1 ? Left : number extends Left | Right ? number : Left extends -1 ? Negate<Right> : Right extends -1 ? Negate<Left> : MultiplyNumbers<Left, Right>;

type IsEvenDigit<DigitArray extends Digit[]> = DigitArray extends HeadDigitArray<any, infer LastDigit> ? LastDigit extends 0 | 2 | 4 | 6 | 8 ? 1 : 0 : never;

type IsUnsignedFloatEven<Float extends UnsignedFloat> = Pop<Float> extends [] ? IsEvenDigit<Shift<Float>> : never;

type IsEven<Number extends number> = number extends Number ? Bit : Number extends Number ? IsUnsignedFloatEven<ToUnsignedFloat<Number>> : never;

type IsNegative<Number extends number> = number extends Number ? Bit : Number extends Number ? Sign$1<Number> extends -1 ? 1 : 0 : never;

type SubtractSignedFloats<Left extends SignedFloat, Right extends SignedFloat> = Left extends SignedFloat<infer LeftSign, infer LeftUnsignedFloat> ? Right extends SignedFloat<infer RightSign, infer RightUnsignedFloat> ? LeftSign extends "-" ? RightSign extends "-" ? NegateSignedFloat<SubtractUnsignedFloats<LeftUnsignedFloat, RightUnsignedFloat>> : SignedFloat<"-", AddUnsignedFloats<LeftUnsignedFloat, RightUnsignedFloat>> : RightSign extends "-" ? SignedFloat<"+", AddUnsignedFloats<LeftUnsignedFloat, RightUnsignedFloat>> : SubtractUnsignedFloats<LeftUnsignedFloat, RightUnsignedFloat> : never : never;

type SubtractNumbers<Left extends number, Right extends number> = SignedFloatToNumber<SubtractSignedFloats<ToSignedFloat<Left>, ToSignedFloat<Right>>>;

type Subtract<Left extends number, Right extends number> = AnyExtend<[
    Left,
    Right
], never> extends 1 ? never : number extends Left | Right ? number : Left extends 0 ? Negate$1<Right> : Right extends 0 ? Left : SubtractNumbers<Left, Right>;

type NegativeExponentHelper<Base extends number, Exponent extends number, NegativeExponent extends number = Negate<Exponent>> = Exponentiate<Base, NegativeExponent> extends InferNumber<infer Result> ? Divide<1, Result> : never;
type ExponentiateHelper<Base extends number, Exponent extends number, Positive extends number = Multiply<Base, Base>, Even extends number = Divide<Exponent, 2>, Odd extends number = Divide<Subtract<Exponent, 1>, 2>> = Exponent extends 0 ? 1 : IsNegative<Exponent> extends 1 ? NegativeExponentHelper<Base, Exponent> : IsEven<Exponent> extends 1 ? Exponentiate<Positive, Even> : Exponentiate<Positive, Odd> extends InferNumber<infer Result> ? Multiply<Base, Result> : never;
type Exponentiate<Base extends number, Exponent extends number> = ExponentiateHelper<Base, Exponent>;

type DecimalComponents<Left extends number, Right extends number> = [
    left: Left,
    right: Right
];

type HighestCommonFactor<A extends number, B extends number> = A extends B ? A : A extends 0 ? B : B extends 0 ? A : GreaterThan$1<A, B> extends 1 ? HighestCommonFactor<Subtract<A, B>, B> : HighestCommonFactor<A, Subtract<B, A>>;

type SimplifyHelper<Decimal extends number> = `${Decimal}` extends `${infer IntegerPart}.${infer FractionalPart}` ? [
    ParseInt<`${IntegerPart}${FractionalPart}`>,
    Power<10, Length<FractionalPart>>
] : never;
type Simplify<Decimal extends number> = SimplifyHelper<Decimal> extends DecimalComponents<infer Numerator, infer Denominator> ? HighestCommonFactor<Numerator, Denominator> extends InferNumber<infer HCF> ? [Divide<Numerator, HCF>, Divide<Denominator, HCF>] : never : never;

type FractionalExponent<Base extends number, Exponent extends number> = Simplify<Exponent> extends DecimalComponents<infer Numerator, infer Denominator> ? Root<Exponentiate<Base, Numerator>, Denominator> : never;

type IsInteger<N extends number> = number extends N ? Bit : N extends N ? Template<N> extends `${string}.${string}` ? 0 : 1 : never;

type Not$1<Number extends number> = Number extends 0 ? 1 : 0;

type IsNonInteger<Number extends number> = Not$1<IsInteger<Number>>;

type Power<Base extends number, Exponent extends number> = AnyExtend<[
    Base,
    Exponent
], never> extends 1 ? never : Exponent extends 0 ? 1 : Exponent extends 1 ? Base : Base extends 1 ? 1 : Base extends 0 ? 0 : number extends Exponent ? -1 | 1 : number extends Base | Exponent ? number : IsNonInteger<Exponent> extends 1 ? FractionalExponent<Base, Exponent> extends InferNumber<infer Result> ? Result : never : Exponentiate<Base, Exponent>;

type BestGuess<Number extends number, Raise extends number> = Minimum<[
    Exponentiate<Length<Number>, 2>,
    Multiply<Number, Raise>
]>;
type RootEstimate<Number extends number, Raise extends number, Guess extends number> = Divide<Add<Multiply<Guess, Subtract<Raise, 1>>, Divide<Number, Power<Guess, Subtract<Raise, 1>>>>, Raise>;
type RootDifference<Estimate extends number, Guess extends number> = Absolute<Subtract<Estimate, Guess>>;
type MaxRootIteration = 25;
type RootHelper<Number extends number, Raise extends number, Iteration extends number = 0, Guess extends number = BestGuess<Number, Raise>, Quotient extends number = RootEstimate<Number, Raise, Guess>, Delta extends number = RootDifference<Quotient, Guess>> = ToUnsignedFloat<Guess> extends UnsignedFloat<infer LeftIntegerPart, infer RightFractionalPart> ? SmallEnoughForScientificNotation<RightFractionalPart> extends 1 ? RootHelper<Number, Raise, 0, MakeSignedNumber<Join<LeftIntegerPart>, "+">> : And<GreaterThan$1<Delta, 0>, LessThan$1<Iteration, MaxRootIteration>> extends 1 ? RootHelper<Number, Raise, Add<Iteration, 1>, Quotient> : Quotient : never;
type Root<Number extends number, Raise extends number> = RootHelper<Number, Raise>;

type CubeRoot<Number extends number> = Root<Number, 3>;

type Division<Numbers extends number[]> = Numbers extends [
    ...infer Rest extends number[],
    infer Tail extends number
] ? Rest extends [] ? Tail : Divide<Division<Rest>, Tail> : 1;

type Equal$1<Left extends number, Right extends number> = AnyExtend<[
    Left,
    Right
], never> extends 1 ? never : number extends Left | Right ? Bit : Left extends Right ? Right extends Left ? 1 : 0 : 0;

type ModUnsignedFloats<Numerator extends UnsignedFloat, Divisor extends UnsignedFloat> = DivideUnsignedFloats<Numerator, Divisor, true> extends [
    ModResult<infer Remainder, Digit[]>,
    infer DecimalPlaces extends number
] ? SafeDigitsToUnsignedFloat<Remainder, DecimalPlaces> : never;

type ModSignedFloats<Numerator extends SignedFloat, Divisor extends SignedFloat> = Numerator extends SignedFloat<infer NumeratorSign, infer NumeratorUnsignedFloat> ? Divisor extends SignedFloat<Sign, infer DivisorUnsignedFloat> ? SignedFloat<NumeratorSign, ModUnsignedFloats<NumeratorUnsignedFloat, DivisorUnsignedFloat>> : never : never;

type ModNumbers<Numerator extends number, Divisor extends number> = SignedFloatToNumber<ModSignedFloats<ToSignedFloat<Numerator>, ToSignedFloat<Divisor>>>;

type Mod<Numerator extends number, Divisor extends number> = AnyExtend<[
    Numerator,
    Divisor
], never> extends 1 ? never : Divisor extends 0 ? never : Numerator extends 0 ? 0 : number extends Numerator | Divisor ? number : ModNumbers<Numerator, Divisor>;

type Subtraction<Numbers extends number[]> = Numbers extends [
    ...infer Rest extends number[],
    infer Tail extends number
] ? Rest extends [] ? Tail : Subtract<Subtraction<Rest>, Tail> : 1;

type Floor<Value extends number> = Value extends 0 ? 0 : Value extends number ? LessThan$1<Value, 0> extends 1 ? Subtraction<[Value, Mod<Value, -1>, 1]> : Mod<Value, 1> extends 0 ? Value : Subtract<Value, Mod<Value, 1>> : never;

type GreaterThanOrEqual$1<Left extends number, Right extends number> = Compare$1<Left, Right> extends -1 ? 0 : 1;

type IsOdd<Number extends number> = Not$1<IsEven<Number>>;

type LeastCommonMultiple<A extends number, B extends number> = Divide<Multiply<A, B>, HighestCommonFactor<A, B>>;

type LessThanOrEqual$1<Left extends number, Right extends number> = GreaterThanOrEqual$1<Right, Left>;

type MakeMultiplicationRow<Number extends Digit, TableRow extends number[] = [0]> = TableRow["length"] extends 10 ? TableRow : LastOfUnion<TableRow> extends infer Previous extends number ? MakeMultiplicationRow<Number, [...TableRow, Add<Previous, Number>]> : never;

type OperationResultFromNumber<Number extends number> = `${Number}` extends `${infer Carry extends Digit}${infer Result extends Digit}` ? OperationResult<Carry, Result> : `${Number}` extends `${infer Result extends Digit}` ? OperationResult<0, Result> : never;

type MapToOperationResult<TRow extends number[]> = {
    [K in keyof TRow]: OperationResultFromNumber<TRow[K]>;
};

type MakeMultiplicationTable<Table extends unknown[], X extends Digit[]> = Table["length"] extends 10 ? Table : X extends TailDigitArray<infer N, infer XTail> ? MakeMultiplicationTable<[
    ...Table,
    MapToOperationResult<MakeMultiplicationRow<N>>
], XTail> : never;

type Maximum<Numbers extends number[]> = Numbers extends [
    infer Head extends number,
    ...infer Rest extends number[]
] ? Bigger<Head, Maximum<Rest>> : 0;

type Multiplication<Numbers extends number[]> = Numbers extends [
    infer Head extends number,
    ...infer Rest extends number[]
] ? Multiply<Head, Multiplication<Rest>> : 1;

type MultiplyThrough<List extends unknown[], Multiplier extends number> = {
    [Index in keyof List]: List[Index] extends number ? Multiply<List[Index], Multiplier> : never;
};

type PI = 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148;

type Signum<Number extends number> = Number extends Number ? `${Number}` extends `-${number}` ? -1 : Number extends 0 ? 0 : 1 : never;

type Round<Value extends number, MidPointRounding extends "AwayFromZero" | "ToEven" = "ToEven"> = MidPointRounding extends "AwayFromZero" ? Multiply<Signum<Value>, Floor<Add<Absolute<Value>, 0.5>>> : Floor<Subtract<Add<Value, 0.5>, Mod<Floor<Add<Value, 0.5>>, 1>>>;

type SquareRoot<Number extends number> = Root<Number, 2>;

type MultiplyByTenPower<Value extends number, Power extends number> = Power extends 0 ? Value : MultiplyByTenPower<Multiply<Value, 10>, Subtract<Power, 1>>;
type DivideByTenPower<Value extends number, Power extends number> = Power extends 0 ? Value : DivideByTenPower<Divide<Value, 10>, Subtract<Power, 1>>;
type ToFixed<Value extends number, Digits extends number> = MultiplyByTenPower<Value, Digits> extends infer Multiplied ? Multiplied extends number ? DivideByTenPower<Round<Multiplied>, Digits> : never : never;

declare namespace Math {
    export type { Absolute, Add, AddCarryDigit, AddCarryDigitTable, AddDigit, AddDigitTable, AddDigits, AddDigitsOperation, AddNumbers, AddSignedFloats, AddThrough, AddUnsignedFloats, AddUnsignedIntegers, Addition, Bigger, Branch$1 as Branch, Clamp, Compare$1 as Compare, CompareDigitTable, CompareDigits, CompareFloatMagnitudes, CompareIntegerMagnitudes, CompareLengths, CompareMagnitudes, CompareNumberMagnitudes, CompareNumbers, ComparisonResult, CrossMultiply, CubeRoot, DecimalComponents, DecomposeNumber, DigitsToUnsignedFloat, Divide, DivideMaxDigits, DivideNumbers, DivideSignedFloats, DivideUnsignedFloats, Division, EmptyStringAsZero, Equal$1 as Equal, EuclideanDivide, EuclideanDivideResult, Exponentiate, FlipSign, FlipTable, FloatDigitCount, FloatMaxDigits, FloatMaxDigitsAsUnsignedFloat, Floor, FractionalExponent, GreaterThan$1 as GreaterThan, GreaterThanOrEqual$1 as GreaterThanOrEqual, HeadDigitArray, HighestCommonFactor, IsEven, IsEvenDigit, IsInteger, IsNegative, IsNonInteger, IsOdd, IsPositive, IsUnsignedFloatEven, Join, LastRow$1 as LastRow, LeastCommonMultiple, LessThan$1 as LessThan, LessThanOrEqual$1 as LessThanOrEqual, LongDivide, LongDivideFraction, MakeBinaryTable, MakeModResult, MakeMultiplicationRow, MakeMultiplicationTable, MakeSignedFloat, MakeSignedNumber, MakeTable$1 as MakeTable, MakeUnsignedFloat, MapToOperationResult, Maximum, Minimum, Mod, ModNumbers, ModResult, ModSignedFloats, ModUnsignedFloats, Multiplication, Multiply, MultiplyCarryDigit, MultiplyCarryDigitTable, MultiplyDigit, MultiplyDigitTable, MultiplyDigitsOperation, MultiplyNumbers, MultiplyRow, MultiplySignedFloats, MultiplySigns, MultiplyThrough, MultiplyUnsignedFloats, Negate, NegateSignedFloat, Normalise, NormaliseForCrossMultiply, NormaliseFractionalParts, NormaliseFractionalZeros, NormaliseIntegerParts, NormaliseIntegerZeros, NormaliseLengths, Not$1 as Not, NumberComponents, NumberPair, Pad, PadDirection, PadEnd, PadStart, PI, Power, Round, RoundFloat, RoundFractionalDigits, RoundingCarryMap, RowShift$1 as RowShift, SafeDigitsToUnsignedFloat, ScientificNotationAsDecimal, SeparateSign, Sign, SignMap, SignToNumber, SignedFloat, SignedFloatToNumber, SignedFloatZero, Signum, Simplify, SmallEnoughForScientificNotation, Smaller, SplitAndNormalise, SplitComponentParts, SplitIntoDigits, SplitLeadingElements, SquareRoot, Subtract, SubtractCarryDigit, SubtractCarryDigitTable, SubtractDigit, SubtractDigitTable, SubtractDigits, SubtractNumbers, SubtractSignedFloats, SubtractUnsignedFloats, SubtractUnsignedIntegers, Subtraction, TableShift, TailDigitArray, ToDecimalString, ToFixed, ToSignedFloat, ToSmallFractionString, ToUnsignedFloat, TrimLeadingZeros, TrimTrailingZeros, UnsignedFloat, UnsignedFloatToNumber, UnsignedFloatZero, UnsignedNumbers, };
}

type AndHelper = Bit.FourBitSquareMatrix<[0, 0, 0, 1]>;
/**
 * A type representing the result of a bitwise AND operation.
 *
 * @param Left - The first bit to AND.
 * @param Right - The second bit to AND.
 *
 * @returns The result of the AND operation.
 *
 * @example
 * ```ts
 * import type { And } from "@ibnlanre/types";
 *
 * type Test = And<0, 1>;
 * //   ^? 0
 * ```
 */
type And<Left extends Bit, Right extends Bit> = AndHelper[Left][Right];
/**
 * Performs a bitwise AND operation on two numbers.
 *
 * @param Left - The first number to AND.
 * @param Right - The second number to AND.
 *
 * @returns The result of the AND operation.
 *
 * @example
 * ```ts
 * import type { Apply, TAnd } from "@ibnlanre/types";
 *
 * type Test = Apply<TAnd, [0, 1]>;
 * //   ^? 0
 * ```
 */
interface TAnd<Left extends Bit | void = void, Right extends Bit | void = void> extends Fn<{
    0: Bit;
    1: Bit;
}> {
    slot: [Left, Right];
    data: And<this[0], this[1]>;
}

type Nand<Left extends Bit, Right extends Bit> = Not<And<Left, Right>>;
interface TNand<Right extends Bit | void = void, Left extends Bit | void = void> extends Fn<{
    0: Bit;
}> {
    slot: [Right, Left];
    data: Nand<this[1], this[0]>;
}

/**
 * A type representing the result of a logical NOT operation.
 *
 * @param Proposition - The proposition to NOT.
 * @returns The result of the NOT operation.
 *
 * @example
 * ```ts
 * import type { Not } from "@ibnlanre/types";
 *
 * type Test = Not<0>;
 * //   ^? 1
 * ```
 */
type Not<Proposition extends Bit> = Proposition extends 0 ? 1 : 0;
/**
 * Performs a logical NOT operation on a proposition.
 *
 * @param Proposition - The proposition to NOT.
 * @returns The result of the NOT operation.
 *
 * @example
 * ```ts
 * import type { Apply, TNot } from "@ibnlanre/types";
 *
 * type Test = Apply<TNot, [0]>;
 * //   ^? 1
 * ```
 */
interface TNot<Proposition extends Bit | void = void> extends Fn<{
    0: Bit;
}> {
    slot: [Proposition];
    data: Not<this[0]>;
}

type OrHelper = Bit.FourBitSquareMatrix<[0, 1, 1, 1]>;
/**
 * A type representing the result of a bitwise OR operation.
 *
 * @param Left - The first bit to OR.
 * @param Right - The second bit to OR.
 *
 * @returns The result of the OR operation.
 *
 * @example
 * ```ts
 * import type { Or } from "@ibnlanre/types";
 *
 * type Test = Or<0, 1>;
 * //   ^? 1
 * ```
 */
type Or<Left extends Bit, Right extends Bit> = OrHelper[Left][Right];
/**
 * Performs a bitwise OR operation on two numbers.
 *
 * @param Left - The first number to OR.
 * @param Right - The second number to OR.
 *
 * @returns The result of the OR operation.
 *
 * @example
 * ```ts
 * import type { Apply, TOr } from "@ibnlanre/types";
 *
 * type Test = Apply<TOr, [0, 1]>;
 * //   ^? 1
 * ```
 */
interface TOr<Right extends Bit | void = void, Left extends Bit | void = void> extends Fn<{
    Right: Bit;
    Left: Bit;
}> {
    slot: [Right, Left];
    data: Or<this[1], this[0]>;
}

type XorHelper = Bit.FourBitSquareMatrix<[0, 1, 1, 0]>;
/**
 * A type representing the result of a bitwise XOR operation.
 *
 * @param Left - The first bit to XOR.
 * @param Right - The second bit to XOR.
 *
 * @returns The result of the XOR operation.
 *
 * @example
 * ```ts
 * import type { Xor } from "@ibnlanre/types";
 *
 * type Test = Xor<0, 1>;
 * //   ^? 1
 * ```
 */
type Xor<Left extends Bit, Right extends Bit> = XorHelper[Left][Right];
/**
 * Performs a bitwise XOR operation on two numbers.
 *
 * @param Left - The first number to XOR.
 * @param Right - The second number to XOR.
 *
 * @returns The result of the XOR operation.
 *
 * @example
 * ```ts
 * import type { Apply, TXor } from "@ibnlanre/types";
 *
 * type Test = Apply<TXor, [0, 1]>;
 * //   ^? 1
 * ```
 */
interface TXor<Right extends Bit | void = void, Left extends Bit | void = void> extends Fn<{
    0: Bit;
    1: Bit;
}> {
    slot: [Right, Left];
    data: Xor<this[1], this[0]>;
}

type Branch<Comparison extends Math.ComparisonResult, Positive extends number, Zero extends number, Negative extends number> = Math.Branch<Comparison, Positive, Zero, Negative>;
interface TBranch<Positive extends number | void = never, Zero extends number | void = never, Negative extends number | void = never, Comparison extends Math.ComparisonResult | void = void> extends Fn<{
    0: number;
    1: number;
    2: number;
    3: Math.ComparisonResult;
}> {
    slot: [Positive, Zero, Negative, Comparison];
    data: Branch<this[3], this[0], this[1], this[2]>;
}

/**
 * Compares two numbers.
 *
 * @description
 * The result of the comparison is:
 * - 0 if the two numbers are equal.
 * - 1 if the first number is greater than the second number.
 * - -1 if the first number is less than the second number.
 *
 * @param Left - The left side of the comparison.
 * @param Right - The right side of the comparison.
 *
 * @returns The result of the comparison.
 */
type Compare<Left extends number, Right extends number> = Math.Compare<Left, Right>;
/**
 * Compares two numbers.
 *
 * @description
 * The result of the comparison is:
 * - 0 if the two numbers are equal.
 * - 1 if the first number is greater than the second number.
 * - -1 if the first number is less than the second number.
 *
 * @param Right - The right side of the comparison.
 * @param Left - The left side of the comparison.
 *
 * @returns The result of the comparison.
 */
interface TCompare<Right extends number | void = void, Left extends number | void = void> extends Fn<{
    0: number;
    1: number;
}> {
    slot: [Right, Left];
    data: Compare<this[1], this[0]>;
}

type Equal<Left extends number, Right extends number> = Math.Equal<Left, Right>;
interface TEqual<Right extends number | void = void, Left extends number | void = void> extends Fn<{
    0: number;
    1: number;
}> {
    slot: [Right, Left];
    data: Equal<this[1], this[0]>;
}

type GreaterThan<Left extends number, Right extends number> = Math.GreaterThan<Left, Right>;
interface TGreaterThan<Right extends number | void = void, Left extends number | void = void> extends Fn<{
    0: number;
    1: number;
}> {
    slot: [Right, Left];
    data: GreaterThan<this[1], this[0]>;
}

type GreaterThanOrEqual<Left extends number, Right extends number> = Math.GreaterThanOrEqual<Left, Right>;
interface TGreaterThanOrEqual<Right extends number | void = void, Left extends number | void = void> extends Fn<{
    0: number;
    1: number;
}> {
    slot: [Right, Left];
    data: GreaterThanOrEqual<this[1], this[0]>;
}

type LessThan<Left extends number, Right extends number> = Math.LessThan<Left, Right>;
interface TLessThan<Right extends number | void = void, Left extends number | void = void> extends Fn<{
    0: number;
    1: number;
}> {
    slot: [Right, Left];
    data: LessThan<this[1], this[0]>;
}

type LessThanOrEqual<Left extends number, Right extends number> = Math.LessThanOrEqual<Left, Right>;
interface TLessThanOrEqual<Right extends number | void = void, Left extends number | void = void> extends Fn<{
    0: number;
    1: number;
}> {
    slot: [Right, Left];
    data: LessThanOrEqual<this[1], this[0]>;
}

type FirstOfUnionHelper<Union extends unknown, Result = keyof Union> = UnionToIntersection<Union extends any ? () => Union : never> extends () => infer First ? FirstOfUnionHelper<Exclude<Union, First>, First> : Result;
type FirstOfUnion<Union extends unknown> = FirstOfUnionHelper<Union>;
interface TFirstOfUnion<Union extends unknown | void = void> extends Fn<{
    0: unknown;
}> {
    slot: [Union];
    data: FirstOfUnion<this[0]>;
}

type Intersect<ObjectType extends unknown> = {
    [Key in keyof ObjectType]: ObjectType[Key] extends Dictionary ? Intersect<ObjectType[Key]> : ObjectType[Key];
} & unknown;
interface TIntersect<ObjectType extends unknown | void = void> extends Fn<{
    0: unknown;
}> {
    slot: [ObjectType];
    data: Intersect<this[0]>;
}

type LastOfUnion<Union extends unknown> = UnionToIntersection<Union extends any ? () => Union : never> extends () => infer Last ? Last : never;
interface TLastOfUnion<Union extends unknown | void = void> extends Fn<{
    0: unknown;
}> {
    slot: [Union];
    data: LastOfUnion<this[0]>;
}

type UnionToIntersection<Union> = (Union extends any ? (k: Union) => void : never) extends (k: infer Intersection) => void ? Intersection : never;
interface TUnionToIntersection<Union extends unknown | void = void> extends Fn<{
    0: unknown;
}> {
    slot: [Union];
    data: UnionToIntersection<this[0]>;
}

type UnionToTupleHelper<Union, Tail = LastOfUnion<Union>, Rest = Exclude<Union, Tail>> = [Tail] extends [never] ? [] : [...UnionToTupleHelper<Rest>, Tail];
type UnionToTuple<Union> = UnionToTupleHelper<Union>;
interface TUnionToTuple<Union extends unknown | void = void> extends Fn<{
    0: unknown;
}> {
    slot: [Union];
    data: UnionToTuple<this[0]>;
}

type Unionize<Intersection> = Intersect<UnionToIntersection<Intersection>>;
interface TUnionize<Intersection extends unknown | void = void> extends Fn<{
    0: unknown;
}> {
    slot: [Intersection];
    data: Unionize<this[0]>;
}

type DefaultWidenOptions = {
    flattenArrays: true;
    widenReturnType: true;
};
type Flatten<Value extends any[]> = Value extends (infer X)[] ? Widen<X>[] : Value;
type Widen<Value, Options extends {
    flattenArrays?: boolean;
    widenReturnType?: boolean;
} = DefaultWidenOptions> = Value extends string ? string : Value extends number ? number : Value extends bigint ? bigint : Value extends boolean ? boolean : Value extends any[] ? [Options["flattenArrays"]] extends [true] ? Flatten<Value> : Value extends [infer Head, ...infer Rest] ? [Widen<Head, Options>, ...Widen<Rest, Options>] : Value : Value extends Dictionary ? {
    [K in keyof Value]: Widen<Value[K], Options>;
} : Value extends (...args: any[]) => any ? [Options["widenReturnType"]] extends [true] ? (...args: Parameters<Value>) => Widen<ReturnType<Value>, Options> : Value : Value;
interface TWiden<Options extends {
    flattenArrays?: boolean;
    widenReturnType?: boolean;
} | void = DefaultWidenOptions, Value extends unknown | void = void> extends Fn<{
    0: {
        flattenArrays?: boolean;
        widenReturnType?: boolean;
    };
    1: unknown;
}> {
    slot: [Options, Value];
    data: Widen<this[1], this[0]>;
}

type AnyExtend<List extends unknown[], Element extends unknown> = List extends [infer Head, ...infer Rest] ? [Head] extends [Element] ? 1 : AnyExtend<Rest, Element> : 0;
interface TAnyExtend<Element extends unknown, List extends unknown[]> extends Fn<{
    0: unknown;
    1: unknown[];
}> {
    slot: [Element, List];
    data: AnyExtend<this[1], this[0]>;
}

type ElseIf<Comparison extends Bit, Positive extends unknown = never, Zero extends unknown = never> = If<Comparison, Positive, Zero>;
interface TElseIf<Positive extends unknown | void = never, Zero extends unknown | void = never, Comparison extends Bit | void = void> extends Fn<{
    0: unknown;
    1: unknown;
    2: Bit;
}> {
    slot: [Positive, Zero, Comparison];
    data: ElseIf<this[2], this[0], this[1]>;
}

type FallbackTo<ActualValue, FallbackValue, PreventableValue = undefined> = [PreventableValue] extends [ActualValue] ? FallbackValue : RequireValue<ActualValue>;
interface TFallbackTo<FallbackValue extends unknown | void = void, PreventableValue extends unknown | undefined = undefined, ActualValue extends unknown | void = void> extends Fn<{
    0: unknown;
    1: unknown | undefined;
    2: unknown;
}> {
    slot: [FallbackValue, PreventableValue, ActualValue];
    data: FallbackTo<this[2], this[0], this[1]>;
}

type If<Condition extends Bit, Positive extends unknown = never, Zero extends unknown = never> = Condition extends 1 ? Positive : Zero;
interface TIf<Positive extends unknown | void = never, Zero extends unknown | void = never, Condition extends Bit | void = void> extends Fn<{
    0: unknown;
    1: unknown;
    2: Bit;
}> {
    slot: [Positive, Zero, Condition];
    data: If<this[2], this[0], this[1]>;
}

type IfNot<Condition extends Math.ComparisonResult, Positive extends unknown = never, Zero extends unknown = never> = Condition extends 0 ? Positive : Zero;
interface TIfNot<Positive extends unknown | void = never, Zero extends unknown | void = never, Condition extends Math.ComparisonResult | void = void> extends Fn<{
    0: unknown;
    1: unknown;
    2: unknown;
}> {
    slot: [Positive, Zero, Condition];
    data: IfNot<this[2], this[0], this[1]>;
}

type IsAny<Value extends unknown> = 0 extends 1 & Value ? 1 : 0;
interface TIsAny<Value extends unknown | void = void> extends Fn<{
    0: unknown;
}> {
    slot: [Value];
    data: IsAny<this[0]>;
}

type IsArray<Value extends unknown> = Value extends Value ? Value extends unknown[] ? 1 : 0 : never;
interface TIsArray<Value extends unknown | void = void> extends Fn<{
    0: unknown;
}> {
    slot: [Value];
    data: IsArray<this[0]>;
}

type IsBetween<Input extends number, LowerBound extends number, UpperBound extends number> = And<GreaterThanOrEqual<Input, LowerBound>, LessThanOrEqual<Input, UpperBound>>;
interface TIsBetween<LowerBound extends number | void = void, UpperBound extends number | void = void, Input extends number | void = void> extends Fn<{
    0: number;
    1: number;
    2: number;
}> {
    slot: [LowerBound, UpperBound, Input];
    data: IsBetween<this[2], this[0], this[1]>;
}

type IsDictionary<Value extends unknown> = Value extends Value ? Value extends Dictionary ? 1 : 0 : never;
interface TIsDictionary<Value extends unknown | void = void> extends Fn<{
    0: unknown;
}> {
    slot: [Value];
    data: IsDictionary<this[0]>;
}

type IsExact<Left, Right> = (<T>() => T extends Left ? 1 : 0) extends <T>() => T extends Right ? 1 : 0 ? 1 : 0;
interface TIsExact<Left extends unknown | void = void, Right extends unknown | void = void> extends Fn<{
    0: unknown;
    1: unknown;
}> {
    slot: [Left, Right];
    data: IsExact<this[0], this[1]>;
}

type IsIntersectionHelper<Left, Right> = (<T>() => T extends Left & T ? 1 : 0) extends <T>() => T extends Right & T ? 1 : 0 ? 0 : 1;
type IsIntersection<Value> = IsIntersectionHelper<Value, Intersect<Value>>;
interface TIsIntersection<Value extends unknown | void = void> extends Fn<{
    0: unknown;
}> {
    slot: [Value];
    data: IsIntersection<this[0]>;
}

type IsNever<Value> = [Value] extends [never] ? 1 : 0;
interface TIsNever<Value extends unknown | void = void> extends Fn<{
    0: unknown;
}> {
    slot: [Value];
    data: IsNever<this[0]>;
}

type IsObject<Value extends unknown> = Value extends Value ? Value extends Record<PropertyKey, any> ? 1 : 0 : never;
interface TIsObject<Value extends unknown | void = void> extends Fn<{
    0: unknown;
}> {
    slot: [Value];
    data: IsObject<this[0]>;
}

type IsPartial<Value> = undefined extends Value ? [Value] extends [undefined] ? 0 : 1 : 0;
interface TIsPartial<Value extends unknown | void = void> extends Fn<{
    0: unknown;
}> {
    slot: [Value];
    data: IsPartial<this[0]>;
}

type IsReadonly<Value> = Readonly<Value> extends Value ? true : false;
interface TIsReadonly<Value extends unknown | void = void> extends Fn<{
    0: unknown;
}> {
    slot: [Value];
    data: IsReadonly<this[0]>;
}

type IsString<Value extends unknown> = Value extends Value ? string extends Value ? 1 : Value extends string ? 1 : 0 : never;
interface TIsString<Value extends unknown | void = void> extends Fn<{
    0: unknown;
}> {
    slot: [Value];
    data: IsString<this[0]>;
}

type IsSubtype<Left, Right> = Left extends Right ? 1 : 0;
interface TIsSubtype<Right extends unknown | void = void, Left extends unknown | void = void> extends Fn<{
    0: unknown;
    1: unknown;
}> {
    slot: [Right, Left];
    data: IsSubtype<this[1], this[0]>;
}

type IsSupertype<Left, Right> = Right extends Left ? 1 : 0;
interface TIsSupertype<Right extends unknown | void = void, Left extends unknown | void = void> extends Fn<{
    0: unknown;
    1: unknown;
}> {
    slot: [Right, Left];
    data: IsSupertype<this[1], this[0]>;
}

type IsUnary<Value extends number> = Value extends 1 ? 1 : 0;
interface TIsUnary<Value extends number | void> extends Fn<{
    0: number;
}> {
    slot: [Value];
    data: IsUnary<this[0]>;
}

type IsUnion<Value> = [Value] extends UnionToTuple<Value> ? 0 : 1;
interface TIsUnion<Value extends unknown | void = void> extends Fn<{
    0: unknown;
}> {
    slot: [Value];
    data: IsUnion<this[0]>;
}

type UnknownHelper<T> = [T] extends [void] ? 1 : 0;
type NeverHelper<T> = [void] extends [T] ? 1 : 0;
type IsVoid<T> = And<UnknownHelper<T>, NeverHelper<T>>;
interface TIsVoid<T extends unknown | void = void> extends Fn<{
    0: unknown;
}> {
    slot: [T];
    data: IsVoid<this[0]>;
}

type IsZero<Value extends number> = Value extends 0 ? 1 : 0;
interface TIsZero<Value extends number | void = void> extends Fn<{
    0: number;
}> {
    slot: [Value];
    data: IsZero<this[0]>;
}

type SingleOut<List extends unknown[]> = List extends [infer Value] ? Value : List;
/**
 * Mark out the void values in a list
 *
 * @param List The list to mark out void values
 * @param Params The parameters to compare with the list
 *
 * @returns The list with void values marked out
 *
 * @description
 * - never extends void, but void does not extend never
 * - If void extends the value, we return the value
 */
type MarkOut<List extends unknown[], Params> = List extends [
    ...infer Ls,
    infer Lv
] ? Params extends [...infer Ts, infer Tv] ? IsVoid<Lv> extends 1 ? [...MarkOut<Ls, Ts>, Tv] : MarkOut<Ls, Ts> : [] : [];
/**
 * Get the arguments of a function
 *
 * @param Callback The function to get its arguments
 * @returns The arguments of the function
 *
 * @example
 * ```ts
 * import type { Fn } from "@ibnlanre/types";
 *
 * type Test = Fn.Arguments<TTrim>;
 * //   ^? string
 * ```
 */
type Arguments<Callback extends Fn> = Callback["slot"] extends unknown[] ? SingleOut<MarkOut<Callback["slot"], Fn.Parameters<Callback>>> : never;

type ComposeLeftHelper<Argument extends unknown, Callbacks extends Fn[], Position extends number = 0> = Callbacks extends [infer Callback extends Fn, ...infer Rest extends Fn[]] ? Argument extends Fn.Arguments<Callback> ? ComposeLeftHelper<Apply<Callback, [Argument]>, Rest, Add$1<Position, 1>> : {
    position: Position;
    scenario: Error;
    callback: Callback;
    expected: Fn.Arguments<Callback>;
    received: Argument;
} : never;
/**
 * Returns an `Error` object if the result from a function cannot be applied to the next function.
 *
 * @summary
 * Returns never if the argument can be applied to all the functions passed.
 *
 * @param Argument - The argument to be passed to the functions.
 * @param Callbacks - The list of functions to be applied to the argument.
 *
 * @returns An `Error` object if the argument cannot be applied to any of the functions passed.
 */
type ComposeLeft<Argument extends unknown, Callbacks extends Fn[]> = ComposeLeftHelper<Argument, Callbacks>;

/**
 * Returns a list of functions that can accept the result of the previous function
 *
 * @summary
 * - Omits functions that cannot be applied to the argument.
 * - Starts calculating from the argument passed
 *
 * @param Argument - The argument to be passed to the functions.
 * @param Callbacks - The list of functions to be applied to the argument.
 *
 * @returns A list of functions that can be applied to the argument in reverse order.
 */
type ComposeRight<Argument extends unknown, Callbacks extends Fn[]> = Callbacks extends [infer Callback extends Fn, ...infer Rest extends Fn[]] ? Argument extends Fn.Arguments<Callback> ? [Callback, ...ComposeRight<Apply<Callback, [Argument]>, Rest>] : [] : Callbacks;

interface Lambda<Input extends unknown> extends Fn {
    input_size: Size<Fn.Preset<Fn.Reflect<Input>>>;
}

type Parameters$1<Callback extends Fn> = SliceTo<Callback["params"], Size<Callback["slot"]>>;

type Signature<Callback extends Fn> = Elements<Fn.Arguments<Callback>>;

type Collect<List> = List extends unknown[] ? List : [List];

type DevoidHelper<List extends unknown[], Result extends unknown[] = []> = List extends [] ? Result : List extends [infer Head, ...infer Rest] ? IsVoid<Head> extends 1 ? DevoidHelper<Rest, Result> : DevoidHelper<Rest, [...Result, Head]> : Result;
type Devoid<List extends unknown[]> = DevoidHelper<List>;

/**
 * Returns a tuple of widened types or void.
 *
 * @param Argument - The tuple to widen.
 * @returns A tuple of widened types or void.
 *
 * @example
 * ```ts
 * import type { Preset } from "@ibnlanre/function";
 *
 * type Test = Preset<[1, "b"]>;
 * //   ^? [number | void, string | void]
 *
 * type Test2 = Preset<"a">;
 * //   ^? [string | void]
 * ```
 */
type Preset<Argument extends unknown> = Argument extends unknown[] ? Argument extends [infer Head, ...infer Rest] ? [Widen<Head> | void, ...Preset<Rest>] : [] : [Widen<Argument> | void];

type Reflect<Input extends unknown> = Input extends unknown[] ? [Input] : Input;

type Last<Rest extends unknown[], Tail extends unknown> = [...Rest, Tail];
type First<Head extends unknown, Rest extends unknown[]> = [Head, ...Rest];
type SelectHelper<Left extends unknown[], Right extends unknown[], Result extends unknown[] = []> = Left extends [] ? Result : Left extends Last<infer LeftRest, infer LeftTail> ? Right extends Last<infer RightRest, infer RightTail> ? IsVoid<LeftTail> extends 1 ? SelectHelper<LeftRest, RightRest, First<RightTail, Result>> : SelectHelper<LeftRest, Right, First<LeftTail, Result>> : Devoid<Concat<Left, Result>> : Result;
type Elect<Left extends unknown[], Right extends unknown[]> = Right extends (infer Elements extends unknown[])[] ? Or<IsNever<Elements>, IsUnary<Count<Left, void>>> extends 1 ? Right : Elements : Right;
type Select<Left extends unknown, Right extends unknown> = SelectHelper<Collect<Left>, Devoid<Elect<Collect<Left>, Collect<Right>>>>;

/**
 * Placeholder for unset values
 *
 * @description
 * This symbol is used to represent void values.
 */
declare const unset: unique symbol;
type unset = typeof unset;

interface FnImpl {
    /**
     * Field for arguments within higher-order functions
     *
     * @description
     * This field is used to represent arguments in a higher-order function.
     */
    args: unknown;
    /**
     * A field that represents a slot.
     *
     * @description
     * This field is used to represent arguments in a function.
     */
    slot: unknown[];
    /**
     * Field for the return value of functions
     *
     * @description
     * This field is used to represent the return value of a function.
     */
    data: unknown;
}
interface FnArgs extends FnImpl {
    0: Retrieve<this["args"]>;
    1: Retrieve<this["args"], 1>;
    2: Retrieve<this["args"], 2>;
    3: Retrieve<this["args"], 3>;
    4: Retrieve<this["args"], 4>;
    5: Retrieve<this["args"], 5>;
    6: Retrieve<this["args"], 6>;
    7: Retrieve<this["args"], 7>;
    8: Retrieve<this["args"], 8>;
    9: Retrieve<this["args"], 9>;
}
/**
 * Parameterized function type
 * @see https://github.com/microsoft/TypeScript/issues/1213#issuecomment-1215039765
 * @see https://stackoverflow.com/a/73533674
 */
interface Fn<Params extends Dictionary<number> = {}> extends FnArgs {
    input_size: Size<TakeFromArray<this["slot"], void>>;
    /**
     * Field for parameters within higher-order functions
     *
     * @description
     * This field is used to represent parameters in a higher-order function.
     */
    params: [
        Params[0],
        Params[1],
        Params[2],
        Params[3],
        Params[4],
        Params[5],
        Params[6],
        Params[7],
        Params[8],
        Params[9]
    ];
}
declare namespace Fn {
    export type { Arguments, Collect, ComposeLeft, ComposeRight, Devoid, Lambda, Parameters$1 as Parameters, Preset, Reflect, Select, Signature, };
}

type Apply<Callback extends Fn, List extends NonEmptyArray<Fn.Arguments<Callback>>> = (Callback & {
    args: Fn.Select<Callback["slot"], List>;
})["data"];
interface TApply<Callback extends Fn, List extends NonEmptyArray<Fn.Arguments<Callback>> | void = void> extends Fn<{
    0: Fn;
    1: NonEmptyArray<Fn.Arguments<Callback>>;
}> {
    slot: [Callback, List];
    data: Apply<this[0], this[1]>;
}

type Call<Callback extends Fn> = (Callback & {
    args: Callback["slot"];
})["data"];
interface TCall<Callback extends Fn> extends Fn<{
    0: Fn;
}> {
    slot: [Callback];
    data: Call<this[0]>;
}

type Invoke<Input extends unknown, Callbacks extends Array<Fn.Lambda<Input>>, Result extends unknown[] = []> = Callbacks extends [
    infer Callback extends Fn,
    ...infer Rest extends Array<Fn.Lambda<Input>>
] ? Input extends Fn.Arguments<Callback> ? Invoke<Input, Rest, [...Result, Apply<Callback, [Input]>]> : Invoke<Input, Rest, Result> : Result;
interface TInvoke<Callbacks extends Array<Fn.Lambda<Input>> | void = void, Input extends unknown | void = void> extends Fn<{
    0: Array<Fn.Lambda<Input>>;
    1: unknown;
}> {
    slot: [Callbacks, Input];
    data: Invoke<this[1], this[0]>;
}

type PipeHelper<Item extends unknown, Callbacks extends Fn[]> = Callbacks extends [infer Callback extends Fn, ...infer Rest extends Fn[]] ? Item extends Fn.Arguments<Callback> ? PipeHelper<Apply<Callback, [Item]>, Rest> : never : Item;
type Pipe<Item extends unknown, Callbacks extends Fn[]> = ComposeLeft<Item, Callbacks> extends infer Composed ? IsNever<Composed> extends 1 ? PipeHelper<Item, Callbacks> : Composed : never;
interface TPipe<Callbacks extends Fn[] | void = void, Item extends unknown | void = void> extends Fn<{
    0: Fn[];
    1: unknown;
}> {
    slot: [Callbacks, Item];
    data: Pipe<this[1], this[0]>;
}

type Take<Collection extends unknown, Value extends unknown = never> = IsNever<Value> extends 1 ? Collection : Value extends Collection ? Extract<Collection, Value> : Value;
interface TTake<Value extends unknown | void = never, Collection extends unknown | void = void> extends Fn<{
    0: unknown;
    1: unknown;
}> {
    slot: [Value, Collection];
    data: Take<this[1], this[0]>;
}

type TakeFromArray<List extends unknown[], Value extends unknown = never> = IsNever<Value> extends 1 ? List : List extends [infer Head, ...infer Rest] ? [Value] extends [Head] ? TakeFromArray<Rest, Value> extends infer Rest ? Rest extends unknown[] ? [Head, ...Rest] : [Head, Rest] : never : TakeFromArray<Rest, Value> : List;
interface TTakeFromArray<Value extends unknown | void = never, List extends unknown[] | void = void> extends Fn<{
    0: unknown;
    1: unknown[];
}> {
    slot: [Value, List];
    data: TakeFromArray<this[1], this[0]>;
}

type TakeFromDictionary<ObjectType extends Dictionary, Path extends unknown = never> = IsNever<Path> extends 1 ? ObjectType : Path extends PropertyKey ? Has<ObjectType, Path> extends 1 ? Get<ObjectType, Exclude<Path, symbol>> : never : ObjectType;
interface TTakeFromDictionary<Path extends PropertyKey | void = never, ObjectType extends Dictionary | void = void> extends Fn<{
    0: PropertyKey;
    1: Dictionary;
}> {
    slot: [Path, ObjectType];
    data: TakeFromDictionary<this[1], this[0]>;
}

type ArbitraryKey<T = never> = T | (string & {});

type Buffers = SharedArrayBuffer | SharedArrayBufferConstructor | Atomics;

type Derivatives = RegExp | Date | JSON;

type Errors = Error | ErrorConstructor | EvalError | RangeError | ReferenceError | SyntaxError | TypeError | URIError;

type Events = Event | ErrorEvent | DOMException | CustomEvent | EventTarget | EventListener | EventListenerObject | EventListenerOrEventListenerObject | EventListenerOptions;

type Functions = Function | FunctionConstructor | Generator | GeneratorFunction | GeneratorFunctionConstructor | AsyncGenerator | AsyncGeneratorFunction | AsyncGeneratorFunctionConstructor | Promise<any> | PromiseConstructor;

type Arrays = Array<any> | ReadonlyArray<any>;

type TypedArrays = ArrayBuffer | DataView | Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;

type Indexable = Arrays | TypedArrays;

type Maps = Map<any, any> | WeakMap<object, any> | ReadonlyMap<any, any>;

type Sets = Set<any> | WeakSet<object> | ReadonlySet<any>;

type Structures = Maps | Sets;

type Iterables = string | Iterable<any> | AsyncIterable<any> | IterableIterator<any> | AsyncIterableIterator<any> | Sets | Maps;

type Primitive = string | number | boolean | null;
type Member = Primitive | Record<string, Primitive> | Array<Json>;
type Json = Member | Record<string, Member>;

type NonEmptyArray<T> = [T, ...T[]];

type Dictionary<Key extends PropertyKey = string, Type extends unknown = unknown> = Record<Key, Type>;

type EmptyObject = Record<PropertyKey, never>;

type Nullable<T = unset> = Exclude<T, unset> | null;

type Nullish<T = unset> = Exclude<T, unset> | null | undefined;

type Serializable = string | number | bigint | boolean | null | undefined;

type Primitives = Serializable | symbol;

type Symbols = "~" | "!" | "@" | "#" | "$" | "%" | "^" | "&" | "*" | "(" | ")" | "-" | "_" | "=" | "+" | "[" | "{" | "]" | "}" | "\\" | "/" | "|" | ";" | ":" | "'" | '"' | "," | "<" | "." | ">" | "?" | "`";

type InferBoolean<Value extends boolean> = boolean extends Value ? boolean : Value extends boolean ? Value : never;
interface TInferBoolean<Value extends boolean | void = void> extends Fn<{
    0: boolean;
}> {
    slot: [Value];
    data: InferBoolean<this[0]>;
}

type InferNumber<Value extends number> = number extends Value ? number : Value extends number ? Value : never;
interface TInferNumber<Value extends number | void = void> extends Fn<{
    0: number;
}> {
    slot: [Value];
    data: InferNumber<this[0]>;
}

type InferString<Value extends string> = string extends Value ? string : Value extends string ? Value : never;
interface TInferString<Value extends string | void = void> extends Fn<{
    0: string;
}> {
    slot: [Value];
    data: InferString<this[0]>;
}

type InferSymbol<Value extends symbol> = symbol extends Value ? symbol : Value extends symbol ? Value : never;
interface TInferSymbol<Value extends symbol | void = void> extends Fn<{
    0: symbol;
}> {
    slot: [Value];
    data: InferSymbol<this[0]>;
}

type InferUndefined<Value extends undefined> = undefined extends Value ? undefined : Value extends undefined ? Value : never;
interface TInferUndefined<Value extends undefined | void = void> extends Fn<{
    0: undefined;
}> {
    slot: [Value];
    data: InferUndefined<this[0]>;
}

type InferNull<Value extends null> = null extends Value ? null : Value extends null ? Value : never;
interface TInferNull<Value extends null | void = void> extends Fn<{
    0: null;
}> {
    slot: [Value];
    data: InferNull<this[0]>;
}

type InferObject<Value extends Record<PropertyKey, unknown>> = Value extends Record<PropertyKey, unknown> ? Value : never;
interface TInferObject<Value extends Record<PropertyKey, unknown> | void = void> extends Fn<{
    0: Record<PropertyKey, unknown>;
}> {
    slot: [Value];
    data: InferObject<this[0]>;
}

type InferArray<Value extends Type[], Type = unknown> = Value;
interface TInferArray<Type extends unknown | void = void, Value extends Type[] | void = void> extends Fn<{
    0: Type;
    1: Type[];
}> {
    slot: [Type, Value];
    data: InferArray<this[1], this[0]>;
}

export { type Absolute$1 as Absolute, type Add$1 as Add, type Addition$1 as Addition, type Anchor, type And, type AnyExtend, type Append, type Apply, type ArbitraryKey, type ArrayOf, type Arrays, type Assign, Bit, type Branch, type Buffers, type Call, type Ceil, type Circle, type Clamp$1 as Clamp, type Collect$1 as Collect, type Combine, type Compare, type Concat, type Contains, type Count, type Decrement, type DeepPartial, type DeepRequired, type Derivatives, type Dictionary, type Diff, Digit, type Divide$1 as Divide, type Division$1 as Division, type Drop, type Elements, type ElseIf, type EmptyObject, type EndsWith, type Entries, type Equal, type Errors, type Events, type Every, type ExcludeKeys, type Expand, type ExtractNestedKeys, type ExtractRootKey, type FallbackTo, type Filter, type FirstOfUnion, type Flat, type Flip, type Floor$1 as Floor, Fn, type FromEntries, type Functions, type Get, type GreaterThan, type GreaterThanOrEqual, type Has, type Head$1 as Head, type If, type IfNot, type Immutable, type IncludeKeys, type Includes, type Increment, type Indexable, type Indices, type InferArray, type InferBoolean, type InferNull, type InferNumber, type InferObject, type InferString, type InferSymbol, type InferUndefined, type Insert, type Intersect, type Invoke, type IsAny, type IsArray, type IsBetween, type IsDictionary, type IsEven$1 as IsEven, type IsExact, type IsInteger$1 as IsInteger, type IsIntersection, type IsNegative$1 as IsNegative, type IsNever, type IsNonInteger$1 as IsNonInteger, type IsObject, type IsOdd$1 as IsOdd, type IsPartial, type IsPositive$1 as IsPositive, type IsReadonly, type IsString, type IsSubtype, type IsSupertype, type IsUnary, type IsUnion, type IsVoid, type IsZero, type Iterables, type Join$1 as Join, type JoinKeys, type Json, type Keys, type LastOfUnion, type Length, type LessThan, type LessThanOrEqual, type Locate, type Map$1 as Map, type Maps, Math, type Max, type Maximum$1 as Maximum, type Merge, type Min, type Minimum$1 as Minimum, type Modulo, type Multiplication$1 as Multiplication, type Multiply$1 as Multiply, type Mutable, type Nand, type Negate$1 as Negate, type NoNumber, type NonEmptyArray, type Not, type Nullable, type Nullish, type ObjectFromPath, type Occurrence, type OmitOptionalValues, type OmitPath, type OmitRequiredValues, type OptionalKeyMap, type OptionalKeys, type OptionalKeysDeep, type Or, type Ordinal, type PadEnd$1 as PadEnd, type PadStart$1 as PadStart, type ParseInt, type Paths, type Pattern, type Permutation, type Pipe, type Pivot, type Place, type Pop, type Pow, type Prepend, type Primitives, type Push, type Range, type Reduce, type Reject, type Replace, type RequireValue, type RequiredKeyMap, type RequiredKeys, type RequiredKeysDeep, type Retrieve, type Reverse, type RotateLeft, type RotateRight, type Round$1 as Round, type Serializable, type Sets, type Shift, type Shuffle, type Sign$1 as Sign, type Size, type Slice, type SliceFrom, type SliceTo, type Some, type Sort, type Split, type SquareRoot$1 as SquareRoot, type StartsWith, type Stringify, type Structures, type Substring, type Subtract$1 as Subtract, type Subtraction$1 as Subtraction, type Symbols, type TAbsolute, type TAdd, type TAddition, type TAnchor, type TAnd, type TAnyExtend, type TAppend, type TApply, type TArrayOf, type TAssign, type TBranch, type TCall, type TCeil, type TCircle, type TCollect, type TCombine, type TCompare, type TConcat, type TContains, type TCount, type TDecrement, type TDeepPartial, type TDeepRequired, type TDiff, type TDivide, type TDivision, type TDrop, type TElements, type TElseIf, type TEndsWith, type TEntries, type TEqual, type TEvery, type TExcludeKeys, type TExpand, type TExtractNestedKeys, type TExtractRootKey, type TFallbackTo, type TFilter, type TFirstOfUnion, type TFlat, type TFlip, type TFloor, type TFromEntries, type TGet, type TGreaterThan, type TGreaterThanOrEqual, type THas, type THead, type TIf, type TIfNot, type TImmutable, type TIncludeKeys, type TIncludes, type TIncrement, type TIndices, type TInferArray, type TInferBoolean, type TInferNull, type TInferNumber, type TInferObject, type TInferString, type TInferSymbol, type TInferUndefined, type TInsert, type TIntersect, type TInvoke, type TIsAny, type TIsArray, type TIsBetween, type TIsDictionary, type TIsEven, type TIsExact, type TIsInteger, type TIsIntersection, type TIsNegative, type TIsNever, type TIsNonInteger, type TIsObject, type TIsOdd, type TIsPartial, type TIsPositive, type TIsReadonly, type TIsString, type TIsSubtype, type TIsSupertype, type TIsUnary, type TIsUnion, type TIsVoid, type TIsZero, type TJoin, type TJoinKeys, type TKeys, type TKeysAsTuple, type TLastOfUnion, type TLength, type TLessThan, type TLessThanOrEqual, type TLocate, type TMap, type TMerge, type TModulo, type TMultiplication, type TMultiply, type TMutable, type TNand, type TNegate, type TNoNumber, type TNot, type TObjectFromPath, type TOccurrence, type TOmitOptionalValues, type TOmitPath, type TOmitRequiredValues, type TOptionalKeys, type TOptionalKeysDeep, type TOr, type TOrdinal, type TPadEnd, type TPadStart, type TParseInt, type TPaths, type TPattern, type TPermutation, type TPipe, type TPivot, type TPlace, type TPop, type TPow, type TPrepend, type TPush, type TRange, type TReduce, type TReject, type TReplace, type TRequireValue, type TRequiredKeys, type TRequiredKeysDeep, type TRetrieve, type TReverse, type TRotateLeft, type TRotateRight, type TRound, type TShift, type TShuffle, type TSign, type TSize, type TSlice, type TSliceFrom, type TSliceTo, type TSome, type TSort, type TSplit, type TSquareRoot, type TStartsWith, type TStringify, type TSubstring, type TSubtract, type TSubtraction, type TTail, type TTake, type TTakeFromArray, type TTakeFromDictionary, type TTemplate, type TToEntries, type TToFixed, type TTrim, type TTrimEnd, type TTrimHead, type TTrimStart, type TTrimTail, type TTrunc, type TUnionToIntersection, type TUnionToTuple, type TUnionize, type TUnshift, type TValueAt, type TValues, type TWiden, type TWith, type TXor, type TZip, type Tail, type Take, type TakeFromArray, type TakeFromDictionary, type Template, type ToEntries, type ToFixed$1 as ToFixed, type Trim, type TrimEnd, type TrimHead, type TrimStart, type TrimTail, type Trunc, type TypedArrays, type UnionToIntersection, type UnionToTuple, type Unionize, type Unshift, type ValueAt, type Values, type Widen, type With, type Xor, type Zip, unset };