data-structure-typed 0.8.18 → 1.12.9

package/dist/types/data-structures/linked-list/doubly-linked-list.d.ts

@@ -1,59 +0,0 @@
-export declare class DoublyLinkedListNode<T> {
-    val: T;
-    next: DoublyLinkedListNode<T> | null;
-    prev: DoublyLinkedListNode<T> | null;
-    constructor(nodeValue: T);
-}
-export type DoublyLinkedListGetBy = 'node' | 'val';
-export declare class DoublyLinkedList<T> {
-    private _first;
-    private _last;
-    private _size;
-    get size(): number;
-    set size(v: number);
-    /**
-     * Adds a node at the beginning of the linked list
-     * @param val Value to be stored at the beginning of the linked list
-     */
-    offerFirst(val: T): boolean;
-    /**
-     * Adds a node to the end of the linked list
-     * @param val Value to be stored in the Doubly linked list node
-     */
-    offerLast(val: T): boolean;
-    peekFirst(): T | null;
-    peekFirst(by: 'val'): T | null;
-    peekFirst(by: 'node'): DoublyLinkedListNode<T> | null;
-    peekLast(): T | null;
-    peekLast(by: 'val'): T | null;
-    peekLast(by: 'node'): DoublyLinkedListNode<T> | null;
-    pollFirst(): T | null;
-    pollFirst(by: 'val'): T | null;
-    pollFirst(by: 'node'): DoublyLinkedListNode<T> | null;
-    pollLast(): T | null;
-    pollLast(by: 'val'): T | null;
-    pollLast(by: 'node'): DoublyLinkedListNode<T> | null;
-    get(index: number): T | null;
-    get(index: number, by: 'node'): DoublyLinkedListNode<T> | null;
-    get(index: number, by: 'val'): T | null;
-    /**
-     * Updates the value of the node at the specified index.
-     * If index = 0; Value of the first element in the list is updated.
-     * If index = 3; Value of the fourth element in the list is updated.
-     * @param index Index of the node to be updated
-     * @param val New value of the node
-     */
-    set(index: number, val: T): boolean;
-    isEmpty(): boolean;
-    /**
-     * Inserts a new node at the specified index.
-     * @param index Index at which the new node has to be inserted
-     * @param val Value of the new node to be inserted
-     */
-    insert(index: number, val: T): boolean;
-    /**
-     * Removes a node at the specified index and returns its value.
-     * @param index Index at which the node has to be removed.
-     */
-    remove(index: number): T | null;
-}

package/dist/types/data-structures/linked-list/index.d.ts

@@ -1,2 +0,0 @@
-export * from './singly-linked-list';
-export * from './doubly-linked-list';

package/dist/types/data-structures/linked-list/singly-linked-list.d.ts

