binary-tree-typed 2.5.0 → 2.5.2

package/src/data-structures/queue/deque.ts

@@ -260,6 +260,30 @@ export class Deque<E = any, R = any> extends LinearBase<E, R> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Deque peek at both ends
  *  const deque = new Deque<number>([10, 20, 30, 40, 50]);
@@ -296,6 +320,30 @@ export class Deque<E = any, R = any> extends LinearBase<E, R> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Peek at the back element
  *  const dq = new Deque<string>(['a', 'b', 'c']);
@@ -346,6 +394,30 @@ export class Deque<E = any, R = any> extends LinearBase<E, R> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // basic Deque creation and push/pop operations
  *  // Create a simple Deque with initial values
@@ -400,6 +472,30 @@ export class Deque<E = any, R = any> extends LinearBase<E, R> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Remove from the back
  *  const dq = new Deque<number>([1, 2, 3]);
@@ -441,6 +537,30 @@ export class Deque<E = any, R = any> extends LinearBase<E, R> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Remove from the front
  *  const dq = new Deque<number>([1, 2, 3]);
@@ -483,6 +603,30 @@ export class Deque<E = any, R = any> extends LinearBase<E, R> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Deque shift and unshift operations
  *  const deque = new Deque<number>([20, 30, 40]);
@@ -570,6 +714,30 @@ export class Deque<E = any, R = any> extends LinearBase<E, R> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Check if empty
  *  const dq = new Deque();
@@ -593,6 +761,30 @@ export class Deque<E = any, R = any> extends LinearBase<E, R> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Remove all elements
  *  const dq = new Deque<number>([1, 2, 3]);
@@ -620,6 +812,30 @@ export class Deque<E = any, R = any> extends LinearBase<E, R> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Access by index
  *  const dq = new Deque<string>(['a', 'b', 'c']);
@@ -820,6 +1036,30 @@ export class Deque<E = any, R = any> extends LinearBase<E, R> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Remove element
  *  const dq = new Deque<number>([1, 2, 3]);
@@ -889,6 +1129,30 @@ export class Deque<E = any, R = any> extends LinearBase<E, R> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Deque for...of iteration and reverse
  *  const deque = new Deque<string>(['A', 'B', 'C', 'D']);
@@ -985,6 +1249,30 @@ export class Deque<E = any, R = any> extends LinearBase<E, R> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Reclaim memory
  *  const dq = new Deque<number>([1, 2, 3, 4, 5]);
@@ -1034,6 +1322,30 @@ export class Deque<E = any, R = any> extends LinearBase<E, R> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Create independent copy
  *  const dq = new Deque<number>([1, 2, 3]);
@@ -1066,6 +1378,30 @@ export class Deque<E = any, R = any> extends LinearBase<E, R> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Filter elements
  *  const dq = new Deque<number>([1, 2, 3, 4]);
@@ -1073,7 +1409,7 @@ export class Deque<E = any, R = any> extends LinearBase<E, R> {
  *     console.log(result.length); // 2;
    */
 
-  filter(predicate: ElementCallback<E, R, boolean>, thisArg?: any): this {
+  filter(predicate: ElementCallback<E, R, boolean>, thisArg?: unknown): this {
     const out = this._createInstance({ toElementFn: this.toElementFn, maxLen: this._maxLen });
     out._setBucketSize(this._bucketSize);
     let index = 0;
@@ -1092,7 +1428,7 @@ export class Deque<E = any, R = any> extends LinearBase<E, R> {
    * @returns A new deque with mapped values.
    */
 
-  mapSame(callback: ElementCallback<E, R, E>, thisArg?: any): this {
+  mapSame(callback: ElementCallback<E, R, E>, thisArg?: unknown): this {
     const out = this._createInstance({ toElementFn: this._toElementFn, maxLen: this._maxLen });
     out._setBucketSize(this._bucketSize);
     let index = 0;
@@ -1120,6 +1456,30 @@ export class Deque<E = any, R = any> extends LinearBase<E, R> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Transform elements
  *  const dq = new Deque<number>([1, 2, 3]);
@@ -1130,7 +1490,7 @@ export class Deque<E = any, R = any> extends LinearBase<E, R> {
   map<EM, RM>(
     callback: ElementCallback<E, R, EM>,
     options?: IterableElementBaseOptions<EM, RM>,
-    thisArg?: any
+    thisArg?: unknown
   ): Deque<EM, RM> {
     const out = this._createLike<EM, RM>([], {
       ...(options ?? {}),
@@ -1263,11 +1623,11 @@ export class Deque<E = any, R = any> extends LinearBase<E, R> {
   protected _createLike<T = E, RR = R>(
     elements: IterableWithSizeOrLength<T> | IterableWithSizeOrLength<RR> = [],
     options?: DequeOptions<T, RR>
-  ): any {
+  ): Deque<T, RR> {
     const Ctor = this.constructor as new (
       elements?: IterableWithSizeOrLength<T> | IterableWithSizeOrLength<RR>,
       options?: DequeOptions<T, RR>
-    ) => any;
+    ) => Deque<T, RR>;
     return new Ctor(elements, options);
   }