priority-deque/bin/index.d.ts

A double-ended priority queue based on min-max heaps.

export declare class PriorityDeque<T> {
    private heap;
    private limit;
    private compare;
    constructor(opts?: {
        compare?: (a: T, b: T) => number;
        limit?: number;
        items?: Iterable<T>;
    });
    clone(): PriorityDeque<T>;
    /** Heap Maintenance Methods **/
    private reheap;
    set(elements: Iterable<T>): void;
    clear(): void;
    private trickleDown;
    private bubbleUp;
    /** Array-Like Methods **/
    [Symbol.iterator](): IterableIterator<T>;
    get length(): number;
    push(...elements: T[]): void;
    append(elements: T[]): void;
    pop(): T | undefined;
    shift(): T | undefined;
    unshift(...elements: T[]): void;
    map<U>(fn: (e: T) => U, compare?: (a: U, b: U) => number): PriorityDeque<U>;
    filter(fn: (e: T) => boolean): PriorityDeque<T>;
    collect<U>(fn: (e: T) => Iterable<U>, compare?: (a: U, b: U) => number): PriorityDeque<U>;
    contains(e: T): boolean;
    some(fn: (e: T) => boolean): boolean;
    every(fn: (e: T) => boolean): boolean;
    find(fn: (e: T) => boolean): T | undefined;
    forEach(fn: (e: T) => void): void;
    /** Heap-Specific Methods **/
    findMin(): T | undefined;
    findMax(): T | undefined;
    private maxIndex;
    replaceMin(e: T): T | undefined;
    replaceMax(e: T): T | undefined;
    private removeAt;
    remove(e: T): boolean;
    replace(a: T, b: T): boolean;
}