@@ -1,358 +0,0 @@
-/** Type used for filter and find methods, returning a boolean */
-type TTestFunction<NodeData> = (data: NodeData, index: number, list: SinglyLinkedList<NodeData>) => boolean;
-/** Type used for map and forEach methods, returning anything */
-type TMapFunction<NodeData> = (data: any, index: number, list: SinglyLinkedList<NodeData>) => any;
-/**
- * The class which represents one link or node in a linked list
- * ```ts
- * const node = new SinglyLinkedListNode(1, null, null, null);
- * ```
- */
-export declare class SinglyLinkedListNode<NodeData = any> {
-    /** Data stored on the node */
-    val: NodeData;
-    /** The previous node in the list */
-    prev: SinglyLinkedListNode<NodeData> | null;
-    /** The next link in the list */
-    next: SinglyLinkedListNode<NodeData> | null;
-    /** The list this node belongs to */
-    list: SinglyLinkedList<NodeData> | null;
-    constructor(
-    /** Data stored on the node */
-    val: NodeData, 
-    /** The previous node in the list */
-    prev: SinglyLinkedListNode<NodeData> | null, 
-    /** The next link in the list */
-    next: SinglyLinkedListNode<NodeData> | null, 
-    /** The list this node belongs to */
-    list: SinglyLinkedList<NodeData> | null);
-    /**
-     * Alias to .val
-     * ```ts
-     * new LinkedList(1, 2, 3).head.value; // 1
-     * ```
-     */
-    get value(): NodeData;
-    /**
-     * Get the index of this node
-     * ```ts
-     * new LinkedList(1, 2, 3).head.index; // 0
-     * ```
-     */
-    get index(): number | undefined;
-    /**
-     * Insert a new node before this one
-     * ```ts
-     * new LinkedList(2, 3).head.insertBefore(1); // 1 <=> 2 <=> 3
-     * ```
-     * @param val Data to save in the node
-     */
-    insertBefore(val: NodeData): SinglyLinkedList<NodeData>;
-    /**
-     * Insert new val after this node
-     * ```ts
-     * new LinkedList(1, 2).tail.insertAfter(3); // 1 <=> 2 <=> 3
-     * ```
-     * @param val Data to be saved in the node
-     */
-    insertAfter(val: NodeData): SinglyLinkedList<NodeData>;
-    /**
-     * Remove this node
-     * ```ts
-     * new LinkedList(1, 2, 3, 4).tail.remove(); // 1 <=> 2 <=> 3
-     * ```
-     */
-    remove(): SinglyLinkedListNode<NodeData>;
-}
-/**
- * A doubly linked list
- * ```ts
- * const list = new LinkedList(1, 2, 3);
- * const listFromArray = LinkedList.from([1, 2, 3]);
- * ```
- */
-export declare class SinglyLinkedList<NodeData = any> {
-    /**
-     * The length of the list
-     */
-    get length(): number;
-    /**
-     * Convert any iterable to a new linked list
-     * ```javascript
-     * const array = [1, 2, 3];
-     * const list = LinkedList.from(array);
-     * ```
-     * @param iterable Any iterable datatype like Array or Map
-     */
-    static from<T>(iterable: Iterable<T>): SinglyLinkedList<T>;
-    /** The head of the list, the first node */
-    head: SinglyLinkedListNode<NodeData> | null;
-    /** The tail of the list, the last node */
-    tail: SinglyLinkedListNode<NodeData> | null;
-    /** Internal size reference */
-    private size;
-    constructor(...args: NodeData[]);
-    /**
-     * Get the node val at a specified index, zero based
-     * ```ts
-     * new LinkedList(1, 2, 3).get(0); // 1
-     * ```
-     * @param index to retrieve val at
-     */
-    get(index: number): NodeData | undefined;
-    /**
-     * Get the node at index, zero based
-     * ```ts
-     * new LinkedList(1, 2, 3).getNode(0);
-     * // { prev: null, val: 1, next: SinglyLinkedListNode }
-     * ```
-     */
-    getNode(index: number): SinglyLinkedListNode<NodeData> | undefined;
-    /**
-     * Return the first node and its index in the list that
-     * satisfies the testing function
-     * ```ts
-     * new LinkedList(1, 2, 3).findNodeIndex(val => val === 1);
-     * // { node: SinglyLinkedListNode, index: 0 }
-     * ```
-     * @param f A function to be applied to the val of each node
-     */
-    findNodeIndex(f: TTestFunction<NodeData>): ({
-        node: SinglyLinkedListNode<NodeData>;
-        index: number;
-    }) | undefined;
-    /**
-     * Returns the first node in the list that
-     * satisfies the provided testing function. Otherwise undefined is returned.
-     * ```ts
-     * new LinkedList(1, 2, 3).findNode(val => val === 1);
-     * // { prev: null, val: 1, next: SinglyLinkedListNode }
-     * ```
-     * @param f Function to test val against
-     */
-    findNode(f: TTestFunction<NodeData>): SinglyLinkedListNode<NodeData> | undefined;
-    /**
-     * Returns the value of the first element in the list that
-     * satisfies the provided testing function. Otherwise undefined is returned.
-     * ```ts
-     * new LinkedList(1, 2, 3).find(val => val === 1); // 1
-     * ```
-     * @param f Function to test val against
-     */
-    find(f: TTestFunction<NodeData>): NodeData | undefined;
-    /**
-     * Returns the index of the first node in the list that
-     * satisfies the provided testing function. Ohterwise -1 is returned.
-     * ```ts
-     * new LinkedList(1, 2, 3).findIndex(val => val === 3); // 2
-     * ```
-     * @param f Function to test val against
-     */
-    findIndex(f: TTestFunction<NodeData>): number;
-    /**
-     * Append one or any number of nodes to the end of the list.
-     * This modifies the list in place and returns the list itself
-     * to make this method chainable.
-     * ```ts
-     * new LinkedList(1).append(2).append(3, 4); // 1 <=> 2 <=> 3 <=> 4
-     * ```
-     * @param args Data to be stored in the node, takes any number of arguments
-     */
-    append(...args: NodeData[]): SinglyLinkedList<NodeData>;
-    /**
-     * Synonym for append
-     * ```ts
-     * new LinkedList(1).push(2).push(3, 4); // 1 <=> 2 <=> 3 <=> 4
-     * ```
-     * @param args Data to be stored, takes any number of arguments
-     */
-    push(...args: NodeData[]): number;
-    /**
-     * Prepend any number of val arguments to the list. The
-     * argument list is prepended as a block to reduce confusion:
-     * ```javascript
-     * new LinkedList(3, 4).prepend(0, 1, 2); // [0, 1, 2, 3, 4]
-     * ```
-     * @param args Data to be stored in the node, accepts any number of arguments
-     */
-    prepend(...args: NodeData[]): SinglyLinkedList<NodeData>;
-    /**
-     * Insert a new node at a given index position. If index is
-     * out of bounds, the node is appended, if index is negative
-     * or 0, it will be prepended.
-     * ```ts
-     * new LinkedList(1, 3).insertAt(1, 2); // 1 <=> 2 <=> 3
-     * ```
-     * @param index The index to insert the new node at
-     * @param val Data to be stored on the new node
-     */
-    insertAt(index: number, val: NodeData): SinglyLinkedList<NodeData>;
-    /**
-     * Remove the specified node from the list and return the removed
-     * node afterwards.
-     * ```ts
-     * const list = new LinkedList(1, 2, 3);
-     * list.removeNode(list.tail); // { prev: null, val: 3, next: null, list: null }
-     * ```
-     * @param node The node to be removed
-     */
-    removeNode(node: SinglyLinkedListNode<NodeData>): SinglyLinkedListNode<NodeData>;
-    /**
-     * Remove the node at the specified index
-     * ```ts
-     * new LinkedList(1, 2, 3).removeAt(2); // { prev: null, val: 3, next: null, list: null }
-     * ```
-     * @param index Index at which to remove
-     */
-    removeAt(index: number): SinglyLinkedListNode<NodeData> | undefined;
-    /**
-     * Insert a new node before the reference node
-     * ```ts
-     * const list = new LinkedList(1, 3);
-     * list.insertBefore(list.tail, 2); // 1 <=> 2 <=> 3
-     * ```
-     * @param referenceNode The node reference
-     * @param val Data to save in the node
-     */
-    insertBefore(referenceNode: SinglyLinkedListNode<NodeData>, val: NodeData): SinglyLinkedList<NodeData>;
-    /**
-     * Sorts the linked list using the provided compare function
-     * @param compare A function used to compare the val of two nodes. It should return
-     *                a boolean. True will insert a before b, false will insert b before a.
-     *                (a, b) => a < b or (1, 2) => 1 < 2 === true, 2 will be inserted after 1,
-     *                the sort order will be ascending.
-     */
-    sort(compare: (a: NodeData, b: NodeData) => boolean): SinglyLinkedList<NodeData>;
-    /**
-     * Insert a new node after this one
-     * ```ts
-     * const list = new LinkedList(2, 3);
-     * list.insertAfter(list.head, 1); // 1 <=> 2 <=> 3
-     * ```
-     * @param referenceNode The reference node
-     * @param val Data to be saved in the node
-     */
-    insertAfter(referenceNode: SinglyLinkedListNode<NodeData>, val: NodeData): SinglyLinkedList<NodeData>;
-    /**
-     * Remove the first node from the list and return the val of the removed node
-     * or undefined
-     * ```ts
-     * new LinkedList(1, 2, 3).shift(); // 1
-     * ```
-     */
-    shift(): NodeData | undefined;
-    /**
-     * Remove the last node from the list and return the val of the removed node
-     * or undefined if the list was empty
-     * ```ts
-     * new LinkedList(1, 2, 3).pop(); // 3
-     * ```
-     */
-    pop(): NodeData | undefined;
-    /**
-     * Merge the current list with another. Both lists will be
-     * equal after merging.
-     * ```ts
-     * const list = new LinkedList(1, 2);
-     * const otherList = new LinkedList(3);
-     * list.merge(otherList);
-     * (list === otherList); // true
-     * ```
-     * @param list The list to be merged
-     */
-    merge(list: SinglyLinkedList<NodeData>): void;
-    /**
-     * Removes all nodes from a list
-     *
-     * ```ts
-     * list.clear();
-     * ```
-     */
-    clear(): this;
-    /**
-     * The slice() method returns a shallow copy of a
-     * portion of a list into a new list object selected
-     * from start to end (end not included).
-     * The original list will not be modified.
-     * ```ts
-     * const list = new LinkedList(1, 2, 3, 4, 5);
-     * const newList = list.slice(0, 3); // 1 <=> 2 <=> 3
-     * ```
-     * @param start Start index
-     * @param end End index, optional
-     */
-    slice(start: number, end?: number): SinglyLinkedList<NodeData | {}>;
-    /**
-     * The reverse() function reverses the list in place and returns the list
-     * itself.
-     * ```ts
-     * new LinkedList(1, 2, 3).reverse(); // 3 <=> 2 <=> 1
-     * ```
-     */
-    reverse(): SinglyLinkedList<NodeData>;
-    /**
-     * The forEach() method executes a provided function once for each list node.
-     * ```ts
-     * new LinkedList(1, 2, 3).forEach(val => log(val)); // 1 2 3
-     * ```
-     * @param f Function to execute for each element, taking up to three arguments.
-     * @param reverse Indicates if the list should be walked in reverse order, default is false
-     */
-    forEach(f: TMapFunction<NodeData>, reverse?: boolean): void;
-    /**
-     * The map() method creates a new list with the results of
-     * calling a provided function on every node in the calling list.
-     * ```ts
-     * new LinkedList(1, 2, 3).map(val => val + 10); // 11 <=> 12 <=> 13
-     * ```
-     * @param f Function that produces an node of the new list, taking up to three arguments
-     * @param reverse Indicates if the list should be mapped in reverse order, default is false
-     */
-    map(f: TMapFunction<NodeData>, reverse?: boolean): SinglyLinkedList<NodeData | {}>;
-    /**
-     * The filter() method creates a new list with all nodes
-     * that pass the test implemented by the provided function.
-     * ```ts
-     * new LinkedList(1, 2, 3, 4, 5).filter(val => val < 4); // 1 <=> 2 <=> 3
-     * ```
-     * @param f Function to test each node val in the list. Return true to keep the node
-     * @param reverse Indicates if the list should be filtered in reverse order, default is false
-     */
-    filter(f: TTestFunction<NodeData>, reverse?: boolean): SinglyLinkedList<NodeData | {}>;
-    /**
-     * Reduce over each node in the list
-     * ```ts
-     * new LinkedList(1, 2, 3).reduce(n => n += 1, 0); // 3
-     * ```
-     * @param f A reducer function
-     * @param start An initial value
-     * @returns The final state of the accumulator
-     */
-    reduce(f: (accumulator: any, currentNode: NodeData, index: number, list: SinglyLinkedList<NodeData>) => any, start?: any, reverse?: boolean): any;
-    /**
-     * Convert the linked list to an array
-     * ```ts
-     * new LinkedList(1, 2, 3).toArray(); // [1, 2, 3]
-     * ```
-     */
-    toArray(): NodeData[];
-    /**
-     * Convert a linked list to string
-     * ```ts
-     * new LinkedList('one', 'two', 'three').toString(' <=> ') === 'one <=> two <=> three';
-     * ```
-     * @param separator Optional string to be placed in between val nodes, default is one space
-     */
-    toString(separator?: string): string;
-    /**
-     * The iterator implementation
-     * ```ts
-     * const list = new LinkedList(1, 2, 3);
-     * for (const val of list) { log(val); } // 1 2 3
-     * ```
-     */
-    [Symbol.iterator](): IterableIterator<NodeData>;
-    /** Private helper function to reduce duplication of pop() and shift() methods */
-    private removeFromAnyEnd;
-}
-export {};

