data-structure-typed 2.6.0 → 2.6.1

package/src/data-structures/linked-list/skip-linked-list.ts

@@ -5,7 +5,6 @@
  * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-
 import type { Comparator, EntryCallback } from '../../types';
 import { ERR, raise } from '../../common';
 import { IterableEntryBase } from '../base';
@@ -28,13 +27,11 @@ export type SkipListOptions<K, V, R = [K, V]> = {
   maxLevel?: number;
   probability?: number;
 };
-
 export type SkipListRangeOptions = {
   lowInclusive?: boolean;
   highInclusive?: boolean;
 };
 
-
 /**
  * SkipList — a probabilistic sorted key-value container.
  *
@@ -47,24 +44,20 @@ export type SkipListRangeOptions = {
  *     expect(() => sl.print()).not.toThrow();
  */
 export class SkipList<K = any, V = any, R = [K, V]> extends IterableEntryBase<K, V | undefined> {
+  // ─── Internal state ──────────────────────────────────────────
+  protected _head: SkipListNode<K, V>;
+  protected _level: number = 0;
   readonly #comparator: Comparator<K>;
   readonly #isDefaultComparator: boolean;
 
-  constructor(
-    entries: Iterable<R> | Iterable<[K, V | undefined]> = [],
-    options: SkipListOptions<K, V, R> = {}
-  ) {
+  constructor(entries: Iterable<R> | Iterable<[K, V | undefined]> = [], options: SkipListOptions<K, V, R> = {}) {
     super();
     const { comparator, toEntryFn, maxLevel, probability } = options;
-
     if (typeof maxLevel === 'number' && maxLevel > 0) this._maxLevel = maxLevel;
     if (typeof probability === 'number' && probability > 0 && probability < 1) this._probability = probability;
-
     this.#isDefaultComparator = comparator === undefined;
     this.#comparator = comparator ?? SkipList.createDefaultComparator<K>();
-
     this._head = new SkipListNode<K, V>(undefined as K, undefined as V, this._maxLevel);
-
     for (const item of entries) {
       let k: K;
       let v: V | undefined;
@@ -80,6 +73,29 @@ export class SkipList<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
     }
   }
 
+  protected _size: number = 0;
+
+  // ─── Size & lifecycle ────────────────────────────────────────
+  get size(): number {
+    return this._size;
+  }
+
+  protected _maxLevel: number = 16;
+
+  get maxLevel(): number {
+    return this._maxLevel;
+  }
+
+  protected _probability: number = 0.5;
+
+  get probability(): number {
+    return this._probability;
+  }
+
+  get comparator(): Comparator<K> {
+    return this.#comparator;
+  }
+
   /**
    * Creates a default comparator supporting number, string, Date, and bigint.
    */
@@ -105,132 +121,27 @@ export class SkipList<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
     };
   }
 
-  // ─── Internal state ──────────────────────────────────────────
-
-  protected _head: SkipListNode<K, V>;
-
-  protected _level: number = 0;
-
-  protected _size: number = 0;
-
-  protected _maxLevel: number = 16;
-
-  protected _probability: number = 0.5;
-
-  // ─── Size & lifecycle ────────────────────────────────────────
-
-  get size(): number {
-    return this._size;
-  }
-
-  get maxLevel(): number {
-    return this._maxLevel;
-  }
-
-  get probability(): number {
-    return this._probability;
-  }
-
-  get comparator(): Comparator<K> {
-    return this.#comparator;
-  }
-
-    /**
+  /**
    * Check if empty
-  
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Check if empty
- *  const sl = new SkipList<number, string>();
- *     console.log(sl.isEmpty()); // true;
+   * @example
+   * // Check if empty
+   *  const sl = new SkipList<number, string>();
+   *     console.log(sl.isEmpty()); // true;
    */
   isEmpty(): boolean {
     return this._size === 0;
   }
 
