yallist

constructor(value: {}, prev?: Node<T>, next?: Node<T>, list?: Yallist<T>);

list?: Yallist<T>;

next?: Node<T>;

prev?: Node<T>;

value: {};

constructor(list?: Iterable<T>);

head?: Node<T>;

length: number;

tail?: Node<T>;

[Symbol.iterator]: () => Generator<T, void, unknown>;

static create: <T = unknown>(list?: Iterable<T>) => Yallist<T>;

forEach: (
    fn: (value: T, i: number, list: Yallist<T>) => any,
    thisp?: any
) => void;

forEachReverse: (
    fn: (value: T, i: number, list: Yallist<T>) => any,
    thisp?: any
) => void;

get: (n: number) => T | undefined;

getReverse: (n: number) => T | undefined;

map: <R = any>(fn: (value: T, list: Yallist<T>) => R, thisp?: any) => Yallist<R>;

mapReverse: <R = any>(
    fn: (value: T, list: Yallist<T>) => R,
    thisp?: any
) => Yallist<R>;

pop: () => T | undefined;

push: (...args: T[]) => number;

pushNode: (node: Node<T>) => void;

reduce: {
    (fn: (left: T, right: T, i: number) => T): T;
    <R = any>(fn: (acc: R, next: T, i: number) => R, initial: R): R;
};

reduceReverse: {
    (fn: (left: T, right: T, i: number) => T): T;
    <R = any>(fn: (acc: R, next: T, i: number) => R, initial: R): R;
};

removeNode: (node: Node<T>) => Node<T> | undefined;

reverse: () => this;

shift: () => T | undefined;

slice: (from?: number, to?: number) => Yallist<unknown>;

sliceReverse: (from?: number, to?: number) => Yallist<unknown>;

splice: (start: number, deleteCount?: number, ...nodes: T[]) => T[];

toArray: () => any[];

toArrayReverse: () => any[];

unshift: (...args: T[]) => number;

unshiftNode: (node: Node<T>) => void;