package/dist/types/data-structures/linked-list/skip-linked-list.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/types/data-structures/matrix/index.d.ts

@@ -1,3 +0,0 @@
-export * from './matrix';
-export * from './vector2d';
-export * from './matrix2d';

package/dist/types/data-structures/matrix/matrix.d.ts

@@ -1,9 +0,0 @@
-export declare class MatrixNTI2D<T = number> {
-    private readonly _matrix;
-    constructor(options: {
-        row: number;
-        col: number;
-        initialVal?: T;
-    });
-    toArray(): Array<Array<T>>;
-}

package/dist/types/data-structures/matrix/matrix2d.d.ts

@@ -1,25 +0,0 @@
-import Vector2D from './vector2d';
-export declare class Matrix2D {
-    private readonly _matrix;
-    constructor(value?: number[][] | Vector2D);
-    /**
-     * Return the matrix values
-     */
-    get m(): number[][];
-    static get empty(): number[][];
-    get toVector(): Vector2D;
-    /**
-     * Initialize an identity matrix
-     */
-    static get identity(): number[][];
-    static add(matrix1: Matrix2D, matrix2: Matrix2D): Matrix2D;
-    static subtract(matrix1: Matrix2D, matrix2: Matrix2D): Matrix2D;
-    static multiply(matrix1: Matrix2D, matrix2: Matrix2D): Matrix2D;
-    static multiplyByValue(matrix: Matrix2D, value: number): Matrix2D;
-    static multiplyByVector(matrix: Matrix2D, vector: Vector2D): Vector2D;
-    static view(width: number, height: number): Matrix2D;
-    static scale(factor: number): Matrix2D;
-    static rotate(radians: number): Matrix2D;
-    static translate(vector: Vector2D): Matrix2D;
-}
-export default Matrix2D;

