data-structure-typed 2.1.0 → 2.1.2

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

@@ -1,27 +0,0 @@
-/**
- * data-structure-typed
- *
- * @author Kirk Qi
- * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
- * @license MIT License
- */
-import type { PriorityQueueOptions } from '../../types';
-import { PriorityQueue } from './priority-queue';
-/**
- * Max-oriented priority queue (max-heap) built on {@link PriorityQueue}.
- * The default comparator orders primitive values in descending order. If you store objects,
- * you must provide a custom comparator via {@link PriorityQueueOptions}.
- * @template E Element type stored in the queue.
- * @template R Extra record/metadata associated with each element.
- * @example
- */
-export declare class MaxPriorityQueue<E = any, R = any> extends PriorityQueue<E, R> {
-    /**
-     * Creates a max-priority queue.
-     * @param elements Optional initial elements to insert.
-     * @param options Optional configuration (e.g., `comparator`, `toElementFn`).
-     * @throws {TypeError} Thrown when using the default comparator with object elements (provide a custom comparator).
-     * @remarks Complexity — Time: O(n log n) when inserting n elements incrementally; Space: O(n).
-     */
-    constructor(elements?: Iterable<E> | Iterable<R>, options?: PriorityQueueOptions<E, R>);
-}

package/dist/esm/data-structures/priority-queue/max-priority-queue.js

@@ -1,34 +0,0 @@
-import { PriorityQueue } from './priority-queue';
-/**
- * Max-oriented priority queue (max-heap) built on {@link PriorityQueue}.
- * The default comparator orders primitive values in descending order. If you store objects,
- * you must provide a custom comparator via {@link PriorityQueueOptions}.
- * @template E Element type stored in the queue.
- * @template R Extra record/metadata associated with each element.
- * @example
- */
-export class MaxPriorityQueue extends PriorityQueue {
-    /**
-     * Creates a max-priority queue.
-     * @param elements Optional initial elements to insert.
-     * @param options Optional configuration (e.g., `comparator`, `toElementFn`).
-     * @throws {TypeError} Thrown when using the default comparator with object elements (provide a custom comparator).
-     * @remarks Complexity — Time: O(n log n) when inserting n elements incrementally; Space: O(n).
-     */
-    constructor(elements = [], options) {
-        super(elements, {
-            comparator: (a, b) => {
-                if (typeof a === 'object' || typeof b === 'object') {
-                    throw TypeError(`When comparing object types, a custom comparator must be defined in the constructor's options parameter.`);
-                }
-                if (a < b)
-                    return 1;
-                if (a > b)
-                    return -1;
-                return 0;
-            },
-            ...options
-        });
-    }
-}
-//# sourceMappingURL=max-priority-queue.js.map

package/dist/esm/data-structures/priority-queue/max-priority-queue.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"max-priority-queue.js","sourceRoot":"","sources":["../../../../src/data-structures/priority-queue/max-priority-queue.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEjD;;;;;;;GAOG;AACH,MAAM,OAAO,gBAAmC,SAAQ,aAAmB;IACzE;;;;;;OAMG;IACH,YAAY,WAAsC,EAAE,EAAE,OAAoC;QACxF,KAAK,CAAC,QAAQ,EAAE;YACd,UAAU,EAAE,CAAC,CAAI,EAAE,CAAI,EAAU,EAAE;gBACjC,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,OAAO,CAAC,KAAK,QAAQ,EAAE,CAAC;oBACnD,MAAM,SAAS,CACb,0GAA0G,CAC3G,CAAC;gBACJ,CAAC;gBACD,IAAI,CAAC,GAAG,CAAC;oBAAE,OAAO,CAAC,CAAC;gBACpB,IAAI,CAAC,GAAG,CAAC;oBAAE,OAAO,CAAC,CAAC,CAAC;gBACrB,OAAO,CAAC,CAAC;YACX,CAAC;YACD,GAAG,OAAO;SACX,CAAC,CAAC;IACL,CAAC;CACF"}

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

