@ibnlanre/types/dist/index.d.ts

An opinionated collection of typescript types

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