package/dist/types/data-structures/matrix/navigator.d.ts

@@ -1,31 +0,0 @@
-type Direction = 'up' | 'right' | 'down' | 'left';
-type Turning = {
-    [key in Direction]: Direction;
-};
-export declare class Character {
-    direction: Direction;
-    turn: () => Character;
-    constructor(direction: Direction, turning: Turning);
-}
-interface NavigatorParams<T> {
-    matrix: T[][];
-    turning: Turning;
-    onMove: (cur: [number, number]) => void;
-    init: {
-        cur: [number, number];
-        charDir: Direction;
-        VISITED: T;
-    };
-}
-export declare class Navigator<T = number> {
-    private readonly _matrix;
-    private readonly _cur;
-    private _character;
-    private readonly _VISITED;
-    onMove: (cur: [number, number]) => void;
-    constructor({ matrix, turning, onMove, init: { cur, charDir, VISITED } }: NavigatorParams<T>);
-    start(): void;
-    check(direction: Direction): boolean;
-    move(direction: Direction): void;
-}
-export {};

package/dist/types/data-structures/matrix/vector2d.d.ts

@@ -1,74 +0,0 @@
-declare class Vector2D {
-    x: number;
-    y: number;
-    w: number;
-    static add(vector1: Vector2D, vector2: Vector2D): Vector2D;
-    static subtract(vector1: Vector2D, vector2: Vector2D): Vector2D;
-    static subtractValue(vector: Vector2D, value: number): Vector2D;
-    static multiply(vector: Vector2D, value: number): Vector2D;
-    static divide(vector: Vector2D, value: number): Vector2D;
-    static equals(vector1: Vector2D, vector2: Vector2D): boolean;
-    static equalsRounded(vector1: Vector2D, vector2: Vector2D, roundingFactor?: number): boolean;
-    /**
-     * Normalizes the vector if it matches a certain condition
-     */
-    static normalize(vector: Vector2D): Vector2D;
-    /**
-     * Adjusts x and y so that the length of the vector does not exceed max
-     */
-    static truncate(vector: Vector2D, max: number): Vector2D;
-    /**
-     * The vector that is perpendicular to this one
-     */
-    static perp(vector: Vector2D): Vector2D;
-    /**
-     * returns the vector that is the reverse of this vector
-     */
-    static reverse(vector: Vector2D): Vector2D;
-    static abs(vector: Vector2D): Vector2D;
-    /**
-     * The dot product of v1 and v2
-     */
-    static dot(vector1: Vector2D, vector2: Vector2D): number;
-    /**
-     * The distance between this and the vector
-     */
-    static distance(vector1: Vector2D, vector2: Vector2D): number;
-    /**
-     * The distance between this and the vector squared
-     */
-    static distanceSq(vector1: Vector2D, vector2: Vector2D): number;
-    /**
-     * Returns positive if v2 is clockwise of this vector, negative if counterclockwise
-     * (assuming the Y axis is pointing down, X axis to right like a Window app)
-     */
-    static sign(vector1: Vector2D, vector2: Vector2D): number;
-    /**
-     * Returns the angle between origin and the given vector in radians
-     * @param vector
-     */
-    static angle(vector: Vector2D): number;
-    static random(maxX: number, maxY: number): Vector2D;
-    constructor(x?: number, y?: number, w?: number);
-    /**
-     * Check wether both x and y are zero
-     */
-    zero(): void;
-    /**
-     * Set x and y both to zero
-     */
-    get isZero(): boolean;
-    /**
-     * The length / magnitude of the vector
-     */
-    get length(): number;
-    /**
-     * The squared length of the vector
-     */
-    get lengthSq(): number;
-    /**
-     * Return the vector with rounded values
-     */
-    get rounded(): Vector2D;
-}
-export default Vector2D;

