import { UnionToObject } from "../types/index.js";
export type ArrayElement<A> = A extends any[] ? A[number] : A;
export type IsEmptyArray<T extends any[]> = T extends [] ? true : false;
export type MaybeArray<T> = T | Array<T>;
export type ExtendsArray<T> = T extends any[] ? true : false;
export interface FixedLengthArray<T, L extends number> extends Array<T> {
    0: T;
    length: L;
}
export type First<T> = T extends [infer F, ...any[]] ? F : never;
export type Last<T> = T extends [...any[], infer L] ? L : never;
export type Tail<T> = T extends [any, ...infer Rest] ? Rest : never;
export type HasTail<T> = T extends [] | [any] ? false : true;
/**
 * Returns passed tuple with added type to the first element
 * @example
 * type T = Unshift<1, [2, 3, 4]>
 * @returns: [1, 2, 3, 4] tuple type
 * -----------
 * @example
 * type T = Unshift<"potato", ["tomato", "tornado"]>
 * @returns: ["potato", "tomato", "tornado"] tuple type
 */
export type Unshift<E, T extends any[]> = ((first: E, ...args: T) => any) extends (...args: infer U) => any ? U : T;
/**
 * Returns new tuple with cutting by amount passed
 * @example
 * type T = Slice<2, [1, 2, 3, 4]>;
 * @returns: [3, 4] tuple type
 * ------------
 * @example
 * type T = Slice<2, ["tomato", "tornado", "potato"]>;
 * @returns: ["potato"] tuple type
 */
export type Slice<Amount extends number, T extends any[], I extends any[] = []> = {
    0: Slice<Amount, Tail<T>, Unshift<any, I>>;
    1: T;
}[Length<I> extends Amount ? 1 : 0];
export type Length<T extends any[]> = T["length"];
export type Position<I extends any[]> = Length<I>;
export type Next<I extends any[]> = Unshift<any, I>;
export type Prev<I extends any[]> = Tail<I>;
/**
 * Creates new tuple type based on "Index" and "From" generics
 * @example
 * type T1 = Iterator<4>;
 * @returns: [any, any, any, any] tuple type
 * ------------
 * @example
 * type T1 = Iterator<4, [any, any]>;
 * @returns: [any, any, any, any, any, any] tuple type
 */
export type Iterator<Index extends number = 0, From extends any[] = [], I extends any[] = []> = {
    0: Iterator<Index, Next<From>, Next<I>>;
    1: From;
}[Position<I> extends Index ? 1 : 0];
/**
 * Returns reversed "T" generic tuple with connecting "R" generic tuple
 * @example
 * type T = Reverse<[1, 2, 3], [4, 5, 6]>;
 * @returns: [3, 2, 1, 4, 5, 6] tuple type
 * ------------
 * @example
 * type T = Reverse<["potato", "tomato", "tornado"], ["Lumbago", "Chicago", "Legato"]>;
 * @returns: ["tornado", "tomato", "potato", "Lumbago", "Chicago", "Legato"] tuple type
 */
export type Reverse<T extends any[], R extends any[] = [], I extends any[] = Iterator> = {
    0: Reverse<T, Unshift<T[Position<I>], R>, Next<I>>;
    1: R;
}[Position<I> extends Length<T> ? 1 : 0];
/**
 * Returns joined tuples
 * @example
 * type T = Concat<[1, 2, 3], [4, 5, 6]>;
 * @returns: [1, 2, 3, 4, 5, 6] tuple type
 * ------------
 * @example
 * type T = Concat<["potato", "tomato", "tornado"], ["Lumbago", "Chicago", "Legato"]>;
 * @returns: ["potato", "tomato", "tornado", "Lumbago", "Chicago", "Legato"] tuple type
 */
export type Concat<A1 extends any[], A2 extends any[]> = [...A1, ...A2];
export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
export type LastOf<T> = UnionToIntersection<T extends any ? () => T : never> extends () => infer R ? R : never;
export type IsUnionType<T extends string> = 1 extends TuplifyUnion<keyof UnionToObject<T>>["length"] ? false : true;
export type Split<S extends string, D extends string> = string extends S ? string[] : S extends "" ? [] : S extends `${infer T}${D}${infer U}` ? [T, ...Split<U, D>] : [S];
export type Push<T extends any[], V> = [...T, V];
export type TuplifyUnion<T, L = LastOf<T>, N = [T] extends [never] ? true : false> = true extends N ? [] : Push<TuplifyUnion<Exclude<T, L>>, L>;
export type TupleIntoUnion<T extends Array<string | number>, S extends string = "."> = T extends [
    infer A,
    ...infer GenericTail
] ? A extends string | number ? GenericTail extends Array<string | number> ? GenericTail extends [] ? A : `${A}${S}${TupleIntoUnion<GenericTail, S>}` : never : never : never;