-    /**
+  /**
    * Remove all entries
-  
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Remove all entries
- *  const sl = new SkipList<number, string>([[1, 'a'], [2, 'b']]);
- *     sl.clear();
- *     console.log(sl.isEmpty()); // true;
+   * @example
+   * // Remove all entries
+   *  const sl = new SkipList<number, string>([
+   *       [1, 'a'],
+   *       [2, 'b']
+   *     ]);
+   *     sl.clear();
+   *     console.log(sl.isEmpty()); // true;
    */
   clear(): void {
     this._head = new SkipListNode<K, V>(undefined as K, undefined as V, this._maxLevel);
@@ -238,53 +149,17 @@ export class SkipList<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
     this._size = 0;
   }
 
-    /**
+  /**
    * Create independent copy
-  
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Create independent copy
- *  const sl = new SkipList<number, string>([[1, 'a'], [2, 'b']]);
- *     const copy = sl.clone();
- *     copy.delete(1);
- *     console.log(sl.has(1)); // true;
+   * @example
+   * // Create independent copy
+   *  const sl = new SkipList<number, string>([
+   *       [1, 'a'],
+   *       [2, 'b']
+   *     ]);
+   *     const copy = sl.clone();
+   *     copy.delete(1);
+   *     console.log(sl.has(1)); // true;
    */
   clone(): this {
     return new SkipList<K, V, R>(this as Iterable<[K, V | undefined]>, {
@@ -299,91 +174,44 @@ export class SkipList<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
   /**
    * Insert or update a key-value pair. Returns `this` for chaining.
    * Unique keys only — if key exists, value is updated in place.
-  
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // In-memory sorted key-value store
- *  const store = new SkipList<number, string>();
- *
- *     store.set(3, 'three');
- *     store.set(1, 'one');
- *     store.set(5, 'five');
- *     store.set(2, 'two');
- *
- *     console.log(store.get(3)); // 'three';
- *     console.log(store.get(1)); // 'one';
- *     console.log(store.get(5)); // 'five';
- *
- *     // Update existing key
- *     store.set(3, 'THREE');
- *     console.log(store.get(3)); // 'THREE';
+   * @example
+   * // In-memory sorted key-value store
+   *  const store = new SkipList<number, string>();
+   *
+   *     store.set(3, 'three');
+   *     store.set(1, 'one');
+   *     store.set(5, 'five');
+   *     store.set(2, 'two');
+   *
+   *     console.log(store.get(3)); // 'three';
+   *     console.log(store.get(1)); // 'one';
+   *     console.log(store.get(5)); // 'five';
+   *
+   *     // Update existing key
+   *     store.set(3, 'THREE');
+   *     console.log(store.get(3)); // 'THREE';
    */
   set(key: K, value: V): this {
     const cmp = this.#comparator;
     const update = this._findUpdate(key);
-
     // If key already exists, update value in place
     const existing = update[0].forward[0];
     if (existing && cmp(existing.key, key) === 0) {
       existing.value = value;
       return this;
     }
-
     const newLevel = this._randomLevel();
     const newNode = new SkipListNode(key, value, newLevel);
-
     if (newLevel > this._level) {
       for (let i = this._level; i < newLevel; i++) {
         update[i] = this._head;
       }
       this._level = newLevel;
     }
-
     for (let i = 0; i < newLevel; i++) {
       newNode.forward[i] = update[i].forward[i];
       update[i].forward[i] = newNode;
     }
-
     this._size++;
     return this;
   }
@@ -391,68 +219,26 @@ export class SkipList<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
   /**
    * Get the value for a key, or `undefined` if not found.
    * Overrides base O(n) with O(log n) skip-list search.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Building a sorted index
- *  type Product = { id: number; name: string; price: number };
- *     const products: Product[] = [
- *       { id: 1, name: 'Widget', price: 25 },
- *       { id: 2, name: 'Gadget', price: 50 },
- *       { id: 3, name: 'Doohickey', price: 15 }
- *     ];
- *
- *     const index = new SkipList<number, Product, Product>(products, {
- *       toEntryFn: (p: Product) => [p.price, p]
- *     });
- *
- *     // Iterate in sorted order by price
- *     const names = [...index.values()].map(p => p!.name);
- *     console.log(names); // ['Doohickey', 'Widget', 'Gadget'];
- *
- *     // Range search: products between $20 and $60
- *     const range = index.rangeSearch([20, 60]);
- *     console.log(range.map(([, p]) => p!.name)); // ['Widget', 'Gadget'];
+   * @example
+   * // Building a sorted index
+   *  type Product = { id: number; name: string; price: number };
+   *     const products: Product[] = [
+   *       { id: 1, name: 'Widget', price: 25 },
+   *       { id: 2, name: 'Gadget', price: 50 },
+   *       { id: 3, name: 'Doohickey', price: 15 }
+   *     ];
+   *
+   *     const index = new SkipList<number, Product, Product>(products, {
+   *       toEntryFn: (p: Product) => [p.price, p]
+   *     });
+   *
+   *     // Iterate in sorted order by price
+   *     const names = [...index.values()].map(p => p!.name);
+   *     console.log(names); // ['Doohickey', 'Widget', 'Gadget'];
+   *
+   *     // Range search: products between $20 and $60
+   *     const range = index.rangeSearch([20, 60]);
+   *     console.log(range.map(([, p]) => p!.name)); // ['Widget', 'Gadget'];
    */
   override get(key: K): V | undefined {
     const node = this._findNode(key);
@@ -462,53 +248,15 @@ export class SkipList<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
   /**
    * Check if a key exists.
    * Overrides base O(n) with O(log n) skip-list search.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Check key existence
- *  const sl = new SkipList<number, string>([[1, 'a'], [3, 'c'], [5, 'e']]);
- *     console.log(sl.has(3)); // true;
- *     console.log(sl.has(4)); // false;
+   * @example
+   * // Check key existence
+   *  const sl = new SkipList<number, string>([
+   *       [1, 'a'],
+   *       [3, 'c'],
+   *       [5, 'e']
+   *     ]);
+   *     console.log(sl.has(3)); // true;
+   *     console.log(sl.has(4)); // false;
    */
   override has(key: K): boolean {
     return this._findNode(key) !== undefined;
@@ -516,77 +264,31 @@ export class SkipList<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
 
   /**
    * Delete a key. Returns `true` if the key was found and removed.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Fast lookup with deletion
- *  const cache = new SkipList<string, number>();
- *
- *     cache.set('alpha', 1);
- *     cache.set('beta', 2);
- *     cache.set('gamma', 3);
- *
- *     console.log(cache.has('beta')); // true;
- *     cache.delete('beta');
- *     console.log(cache.has('beta')); // false;
- *     console.log(cache.size); // 2;
+   * @example
+   * // Fast lookup with deletion
+   *  const cache = new SkipList<string, number>();
+   *
+   *     cache.set('alpha', 1);
+   *     cache.set('beta', 2);
+   *     cache.set('gamma', 3);
+   *
+   *     console.log(cache.has('beta')); // true;
+   *     cache.delete('beta');
+   *     console.log(cache.has('beta')); // false;
+   *     console.log(cache.size); // 2;
    */
   delete(key: K): boolean {
     const cmp = this.#comparator;
     const update = this._findUpdate(key);
-
     const target = update[0].forward[0];
     if (!target || cmp(target.key, key) !== 0) return false;
-
     for (let i = 0; i < this._level; i++) {
       if (update[i].forward[i] !== target) break;
       update[i].forward[i] = target.forward[i];
     }
-
     while (this._level > 0 && !this._head.forward[this._level - 1]) {
       this._level--;
     }
-
     this._size--;
     return true;
   }
@@ -595,52 +297,14 @@ export class SkipList<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
 
   /**
    * Returns the first (smallest key) entry, or `undefined` if empty.
-  
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Access the minimum entry
- *  const sl = new SkipList<number, string>([[5, 'e'], [1, 'a'], [3, 'c']]);
- *     console.log(sl.first()); // [1, 'a'];
+   * @example
+   * // Access the minimum entry
+   *  const sl = new SkipList<number, string>([
+   *       [5, 'e'],
+   *       [1, 'a'],
+   *       [3, 'c']
+   *     ]);
+   *     console.log(sl.first()); // [1, 'a'];
    */
   first(): [K, V | undefined] | undefined {
     const node = this._head.forward[0];
@@ -649,52 +313,14 @@ export class SkipList<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
 
   /**
    * Returns the last (largest key) entry, or `undefined` if empty.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Access the maximum entry
- *  const sl = new SkipList<number, string>([[5, 'e'], [1, 'a'], [3, 'c']]);
- *     console.log(sl.last()); // [5, 'e'];
+   * @example
+   * // Access the maximum entry
+   *  const sl = new SkipList<number, string>([
+   *       [5, 'e'],
+   *       [1, 'a'],
+   *       [3, 'c']
+   *     ]);
+   *     console.log(sl.last()); // [5, 'e'];
    */
   last(): [K, V | undefined] | undefined {
     let current = this._head;
@@ -708,50 +334,15 @@ export class SkipList<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
 
   /**
    * Remove and return the first (smallest key) entry.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Remove and return smallest
- *  const sl = new SkipList<number, string>([[1, 'a'], [2, 'b'], [3, 'c']]);
- *     console.log(sl.pollFirst()); // [1, 'a'];
- *     console.log(sl.size); // 2;
+   * @example
+   * // Remove and return smallest
+   *  const sl = new SkipList<number, string>([
+   *       [1, 'a'],
+   *       [2, 'b'],
+   *       [3, 'c']
+   *     ]);
+   *     console.log(sl.pollFirst()); // [1, 'a'];
+   *     console.log(sl.size); // 2;
    */
   pollFirst(): [K, V | undefined] | undefined {
     const entry = this.first();
@@ -762,50 +353,15 @@ export class SkipList<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
 
   /**
    * Remove and return the last (largest key) entry.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Remove and return largest
- *  const sl = new SkipList<number, string>([[1, 'a'], [2, 'b'], [3, 'c']]);
- *     console.log(sl.pollLast()); // [3, 'c'];
- *     console.log(sl.size); // 2;
+   * @example
+   * // Remove and return largest
+   *  const sl = new SkipList<number, string>([
+   *       [1, 'a'],
+   *       [2, 'b'],
+   *       [3, 'c']
+   *     ]);
+   *     console.log(sl.pollLast()); // [3, 'c'];
+   *     console.log(sl.size); // 2;
    */
   pollLast(): [K, V | undefined] | undefined {
     const entry = this.last();
@@ -816,53 +372,15 @@ export class SkipList<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
 
   /**
    * Least entry ≥ key, or `undefined`.
-  
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Least entry ≥ key
- *  const sl = new SkipList<number, string>([[10, 'a'], [20, 'b'], [30, 'c']]);
- *     console.log(sl.ceiling(15)); // [20, 'b'];
- *     console.log(sl.ceiling(20)); // [20, 'b'];
+   * @example
+   * // Least entry ≥ key
+   *  const sl = new SkipList<number, string>([
+   *       [10, 'a'],
+   *       [20, 'b'],
+   *       [30, 'c']
+   *     ]);
+   *     console.log(sl.ceiling(15)); // [20, 'b'];
+   *     console.log(sl.ceiling(20)); // [20, 'b'];
    */
   ceiling(key: K): [K, V | undefined] | undefined {
     const cmp = this.#comparator;
@@ -878,53 +396,15 @@ export class SkipList<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
 
   /**
    * Greatest entry ≤ key, or `undefined`.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Greatest entry ≤ key
- *  const sl = new SkipList<number, string>([[10, 'a'], [20, 'b'], [30, 'c']]);
- *     console.log(sl.floor(25)); // [20, 'b'];
- *     console.log(sl.floor(5)); // undefined;
+   * @example
+   * // Greatest entry ≤ key
+   *  const sl = new SkipList<number, string>([
+   *       [10, 'a'],
+   *       [20, 'b'],
+   *       [30, 'c']
+   *     ]);
+   *     console.log(sl.floor(25)); // [20, 'b'];
+   *     console.log(sl.floor(5)); // undefined;
    */
   floor(key: K): [K, V | undefined] | undefined {
     const cmp = this.#comparator;
@@ -935,7 +415,6 @@ export class SkipList<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
       }
     }
     const result = current === this._head ? undefined : current;
-
     // Check if we're exactly at or before key
     if (result && cmp(result.key, key) <= 0) return [result.key, result.value];
     return undefined;
@@ -943,50 +422,15 @@ export class SkipList<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
 
   /**
    * Least entry strictly > key, or `undefined`.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Strictly greater entry
- *  const sl = new SkipList<number, string>([[10, 'a'], [20, 'b'], [30, 'c']]);
- *     console.log(sl.higher(15)); // [20, 'b'];
- *     console.log(sl.higher(30)); // undefined;
+   * @example
+   * // Strictly greater entry
+   *  const sl = new SkipList<number, string>([
+   *       [10, 'a'],
+   *       [20, 'b'],
+   *       [30, 'c']
+   *     ]);
+   *     console.log(sl.higher(15)); // [20, 'b'];
+   *     console.log(sl.higher(30)); // undefined;
    */
   higher(key: K): [K, V | undefined] | undefined {
     const cmp = this.#comparator;
@@ -1002,50 +446,15 @@ export class SkipList<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
 
   /**
    * Greatest entry strictly < key, or `undefined`.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Strictly less entry
- *  const sl = new SkipList<number, string>([[10, 'a'], [20, 'b'], [30, 'c']]);
- *     console.log(sl.lower(25)); // [20, 'b'];
- *     console.log(sl.lower(10)); // undefined;
+   * @example
+   * // Strictly less entry
+   *  const sl = new SkipList<number, string>([
+   *       [10, 'a'],
+   *       [20, 'b'],
+   *       [30, 'c']
+   *     ]);
+   *     console.log(sl.lower(25)); // [20, 'b'];
+   *     console.log(sl.lower(10)); // undefined;
    */
   lower(key: K): [K, V | undefined] | undefined {
     const cmp = this.#comparator;
@@ -1064,60 +473,27 @@ export class SkipList<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
 
   /**
    * Returns entries within the given key range.
-  
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Find entries in a range
- *  const sl = new SkipList<number, string>([[1, 'a'], [2, 'b'], [3, 'c'], [4, 'd'], [5, 'e']]);
- *     const result = sl.rangeSearch([2, 4]);
- *     console.log(result); // [[2, 'b'], [3, 'c'], [4, 'd']];
+   * @example
+   * // Find entries in a range
+   *  const sl = new SkipList<number, string>([
+   *       [1, 'a'],
+   *       [2, 'b'],
+   *       [3, 'c'],
+   *       [4, 'd'],
+   *       [5, 'e']
+   *     ]);
+   *     const result = sl.rangeSearch([2, 4]);
+   *     console.log(result); // [
+   *  //      [2, 'b'],
+   *  //      [3, 'c'],
+   *  //      [4, 'd']
+   *  //    ];
    */
   rangeSearch(range: [K, K], options: SkipListRangeOptions = {}): Array<[K, V | undefined]> {
     const { lowInclusive = true, highInclusive = true } = options;
     const [low, high] = range;
     const cmp = this.#comparator;
     const out: Array<[K, V | undefined]> = [];
-
     // Start from the first node >= low
     let current = this._head;
     for (let i = this._level - 1; i >= 0; i--) {
@@ -1126,20 +502,16 @@ export class SkipList<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
       }
     }
     current = current.forward[0]!;
-
     while (current) {
       const cmpHigh = cmp(current.key, high);
       if (cmpHigh > 0) break;
       if (cmpHigh === 0 && !highInclusive) break;
-
       const cmpLow = cmp(current.key, low);
       if (cmpLow > 0 || (cmpLow === 0 && lowInclusive)) {
         out.push([current.key, current.value]);
       }
-
       current = current.forward[0]!;
     }
-
     return out;
   }
 
@@ -1147,50 +519,14 @@ export class SkipList<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
 
   /**
    * Creates a new SkipList with entries transformed by callback.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Transform entries
- *  const sl = new SkipList<number, string>([[1, 'a'], [2, 'b']]);
- *     const mapped = sl.map((v, k) => [k, v?.toUpperCase()] as [number, string]);
- *     console.log([...mapped.values()]); // ['A', 'B'];
+   * @example
+   * // Transform entries
+   *  const sl = new SkipList<number, string>([
+   *       [1, 'a'],
+   *       [2, 'b']
+   *     ]);
+   *     const mapped = sl.map((v, k) => [k, v?.toUpperCase()] as [number, string]);
+   *     console.log([...mapped.values()]); // ['A', 'B'];
    */
   map<MK, MV>(
     callback: EntryCallback<K, V | undefined, [MK, MV]>,
@@ -1207,55 +543,17 @@ export class SkipList<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
 
   /**
    * Creates a new SkipList with entries that pass the predicate.
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-    * @example
- * // Filter entries
- *  const sl = new SkipList<number, string>([[1, 'a'], [2, 'b'], [3, 'c']]);
- *     const result = sl.filter((v, k) => k > 1);
- *     console.log(result.size); // 2;
+   * @example
+   * // Filter entries
+   *  const sl = new SkipList<number, string>([
+   *       [1, 'a'],
+   *       [2, 'b'],
+   *       [3, 'c']
+   *     ]);
+   *     const result = sl.filter((v, k) => k > 1);
+   *     console.log(result.size); // 2;
    */
-  filter(
-    callbackfn: EntryCallback<K, V | undefined, boolean>,
-    thisArg?: unknown
-  ): this {
+  filter(callbackfn: EntryCallback<K, V | undefined, boolean>, thisArg?: unknown): this {
     const out = new SkipList<K, V, R>([], {
       comparator: this.#isDefaultComparator ? undefined : this.#comparator,
       maxLevel: this._maxLevel,
@@ -1270,7 +568,6 @@ export class SkipList<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
   }
 
   // ─── Iterator (required by IterableEntryBase) ────────────────
-
   protected _getIterator(): IterableIterator<[K, V | undefined]> {
     const head = this._head;
     return (function* () {
@@ -1291,14 +588,12 @@ export class SkipList<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
     const cmp = this.#comparator;
     const update: SkipListNode<K, V>[] = new Array(this._maxLevel).fill(this._head);
     let current = this._head;
-
     for (let i = this._level - 1; i >= 0; i--) {
       while (current.forward[i] && cmp(current.forward[i]!.key, key) < 0) {
         current = current.forward[i]!;
       }
       update[i] = current;
     }
-
     return update;
   }
 
@@ -1308,13 +603,11 @@ export class SkipList<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
   protected _findNode(key: K): SkipListNode<K, V> | undefined {
     const cmp = this.#comparator;
     let current = this._head;
-
     for (let i = this._level - 1; i >= 0; i--) {
       while (current.forward[i] && cmp(current.forward[i]!.key, key) < 0) {
         current = current.forward[i]!;
       }
     }
-
     const candidate = current.forward[0];
     if (candidate && cmp(candidate.key, key) === 0) return candidate;
     return undefined;