package/dist/types/data-structures/priority-queue/index.d.ts

@@ -1,3 +0,0 @@
-export * from './priority-queue';
-export * from './min-priority-queue';
-export * from './max-priority-queue';

package/dist/types/data-structures/priority-queue/max-priority-queue.d.ts

@@ -1,4 +0,0 @@
-import { PriorityQueue, PriorityQueueOptions } from './priority-queue';
-export declare class MaxPriorityQueue<T = number> extends PriorityQueue<T> {
-    constructor(options: PriorityQueueOptions<T>);
-}

package/dist/types/data-structures/priority-queue/min-priority-queue.d.ts

@@ -1,4 +0,0 @@
-import { PriorityQueue, PriorityQueueOptions } from './priority-queue';
-export declare class MinPriorityQueue<T = number> extends PriorityQueue<T> {
-    constructor(options: PriorityQueueOptions<T>);
-}

package/dist/types/data-structures/priority-queue/priority-queue.d.ts

@@ -1,36 +0,0 @@
-export type PriorityQueueComparator<T> = (a: T, b: T) => number;
-export interface PriorityQueueOptions<T> {
-    nodes?: T[];
-    isFix?: boolean;
-    comparator: PriorityQueueComparator<T>;
-}
-export type PriorityQueueDFSOrderPattern = 'pre' | 'in' | 'post';
-export declare class PriorityQueue<T = number> {
-    protected nodes: T[];
-    get size(): number;
-    protected readonly _comparator: PriorityQueueComparator<T>;
-    constructor(options: PriorityQueueOptions<T>);
-    protected _compare(a: number, b: number): boolean;
-    protected _swap(a: number, b: number): void;
-    protected _isValidIndex(index: number): boolean;
-    protected _getParent(child: number): number;
-    protected _getLeft(parent: number): number;
-    protected _getRight(parent: number): number;
-    protected _getComparedChild(parent: number): number;
-    protected _heapifyUp(start: number): void;
-    protected _heapifyDown(start: number): void;
-    protected _fix(): void;
-    offer(node: T): void;
-    peek(): T | null;
-    poll(): T | null;
-    leaf(): T | null;
-    isEmpty(): boolean;
-    clear(): void;
-    toArray(): T[];
-    clone(): PriorityQueue<T>;
-    isValid(): boolean;
-    sort(): T[];
-    DFS(dfsMode: PriorityQueueDFSOrderPattern): (T | null)[];
-    static heapify<T>(options: PriorityQueueOptions<T>): PriorityQueue<T>;
-    static isPriorityQueueified<T>(options: Omit<PriorityQueueOptions<T>, 'isFix'>): boolean;
-}