@@ -1,26 +0,0 @@
-/**
- * data-structure-typed
- *
- * @author Kirk Qi
- * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
- * @license MIT License
- */
-import type { PriorityQueueOptions } from '../../types';
-import { PriorityQueue } from './priority-queue';
-/**
- * Min-oriented priority queue (min-heap) built on {@link PriorityQueue}.
- * The queue removes the smallest element first under the provided comparator.
- * Provide a custom comparator if you store non-primitive objects.
- * @template E Element type stored in the queue.
- * @template R Extra record/metadata associated with each element.
- * @example
- */
-export declare class MinPriorityQueue<E = any, R = any> extends PriorityQueue<E, R> {
-    /**
-     * Creates a min-priority queue.
-     * @param elements Optional initial elements to insert.
-     * @param options Optional configuration (e.g., `comparator`, `toElementFn`).
-     * @remarks Complexity — Time: O(n log n) when inserting n elements incrementally; Space: O(n).
-     */
-    constructor(elements?: Iterable<E> | Iterable<R>, options?: PriorityQueueOptions<E, R>);
-}

package/dist/esm/data-structures/priority-queue/min-priority-queue.js

@@ -1,21 +0,0 @@
-import { PriorityQueue } from './priority-queue';
-/**
- * Min-oriented priority queue (min-heap) built on {@link PriorityQueue}.
- * The queue removes the smallest element first under the provided comparator.
- * Provide a custom comparator if you store non-primitive objects.
- * @template E Element type stored in the queue.
- * @template R Extra record/metadata associated with each element.
- * @example
- */
-export class MinPriorityQueue extends PriorityQueue {
-    /**
-     * Creates a min-priority queue.
-     * @param elements Optional initial elements to insert.
-     * @param options Optional configuration (e.g., `comparator`, `toElementFn`).
-     * @remarks Complexity — Time: O(n log n) when inserting n elements incrementally; Space: O(n).
-     */
-    constructor(elements = [], options) {
-        super(elements, options);
-    }
-}
-//# sourceMappingURL=min-priority-queue.js.map

package/dist/esm/data-structures/priority-queue/min-priority-queue.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"min-priority-queue.js","sourceRoot":"","sources":["../../../../src/data-structures/priority-queue/min-priority-queue.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEjD;;;;;;;GAOG;AACH,MAAM,OAAO,gBAAmC,SAAQ,aAAmB;IACzE;;;;;OAKG;IACH,YAAY,WAAsC,EAAE,EAAE,OAAoC;QACxF,KAAK,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;IAC3B,CAAC;CACF"}

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

@@ -1,15 +0,0 @@
-/**
- * data-structure-typed
- *
- * @author Kirk Qi
- * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
- * @license MIT License
- */
-import type { PriorityQueueOptions } from '../../types';
-import { Heap } from '../heap';
-/**
- * @example
- */
-export declare class PriorityQueue<E = any, R = any> extends Heap<E, R> {
-    constructor(elements?: Iterable<E> | Iterable<R>, options?: PriorityQueueOptions<E, R>);
-}

package/dist/esm/data-structures/priority-queue/priority-queue.js

@@ -1,17 +0,0 @@
-/**
- * data-structure-typed
- *
- * @author Kirk Qi
- * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
- * @license MIT License
- */
-import { Heap } from '../heap';
-/**
- * @example
- */
-export class PriorityQueue extends Heap {
-    constructor(elements = [], options) {
-        super(elements, options);
-    }
-}
-//# sourceMappingURL=priority-queue.js.map

package/dist/esm/data-structures/priority-queue/priority-queue.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"priority-queue.js","sourceRoot":"","sources":["../../../../src/data-structures/priority-queue/priority-queue.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAE/B;;GAEG;AACH,MAAM,OAAO,aAAgC,SAAQ,IAAU;IAC7D,YAAY,WAAsC,EAAE,EAAE,OAAoC;QACxF,KAAK,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;IAC3B,CAAC;CACF"}

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

@@ -1,431 +0,0 @@
-/**
- * data-structure-typed
- *
- * @author Pablo Zeng
- * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-import type { DequeOptions, ElementCallback, IterableElementBaseOptions, IterableWithSizeOrLength, LinearBaseOptions } from '../../types';
-import { LinearBase } from '../base/linear-base';
-/**
- * Deque implemented with circular buckets allowing O(1) amortized push/pop at both ends.
- * @remarks Time O(1), Space O(1)
- * @template E
- * @template R
- * 1. Operations at Both Ends: Supports adding and removing elements at both the front and back of the queue. This allows it to be used as a stack (last in, first out) and a queue (first in, first out).
- * 2. Efficient Random Access: Being based on an array, it offers fast random access capability, allowing constant time access to any element.
- * 3. Continuous Memory Allocation: Since it is based on an array, all elements are stored contiguously in memory, which can bring cache friendliness and efficient memory access.
- * 4. Efficiency: Adding and removing elements at both ends of a deque is usually very fast. However, when the dynamic array needs to expand, it may involve copying the entire array to a larger one, and this operation has a time complexity of O(n).
- * 5. Performance jitter: Deque may experience performance jitter, but DoublyLinkedList will not
- * @example
- * // prize roulette
- *     class PrizeRoulette {
- *       private deque: Deque<string>;
- *
- *       constructor(prizes: string[]) {
- *         // Initialize the deque with prizes
- *         this.deque = new Deque<string>(prizes);
- *       }
- *
- *       // Rotate clockwise to the right (forward)
- *       rotateClockwise(steps: number): void {
- *         const n = this.deque.length;
- *         if (n === 0) return;
- *
- *         for (let i = 0; i < steps; i++) {
- *           const last = this.deque.pop(); // Remove the last element
- *           this.deque.unshift(last!); // Add it to the front
- *         }
- *       }
- *
- *       // Rotate counterclockwise to the left (backward)
- *       rotateCounterClockwise(steps: number): void {
- *         const n = this.deque.length;
- *         if (n === 0) return;
- *
- *         for (let i = 0; i < steps; i++) {
- *           const first = this.deque.shift(); // Remove the first element
- *           this.deque.push(first!); // Add it to the back
- *         }
- *       }
- *
- *       // Display the current prize at the head
- *       display() {
- *         return this.deque.first;
- *       }
- *     }
- *
- *     // Example usage
- *     const prizes = ['Car', 'Bike', 'Laptop', 'Phone', 'Watch', 'Headphones']; // Initialize the prize list
- *     const roulette = new PrizeRoulette(prizes);
- *
- *     // Display the initial state
- *     console.log(roulette.display()); // 'Car' // Car
- *
- *     // Rotate clockwise by 3 steps
- *     roulette.rotateClockwise(3);
- *     console.log(roulette.display()); // 'Phone' // Phone
- *
- *     // Rotate counterclockwise by 2 steps
- *     roulette.rotateCounterClockwise(2);
- *     console.log(roulette.display()); // 'Headphones'
- * @example
- * // sliding window
- *     // Maximum function of sliding window
- *     function maxSlidingWindow(nums: number[], k: number): number[] {
- *       const n = nums.length;
- *       if (n * k === 0) return [];
- *
- *       const deq = new Deque<number>();
- *       const result: number[] = [];
- *
- *       for (let i = 0; i < n; i++) {
- *         // Delete indexes in the queue that are not within the window range
- *         if (deq.length > 0 && deq.first! === i - k) {
- *           deq.shift();
- *         }
- *
- *         // Remove all indices less than the current value from the tail of the queue
- *         while (deq.length > 0 && nums[deq.last!] < nums[i]) {
- *           deq.pop();
- *         }
- *
- *         // Add the current index to the end of the queue
- *         deq.push(i);
- *
- *         // Add the maximum value of the window to the results
- *         if (i >= k - 1) {
- *           result.push(nums[deq.first!]);
- *         }
- *       }
- *
- *       return result;
- *     }
- *
- *     const nums = [1, 3, -1, -3, 5, 3, 6, 7];
- *     const k = 3;
- *     console.log(maxSlidingWindow(nums, k)); // [3, 3, 5, 5, 6, 7]
- */
-export declare class Deque<E = any, R = any> extends LinearBase<E, R> {
-    protected _equals: (a: E, b: E) => boolean;
-    /**
-     * Create a Deque and optionally bulk-insert elements.
-     * @remarks Time O(N), Space O(N)
-     * @param [elements] - Iterable (or iterable-like) of elements/records to insert.
-     * @param [options] - Options such as bucketSize, toElementFn, and maxLen.
-     * @returns New Deque instance.
-     */
-    constructor(elements?: IterableWithSizeOrLength<E> | IterableWithSizeOrLength<R>, options?: DequeOptions<E, R>);
-    protected _bucketSize: number;
-    /**
-     * Get the current bucket size.
-     * @remarks Time O(1), Space O(1)
-     * @returns Bucket capacity per bucket.
-     */
-    get bucketSize(): number;
-    protected _bucketFirst: number;
-    /**
-     * Get the index of the first bucket in use.
-     * @remarks Time O(1), Space O(1)
-     * @returns Zero-based bucket index.
-     */
-    get bucketFirst(): number;
-    protected _firstInBucket: number;
-    /**
-     * Get the index inside the first bucket.
-     * @remarks Time O(1), Space O(1)
-     * @returns Zero-based index within the first bucket.
-     */
-    get firstInBucket(): number;
-    protected _bucketLast: number;
-    /**
-     * Get the index of the last bucket in use.
-     * @remarks Time O(1), Space O(1)
-     * @returns Zero-based bucket index.
-     */
-    get bucketLast(): number;
-    protected _lastInBucket: number;
-    /**
-     * Get the index inside the last bucket.
-     * @remarks Time O(1), Space O(1)
-     * @returns Zero-based index within the last bucket.
-     */
-    get lastInBucket(): number;
-    protected _bucketCount: number;
-    /**
-     * Get the number of buckets allocated.
-     * @remarks Time O(1), Space O(1)
-     * @returns Bucket count.
-     */
-    get bucketCount(): number;
-    protected _buckets: E[][];
-    /**
-     * Get the internal buckets array.
-     * @remarks Time O(1), Space O(1)
-     * @returns Array of buckets storing values.
-     */
-    get buckets(): E[][];
-    protected _length: number;
-    /**
-     * Get the number of elements in the deque.
-     * @remarks Time O(1), Space O(1)
-     * @returns Current length.
-     */
-    get length(): number;
-    /**
-     * Get the first element without removing it.
-     * @remarks Time O(1), Space O(1)
-     * @returns First element or undefined.
-     */
-    get first(): E | undefined;
-    /**
-     * Get the last element without removing it.
-     * @remarks Time O(1), Space O(1)
-     * @returns Last element or undefined.
-     */
-    get last(): E | undefined;
-    /**
-     * Create a Deque from an array of elements.
-     * @remarks Time O(N), Space O(N)
-     * @template E
-     * @template R
-     * @param this - Constructor (subclass) to instantiate.
-     * @param data - Array of elements to insert in order.
-     * @param [options] - Options forwarded to the constructor.
-     * @returns A new Deque populated from the array.
-     */
-    static fromArray<E, R = any>(this: new (elements?: IterableWithSizeOrLength<E> | IterableWithSizeOrLength<R>, options?: DequeOptions<E, R>) => any, data: E[], options?: DequeOptions<E, R>): any;
-    /**
-     * Append one element at the back.
-     * @remarks Time O(1) amortized, Space O(1)
-     * @param element - Element to append.
-     * @returns True when appended.
-     */
-    push(element: E): boolean;
-    /**
-     * Remove and return the last element.
-     * @remarks Time O(1), Space O(1)
-     * @returns Removed element or undefined.
-     */
-    pop(): E | undefined;
-    /**
-     * Remove and return the first element.
-     * @remarks Time O(1) amortized, Space O(1)
-     * @returns Removed element or undefined.
-     */
-    shift(): E | undefined;
-    /**
-     * Prepend one element at the front.
-     * @remarks Time O(1) amortized, Space O(1)
-     * @param element - Element to prepend.
-     * @returns True when prepended.
-     */
-    unshift(element: E): boolean;
-    /**
-     * Append a sequence of elements.
-     * @remarks Time O(N), Space O(1)
-     * @param elements - Iterable (or iterable-like) of elements/records.
-     * @returns Array of per-element success flags.
-     */
-    pushMany(elements: IterableWithSizeOrLength<E> | IterableWithSizeOrLength<R>): boolean[];
-    /**
-     * Prepend a sequence of elements.
-     * @remarks Time O(N), Space O(1)
-     * @param [elements] - Iterable (or iterable-like) of elements/records.
-     * @returns Array of per-element success flags.
-     */
-    unshiftMany(elements?: IterableWithSizeOrLength<E> | IterableWithSizeOrLength<R>): boolean[];
-    /**
-     * Check whether the deque is empty.
-     * @remarks Time O(1), Space O(1)
-     * @returns True if length is 0.
-     */
-    isEmpty(): boolean;
-    /**
-     * Remove all elements and reset structure.
-     * @remarks Time O(1), Space O(1)
-     * @returns void
-     */
-    clear(): void;
-    /**
-     * Get the element at a given position.
-     * @remarks Time O(1), Space O(1)
-     * @param pos - Zero-based position from the front.
-     * @returns Element or undefined.
-     */
-    at(pos: number): E | undefined;
-    /**
-     * Replace the element at a given position.
-     * @remarks Time O(1), Space O(1)
-     * @param pos - Zero-based position from the front.
-     * @param element - New element value.
-     * @returns True if updated.
-     */
-    setAt(pos: number, element: E): boolean;
-    /**
-     * Insert repeated copies of an element at a position.
-     * @remarks Time O(N), Space O(1)
-     * @param pos - Zero-based position from the front.
-     * @param element - Element to insert.
-     * @param [num] - Number of times to insert (default 1).
-     * @returns True if inserted.
-     */
-    addAt(pos: number, element: E, num?: number): boolean;
-    /**
-     * Cut the deque to keep items up to index; optionally mutate in-place.
-     * @remarks Time O(N), Space O(1)
-     * @param pos - Last index to keep.
-     * @param [isCutSelf] - When true, mutate this deque; otherwise return a new deque.
-     * @returns This deque if in-place; otherwise a new deque of the prefix.
-     */
-    cut(pos: number, isCutSelf?: boolean): Deque<E>;
-    /**
-     * Remove and/or insert elements at a position (array-like behavior).
-     * @remarks Time O(N + M), Space O(M)
-     * @param start - Start index (clamped to [0, length]).
-     * @param [deleteCount] - Number of elements to remove (default: length - start).
-     * @param [items] - Elements to insert after `start`.
-     * @returns A new deque containing the removed elements (typed as `this`).
-     */
-    splice(start: number, deleteCount?: number, ...items: E[]): this;
-    /**
-     * Cut the deque to keep items from index onward; optionally mutate in-place.
-     * @remarks Time O(N), Space O(1)
-     * @param pos - First index to keep.
-     * @param [isCutSelf] - When true, mutate this deque; otherwise return a new deque.
-     * @returns This deque if in-place; otherwise a new deque of the suffix.
-     */
-    cutRest(pos: number, isCutSelf?: boolean): Deque<E>;
-    /**
-     * Delete the element at a given position.
-     * @remarks Time O(N), Space O(1)
-     * @param pos - Zero-based position from the front.
-     * @returns Removed element or undefined.
-     */
-    deleteAt(pos: number): E | undefined;
-    /**
-     * Delete the first occurrence of a value.
-     * @remarks Time O(N), Space O(1)
-     * @param element - Element to remove (using the configured equality).
-     * @returns True if an element was removed.
-     */
-    delete(element: E): boolean;
-    /**
-     * Delete the first element matching a predicate.
-     * @remarks Time O(N), Space O(1)
-     * @param predicate - Function (value, index, deque) → boolean.
-     * @returns True if a match was removed.
-     */
-    deleteWhere(predicate: (value: E, index: number, deque: this) => boolean): boolean;
-    /**
-     * Set the equality comparator used by delete operations.
-     * @remarks Time O(1), Space O(1)
-     * @param equals - Equality predicate (a, b) → boolean.
-     * @returns This deque.
-     */
-    setEquality(equals: (a: E, b: E) => boolean): this;
-    /**
-     * Reverse the deque by reversing buckets and pointers.
-     * @remarks Time O(N), Space O(N)
-     * @returns This deque.
-     */
-    reverse(): this;
-    /**
-     * Deduplicate consecutive equal elements in-place.
-     * @remarks Time O(N), Space O(1)
-     * @returns This deque.
-     */
-    unique(): this;
-    /**
-     * Trim unused buckets to fit exactly the active range.
-     * @remarks Time O(N), Space O(1)
-     * @returns void
-     */
-    shrinkToFit(): void;
-    /**
-     * Deep clone this deque, preserving options.
-     * @remarks Time O(N), Space O(N)
-     * @returns A new deque with the same content and options.
-     */
-    clone(): this;
-    /**
-     * Filter elements into a new deque of the same class.
-     * @remarks Time O(N), Space O(N)
-     * @param predicate - Predicate (value, index, deque) → boolean to keep element.
-     * @param [thisArg] - Value for `this` inside the predicate.
-     * @returns A new deque with kept elements.
-     */
-    filter(predicate: ElementCallback<E, R, boolean>, thisArg?: any): this;
-    /**
-     * Map elements into a new deque of the same element type.
-     * @remarks Time O(N), Space O(N)
-     * @param callback - Mapping function (value, index, deque) → newValue.
-     * @param [thisArg] - Value for `this` inside the callback.
-     * @returns A new deque with mapped values.
-     */
-    mapSame(callback: ElementCallback<E, R, E>, thisArg?: any): this;
-    /**
-     * Map elements into a new deque (possibly different element type).
-     * @remarks Time O(N), Space O(N)
-     * @template EM
-     * @template RM
-     * @param callback - Mapping function (value, index, deque) → newElement.
-     * @param [options] - Options for the output deque (e.g., bucketSize, toElementFn, maxLen).
-     * @param [thisArg] - Value for `this` inside the callback.
-     * @returns A new Deque with mapped elements.
-     */
-    map<EM, RM>(callback: ElementCallback<E, R, EM>, options?: IterableElementBaseOptions<EM, RM>, thisArg?: any): Deque<EM, RM>;
-    /**
-     * (Protected) Set the internal bucket size.
-     * @remarks Time O(1), Space O(1)
-     * @param size - Bucket capacity to assign.
-     * @returns void
-     */
-    protected _setBucketSize(size: number): void;
-    /**
-     * (Protected) Iterate elements from front to back.
-     * @remarks Time O(N), Space O(1)
-     * @returns Iterator of elements.
-     */
-    protected _getIterator(): IterableIterator<E>;
-    /**
-     * (Protected) Reallocate buckets to make room near the ends.
-     * @remarks Time O(N), Space O(N)
-     * @param [needBucketNum] - How many extra buckets to add; defaults to half of current.
-     * @returns void
-     */
-    protected _reallocate(needBucketNum?: number): void;
-    /**
-     * (Protected) Translate a logical position to bucket/offset.
-     * @remarks Time O(1), Space O(1)
-     * @param pos - Zero-based position.
-     * @returns An object containing bucketIndex and indexInBucket.
-     */
-    protected _getBucketAndPosition(pos: number): {
-        bucketIndex: number;
-        indexInBucket: number;
-    };
-    /**
-     * (Protected) Create an empty instance of the same concrete class.
-     * @remarks Time O(1), Space O(1)
-     * @param [options] - Options forwarded to the constructor.
-     * @returns An empty like-kind deque instance.
-     */
-    protected _createInstance(options?: LinearBaseOptions<E, R>): this;
-    /**
-     * (Protected) Create a like-kind deque seeded by elements.
-     * @remarks Time O(N), Space O(N)
-     * @template T
-     * @template RR
-     * @param [elements] - Iterable used to seed the new deque.
-     * @param [options] - Options forwarded to the constructor.
-     * @returns A like-kind Deque instance.
-     */
-    protected _createLike<T = E, RR = R>(elements?: IterableWithSizeOrLength<T> | IterableWithSizeOrLength<RR>, options?: DequeOptions<T, RR>): any;
-    /**
-     * (Protected) Iterate elements from back to front.
-     * @remarks Time O(N), Space O(1)
-     * @returns Iterator of elements.
-     */
-    protected _getReverseIterator(): IterableIterator<E>;
-}