package/dist/types/data-structures/queue/deque.d.ts

@@ -1,37 +0,0 @@
-import { DoublyLinkedList } from '../linked-list';
-export declare class Deque<T> extends DoublyLinkedList<T> {
-}
-export declare class ObjectDeque<T> {
-    protected _nodes: {
-        [key: number]: T;
-    };
-    protected _capacity: number;
-    protected _first: number;
-    protected _last: number;
-    protected _size: number;
-    constructor(capacity?: number);
-    size(): number;
-    offerFirst(value: T): void;
-    offerLast(value: T): void;
-    pollFirst(): T | undefined;
-    peekFirst(): T | undefined;
-    pollLast(): T | undefined;
-    peekLast(): T | undefined;
-    get(index: number): NonNullable<T> | null;
-    isEmpty(): boolean;
-}
-export declare class ArrayDeque<T> {
-    protected _nodes: T[];
-    get size(): number;
-    offerLast(value: T): number;
-    pollLast(): T | null;
-    pollFirst(): T | null;
-    offerFirst(value: T): number;
-    peekFirst(): T | null;
-    peekLast(): T | null;
-    get(index: number): T | null;
-    set(index: number, value: T): T;
-    insert(index: number, value: T): T[];
-    remove(index: number): T[];
-    isEmpty(): boolean;
-}

package/dist/types/data-structures/queue/index.d.ts

@@ -1 +0,0 @@
-export * from './queue';