linked-list-typed 2.4.4 → 2.5.0

package/dist/cjs-legacy/index.cjs

@@ -1,9 +1,16 @@
 'use strict';
 
 var __defProp = Object.defineProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value), value);
 
 // src/data-structures/base/iterable-element-base.ts
 var _IterableElementBase = class _IterableElementBase {
@@ -721,11 +728,37 @@ var _SinglyLinkedList = class _SinglyLinkedList extends LinearLinkedBase {
     return list;
   }
   /**
-   * Append an element/node to the tail.
-   * @remarks Time O(1), Space O(1)
-   * @param elementOrNode - Element or node to append.
-   * @returns True when appended.
-   */
+    * Append an element/node to the tail.
+    * @remarks Time O(1), Space O(1)
+    * @param elementOrNode - Element or node to append.
+    * @returns True when appended.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // basic SinglyLinkedList creation and push operation
+  *  // Create a simple SinglyLinkedList with initial values
+  *     const list = new SinglyLinkedList([1, 2, 3, 4, 5]);
+  *
+  *     // Verify the list maintains insertion order
+  *     console.log([...list]); // [1, 2, 3, 4, 5];
+  *
+  *     // Check length
+  *     console.log(list.length); // 5;
+  *
+  *     // Push a new element to the end
+  *     list.push(6);
+  *     console.log(list.length); // 6;
+  *     console.log([...list]); // [1, 2, 3, 4, 5, 6];
+    */
   push(elementOrNode) {
     const newNode = this._ensureNode(elementOrNode);
     if (!this.head) {
@@ -739,10 +772,36 @@ var _SinglyLinkedList = class _SinglyLinkedList extends LinearLinkedBase {
     return true;
   }
   /**
-   * Remove and return the tail element.
-   * @remarks Time O(N), Space O(1)
-   * @returns Removed element or undefined.
-   */
+    * Remove and return the tail element.
+    * @remarks Time O(N), Space O(1)
+    * @returns Removed element or undefined.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // SinglyLinkedList pop and shift operations
+  *  const list = new SinglyLinkedList<number>([10, 20, 30, 40, 50]);
+  *
+  *     // Pop removes from the end
+  *     const last = list.pop();
+  *     console.log(last); // 50;
+  *
+  *     // Shift removes from the beginning
+  *     const first = list.shift();
+  *     console.log(first); // 10;
+  *
+  *     // Verify remaining elements
+  *     console.log([...list]); // [20, 30, 40];
+  *     console.log(list.length); // 3;
+    */
   pop() {
     var _a;
     if (!this.head) return void 0;
@@ -762,10 +821,26 @@ var _SinglyLinkedList = class _SinglyLinkedList extends LinearLinkedBase {
     return value;
   }
   /**
-   * Remove and return the head element.
-   * @remarks Time O(1), Space O(1)
-   * @returns Removed element or undefined.
-   */
+    * Remove and return the head element.
+    * @remarks Time O(1), Space O(1)
+    * @returns Removed element or undefined.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Remove from the front
+  *  const list = new SinglyLinkedList<number>([10, 20, 30]);
+  *     console.log(list.shift()); // 10;
+  *     console.log(list.length); // 2;
+    */
   shift() {
     if (!this.head) return void 0;
     const removed = this.head;
@@ -775,11 +850,42 @@ var _SinglyLinkedList = class _SinglyLinkedList extends LinearLinkedBase {
     return removed.value;
   }
   /**
-   * Prepend an element/node to the head.
-   * @remarks Time O(1), Space O(1)
-   * @param elementOrNode - Element or node to prepend.
-   * @returns True when prepended.
-   */
+    * Prepend an element/node to the head.
+    * @remarks Time O(1), Space O(1)
+    * @param elementOrNode - Element or node to prepend.
+    * @returns True when prepended.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // SinglyLinkedList unshift and forward traversal
+  *  const list = new SinglyLinkedList<number>([20, 30, 40]);
+  *
+  *     // Unshift adds to the beginning
+  *     list.unshift(10);
+  *     console.log([...list]); // [10, 20, 30, 40];
+  *
+  *     // Access elements (forward traversal only for singly linked)
+  *     const second = list.at(1);
+  *     console.log(second); // 20;
+  *
+  *     // SinglyLinkedList allows forward iteration only
+  *     const elements: number[] = [];
+  *     for (const item of list) {
+  *       elements.push(item);
+  *     }
+  *     console.log(elements); // [10, 20, 30, 40];
+  *
+  *     console.log(list.length); // 4;
+    */
   unshift(elementOrNode) {
     const newNode = this._ensureNode(elementOrNode);
     if (!this.head) {
@@ -835,11 +941,28 @@ var _SinglyLinkedList = class _SinglyLinkedList extends LinearLinkedBase {
     return void 0;
   }
   /**
-   * Get the element at a given index.
-   * @remarks Time O(N), Space O(1)
-   * @param index - Zero-based index.
-   * @returns Element or undefined.
-   */
+    * Get the element at a given index.
+    * @remarks Time O(N), Space O(1)
+    * @param index - Zero-based index.
+    * @returns Element or undefined.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Access element by index
+  *  const list = new SinglyLinkedList<string>(['a', 'b', 'c', 'd']);
+  *     console.log(list.at(0)); // 'a';
+  *     console.log(list.at(2)); // 'c';
+  *     console.log(list.at(3)); // 'd';
+    */
   at(index) {
     if (index < 0 || index >= this._length) return void 0;
     let current = this.head;
@@ -856,11 +979,23 @@ var _SinglyLinkedList = class _SinglyLinkedList extends LinearLinkedBase {
     return elementNodeOrPredicate instanceof SinglyLinkedListNode;
   }
   /**
-   * Get the node reference at a given index.
-   * @remarks Time O(N), Space O(1)
-   * @param index - Zero-based index.
-   * @returns Node or undefined.
-   */
+    * Get the node reference at a given index.
+    * @remarks Time O(N), Space O(1)
+    * @param index - Zero-based index.
+    * @returns Node or undefined.
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Get node at index
+  *  const list = new SinglyLinkedList<string>(['a', 'b', 'c']);
+  *     console.log(list.getNodeAt(1)?.value); // 'b';
+    */
   getNodeAt(index) {
     if (index < 0 || index >= this._length) return void 0;
     let current = this.head;
@@ -868,11 +1003,24 @@ var _SinglyLinkedList = class _SinglyLinkedList extends LinearLinkedBase {
     return current;
   }
   /**
-   * Delete the element at an index.
-   * @remarks Time O(N), Space O(1)
-   * @param index - Zero-based index.
-   * @returns Removed element or undefined.
-   */
+    * Delete the element at an index.
+    * @remarks Time O(N), Space O(1)
+    * @param index - Zero-based index.
+    * @returns Removed element or undefined.
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Remove by index
+  *  const list = new SinglyLinkedList<string>(['a', 'b', 'c']);
+  *     list.deleteAt(1);
+  *     console.log(list.toArray()); // ['a', 'c'];
+    */
   deleteAt(index) {
     if (index < 0 || index >= this._length) return void 0;
     if (index === 0) return this.shift();
@@ -885,11 +1033,24 @@ var _SinglyLinkedList = class _SinglyLinkedList extends LinearLinkedBase {
     return value;
   }
   /**
-   * Delete the first match by value/node.
-   * @remarks Time O(N), Space O(1)
-   * @param [elementOrNode] - Element or node to remove; if omitted/undefined, nothing happens.
-   * @returns True if removed.
-   */
+    * Delete the first match by value/node.
+    * @remarks Time O(N), Space O(1)
+    * @param [elementOrNode] - Element or node to remove; if omitted/undefined, nothing happens.
+    * @returns True if removed.
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Remove first occurrence
+  *  const list = new SinglyLinkedList<number>([1, 2, 3, 2]);
+  *     list.delete(2);
+  *     console.log(list.toArray()); // [1, 3, 2];
+    */
   delete(elementOrNode) {
     if (elementOrNode === void 0 || !this.head) return false;
     const node = this.isNode(elementOrNode) ? elementOrNode : this.getNode(elementOrNode);
@@ -906,12 +1067,25 @@ var _SinglyLinkedList = class _SinglyLinkedList extends LinearLinkedBase {
     return true;
   }
   /**
-   * Insert a new element/node at an index, shifting following nodes.
-   * @remarks Time O(N), Space O(1)
-   * @param index - Zero-based index.
-   * @param newElementOrNode - Element or node to insert.
-   * @returns True if inserted.
-   */
+    * Insert a new element/node at an index, shifting following nodes.
+    * @remarks Time O(N), Space O(1)
+    * @param index - Zero-based index.
+    * @param newElementOrNode - Element or node to insert.
+    * @returns True if inserted.
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Insert at index
+  *  const list = new SinglyLinkedList<number>([1, 3]);
+  *     list.addAt(1, 2);
+  *     console.log(list.toArray()); // [1, 2, 3];
+    */
   addAt(index, newElementOrNode) {
     if (index < 0 || index > this._length) return false;
     if (index === 0) return this.unshift(newElementOrNode);
@@ -937,28 +1111,70 @@ var _SinglyLinkedList = class _SinglyLinkedList extends LinearLinkedBase {
     return true;
   }
   /**
-   * Check whether the list is empty.
-   * @remarks Time O(1), Space O(1)
-   * @returns True if length is 0.
-   */
+    * Check whether the list is empty.
+    * @remarks Time O(1), Space O(1)
+    * @returns True if length is 0.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Check empty
+  *  console.log(new SinglyLinkedList().isEmpty()); // true;
+    */
   isEmpty() {
     return this._length === 0;
   }
   /**
-   * Remove all nodes and reset length.
-   * @remarks Time O(N), Space O(1)
-   * @returns void
-   */
+    * Remove all nodes and reset length.
+    * @remarks Time O(N), Space O(1)
+    * @returns void
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Remove all
+  *  const list = new SinglyLinkedList<number>([1, 2, 3]);
+  *     list.clear();
+  *     console.log(list.isEmpty()); // true;
+    */
   clear() {
     this._head = void 0;
     this._tail = void 0;
     this._length = 0;
   }
   /**
-   * Reverse the list in place.
-   * @remarks Time O(N), Space O(1)
-   * @returns This list.
-   */
+    * Reverse the list in place.
+    * @remarks Time O(N), Space O(1)
+    * @returns This list.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Reverse the list in-place
+  *  const list = new SinglyLinkedList<number>([1, 2, 3, 4]);
+  *     list.reverse();
+  *     console.log([...list]); // [4, 3, 2, 1];
+    */
   reverse() {
     if (!this.head || this.head === this.tail) return this;
     let prev;
@@ -1133,22 +1349,64 @@ var _SinglyLinkedList = class _SinglyLinkedList extends LinearLinkedBase {
     return false;
   }
   /**
-   * Deep clone this list (values are copied by reference).
-   * @remarks Time O(N), Space O(N)
-   * @returns A new list with the same element sequence.
-   */
+    * Deep clone this list (values are copied by reference).
+    * @remarks Time O(N), Space O(N)
+    * @returns A new list with the same element sequence.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Deep copy
+  *  const list = new SinglyLinkedList<number>([1, 2, 3]);
+  *     const copy = list.clone();
+  *     copy.pop();
+  *     console.log(list.length); // 3;
+  *     console.log(copy.length); // 2;
+    */
   clone() {
     const out = this._createInstance();
     for (const v of this) out.push(v);
     return out;
   }
   /**
-   * Filter values into a new list of the same class.
-   * @remarks Time O(N), Space O(N)
-   * @param callback - Predicate (value, index, list) → boolean to keep value.
-   * @param [thisArg] - Value for `this` inside the callback.
-   * @returns A new list with kept values.
-   */
+    * Filter values into a new list of the same class.
+    * @remarks Time O(N), Space O(N)
+    * @param callback - Predicate (value, index, list) → boolean to keep value.
+    * @param [thisArg] - Value for `this` inside the callback.
+    * @returns A new list with kept values.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // SinglyLinkedList filter and map operations
+  *  const list = new SinglyLinkedList<number>([1, 2, 3, 4, 5]);
+  *
+  *     // Filter even numbers
+  *     const filtered = list.filter(value => value % 2 === 0);
+  *     console.log(filtered.length); // 2;
+  *
+  *     // Map to double values
+  *     const doubled = list.map(value => value * 2);
+  *     console.log(doubled.length); // 5;
+  *
+  *     // Use reduce to sum
+  *     const sum = list.reduce((acc, value) => acc + value, 0);
+  *     console.log(sum); // 15;
+    */
   filter(callback, thisArg) {
     const out = this._createInstance();
     let index = 0;
@@ -1172,15 +1430,31 @@ var _SinglyLinkedList = class _SinglyLinkedList extends LinearLinkedBase {
     return out;
   }
   /**
-   * Map values into a new list (possibly different element type).
-   * @remarks Time O(N), Space O(N)
-   * @template EM
-   * @template RM
-   * @param callback - Mapping function (value, index, list) → newElement.
-   * @param [options] - Options for the output list (e.g., maxLen, toElementFn).
-   * @param [thisArg] - Value for `this` inside the callback.
-   * @returns A new SinglyLinkedList with mapped values.
-   */
+    * Map values into a new list (possibly different element type).
+    * @remarks Time O(N), Space O(N)
+    * @template EM
+    * @template RM
+    * @param callback - Mapping function (value, index, list) → newElement.
+    * @param [options] - Options for the output list (e.g., maxLen, toElementFn).
+    * @param [thisArg] - Value for `this` inside the callback.
+    * @returns A new SinglyLinkedList with mapped values.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Transform elements
+  *  const list = new SinglyLinkedList<number>([1, 2, 3]);
+  *     const doubled = list.map(n => n * 2);
+  *     console.log([...doubled]); // [2, 4, 6];
+    */
   map(callback, options, thisArg) {
     const out = this._createLike([], { ...options != null ? options : {}, maxLen: this._maxLen });
     let index = 0;
@@ -1456,11 +1730,37 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
     return elementNodeOrPredicate instanceof DoublyLinkedListNode;
   }
   /**
-   * Append an element/node to the tail.
-   * @remarks Time O(1), Space O(1)
-   * @param elementOrNode - Element or node to append.
-   * @returns True when appended.
-   */
+    * Append an element/node to the tail.
+    * @remarks Time O(1), Space O(1)
+    * @param elementOrNode - Element or node to append.
+    * @returns True when appended.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // basic DoublyLinkedList creation and push operation
+  *  // Create a simple DoublyLinkedList with initial values
+  *     const list = new DoublyLinkedList([1, 2, 3, 4, 5]);
+  *
+  *     // Verify the list maintains insertion order
+  *     console.log([...list]); // [1, 2, 3, 4, 5];
+  *
+  *     // Check length
+  *     console.log(list.length); // 5;
+  *
+  *     // Push a new element to the end
+  *     list.push(6);
+  *     console.log(list.length); // 6;
+  *     console.log([...list]); // [1, 2, 3, 4, 5, 6];
+    */
   push(elementOrNode) {
     const newNode = this._ensureNode(elementOrNode);
     if (!this.head) {
@@ -1476,10 +1776,36 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
     return true;
   }
   /**
-   * Remove and return the tail element.
-   * @remarks Time O(1), Space O(1)
-   * @returns Removed element or undefined.
-   */
+    * Remove and return the tail element.
+    * @remarks Time O(1), Space O(1)
+    * @returns Removed element or undefined.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // DoublyLinkedList pop and shift operations
+  *  const list = new DoublyLinkedList<number>([10, 20, 30, 40, 50]);
+  *
+  *     // Pop removes from the end
+  *     const last = list.pop();
+  *     console.log(last); // 50;
+  *
+  *     // Shift removes from the beginning
+  *     const first = list.shift();
+  *     console.log(first); // 10;
+  *
+  *     // Verify remaining elements
+  *     console.log([...list]); // [20, 30, 40];
+  *     console.log(list.length); // 3;
+    */
   pop() {
     if (!this.tail) return void 0;
     const removed = this.tail;
@@ -1494,10 +1820,26 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
     return removed.value;
   }
   /**
-   * Remove and return the head element.
-   * @remarks Time O(1), Space O(1)
-   * @returns Removed element or undefined.
-   */
+    * Remove and return the head element.
+    * @remarks Time O(1), Space O(1)
+    * @returns Removed element or undefined.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Remove from the front
+  *  const list = new DoublyLinkedList<number>([10, 20, 30]);
+  *     console.log(list.shift()); // 10;
+  *     console.log(list.first); // 20;
+    */
   shift() {
     if (!this.head) return void 0;
     const removed = this.head;
@@ -1512,11 +1854,27 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
     return removed.value;
   }
   /**
-   * Prepend an element/node to the head.
-   * @remarks Time O(1), Space O(1)
-   * @param elementOrNode - Element or node to prepend.
-   * @returns True when prepended.
-   */
+    * Prepend an element/node to the head.
+    * @remarks Time O(1), Space O(1)
+    * @param elementOrNode - Element or node to prepend.
+    * @returns True when prepended.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Add to the front
+  *  const list = new DoublyLinkedList<number>([2, 3]);
+  *     list.unshift(1);
+  *     console.log([...list]); // [1, 2, 3];
+    */
   unshift(elementOrNode) {
     const newNode = this._ensureNode(elementOrNode);
     if (!this.head) {
@@ -1560,11 +1918,27 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
     return ans;
   }
   /**
-   * Get the element at a given index.
-   * @remarks Time O(N), Space O(1)
-   * @param index - Zero-based index.
-   * @returns Element or undefined.
-   */
+    * Get the element at a given index.
+    * @remarks Time O(N), Space O(1)
+    * @param index - Zero-based index.
+    * @returns Element or undefined.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Access by index
+  *  const list = new DoublyLinkedList<string>(['a', 'b', 'c']);
+  *     console.log(list.at(1)); // 'b';
+  *     console.log(list.at(2)); // 'c';
+    */
   at(index) {
     if (index < 0 || index >= this._length) return void 0;
     let current = this.head;
@@ -1572,11 +1946,23 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
     return current == null ? void 0 : current.value;
   }
   /**
-   * Get the node reference at a given index.
-   * @remarks Time O(N), Space O(1)
-   * @param index - Zero-based index.
-   * @returns Node or undefined.
-   */
+    * Get the node reference at a given index.
+    * @remarks Time O(N), Space O(1)
+    * @param index - Zero-based index.
+    * @returns Node or undefined.
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Get node at index
+  *  const list = new DoublyLinkedList<string>(['a', 'b', 'c']);
+  *     console.log(list.getNodeAt(1)?.value); // 'b';
+    */
   getNodeAt(index) {
     if (index < 0 || index >= this._length) return void 0;
     let current = this.head;
@@ -1615,12 +2001,25 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
     return void 0;
   }
   /**
-   * Insert a new element/node at an index, shifting following nodes.
-   * @remarks Time O(N), Space O(1)
-   * @param index - Zero-based index.
-   * @param newElementOrNode - Element or node to insert.
-   * @returns True if inserted.
-   */
+    * Insert a new element/node at an index, shifting following nodes.
+    * @remarks Time O(N), Space O(1)
+    * @param index - Zero-based index.
+    * @param newElementOrNode - Element or node to insert.
+    * @returns True if inserted.
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Insert at position
+  *  const list = new DoublyLinkedList<number>([1, 3]);
+  *     list.addAt(1, 2);
+  *     console.log(list.toArray()); // [1, 2, 3];
+    */
   addAt(index, newElementOrNode) {
     if (index < 0 || index > this._length) return false;
     if (index === 0) return this.unshift(newElementOrNode);
@@ -1687,11 +2086,24 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
     return true;
   }
   /**
-   * Delete the element at an index.
-   * @remarks Time O(N), Space O(1)
-   * @param index - Zero-based index.
-   * @returns Removed element or undefined.
-   */
+    * Delete the element at an index.
+    * @remarks Time O(N), Space O(1)
+    * @param index - Zero-based index.
+    * @returns Removed element or undefined.
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Remove by index
+  *  const list = new DoublyLinkedList<string>(['a', 'b', 'c']);
+  *     list.deleteAt(1);
+  *     console.log(list.toArray()); // ['a', 'c'];
+    */
   deleteAt(index) {
     if (index < 0 || index >= this._length) return;
     if (index === 0) return this.shift();
@@ -1705,11 +2117,24 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
     return removedNode.value;
   }
   /**
-   * Delete the first match by value/node.
-   * @remarks Time O(N), Space O(1)
-   * @param [elementOrNode] - Element or node to remove.
-   * @returns True if removed.
-   */
+    * Delete the first match by value/node.
+    * @remarks Time O(N), Space O(1)
+    * @param [elementOrNode] - Element or node to remove.
+    * @returns True if removed.
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Remove first occurrence
+  *  const list = new DoublyLinkedList<number>([1, 2, 3, 2]);
+  *     list.delete(2);
+  *     console.log(list.toArray()); // [1, 3, 2];
+    */
   delete(elementOrNode) {
     const node = this.getNode(elementOrNode);
     if (!node) return false;
@@ -1725,29 +2150,68 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
     return true;
   }
   /**
-   * Check whether the list is empty.
-   * @remarks Time O(1), Space O(1)
-   * @returns True if length is 0.
-   */
+    * Check whether the list is empty.
+    * @remarks Time O(1), Space O(1)
+    * @returns True if length is 0.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Check empty
+  *  console.log(new DoublyLinkedList().isEmpty()); // true;
+    */
   isEmpty() {
     return this._length === 0;
   }
   /**
-   * Remove all nodes and reset length.
-   * @remarks Time O(N), Space O(1)
-   * @returns void
-   */
+    * Remove all nodes and reset length.
+    * @remarks Time O(N), Space O(1)
+    * @returns void
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Remove all
+  *  const list = new DoublyLinkedList<number>([1, 2]);
+  *     list.clear();
+  *     console.log(list.isEmpty()); // true;
+    */
   clear() {
     this._head = void 0;
     this._tail = void 0;
     this._length = 0;
   }
   /**
-   * Find the first value matching a predicate scanning forward.
-   * @remarks Time O(N), Space O(1)
-   * @param elementNodeOrPredicate - Element, node, or predicate to match.
-   * @returns Matched value or undefined.
-   */
+    * Find the first value matching a predicate scanning forward.
+    * @remarks Time O(N), Space O(1)
+    * @param elementNodeOrPredicate - Element, node, or predicate to match.
+    * @returns Matched value or undefined.
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Search with predicate
+  *  const list = new DoublyLinkedList<number>([10, 20, 30]);
+  *     const found = list.search(node => node.value > 15);
+  *     console.log(found); // 20;
+    */
   search(elementNodeOrPredicate) {
     const predicate = this._ensurePredicate(elementNodeOrPredicate);
     let current = this.head;
@@ -1758,11 +2222,25 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
     return void 0;
   }
   /**
-   * Find the first value matching a predicate scanning backward.
-   * @remarks Time O(N), Space O(1)
-   * @param elementNodeOrPredicate - Element, node, or predicate to match.
-   * @returns Matched value or undefined.
-   */
+    * Find the first value matching a predicate scanning backward.
+    * @remarks Time O(N), Space O(1)
+    * @param elementNodeOrPredicate - Element, node, or predicate to match.
+    * @returns Matched value or undefined.
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Find value scanning from tail
+  *  const list = new DoublyLinkedList<number>([1, 2, 3, 4]);
+  *     // getBackward scans from tail to head, returns first match
+  *     const found = list.getBackward(node => node.value < 4);
+  *     console.log(found); // 3;
+    */
   getBackward(elementNodeOrPredicate) {
     const predicate = this._ensurePredicate(elementNodeOrPredicate);
     let current = this.tail;
@@ -1773,10 +2251,26 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
     return void 0;
   }
   /**
-   * Reverse the list in place.
-   * @remarks Time O(N), Space O(1)
-   * @returns This list.
-   */
+    * Reverse the list in place.
+    * @remarks Time O(N), Space O(1)
+    * @returns This list.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Reverse in-place
+  *  const list = new DoublyLinkedList<number>([1, 2, 3]);
+  *     list.reverse();
+  *     console.log([...list]); // [3, 2, 1];
+    */
   reverse() {
     let current = this.head;
     [this._head, this._tail] = [this.tail, this.head];
@@ -1798,22 +2292,53 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
     return this;
   }
   /**
-   * Deep clone this list (values are copied by reference).
-   * @remarks Time O(N), Space O(N)
-   * @returns A new list with the same element sequence.
-   */
+    * Deep clone this list (values are copied by reference).
+    * @remarks Time O(N), Space O(N)
+    * @returns A new list with the same element sequence.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Deep copy
+  *  const list = new DoublyLinkedList<number>([1, 2, 3]);
+  *     const copy = list.clone();
+  *     copy.pop();
+  *     console.log(list.length); // 3;
+    */
   clone() {
     const out = this._createInstance({ toElementFn: this._toElementFn, maxLen: this._maxLen });
     for (const v of this) out.push(v);
     return out;
   }
   /**
-   * Filter values into a new list of the same class.
-   * @remarks Time O(N), Space O(N)
-   * @param callback - Predicate (value, index, list) → boolean to keep value.
-   * @param [thisArg] - Value for `this` inside the callback.
-   * @returns A new list with kept values.
-   */
+    * Filter values into a new list of the same class.
+    * @remarks Time O(N), Space O(N)
+    * @param callback - Predicate (value, index, list) → boolean to keep value.
+    * @param [thisArg] - Value for `this` inside the callback.
+    * @returns A new list with kept values.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Filter elements
+  *  const list = new DoublyLinkedList<number>([1, 2, 3, 4, 5]);
+  *     const evens = list.filter(n => n % 2 === 0);
+  *     console.log([...evens]); // [2, 4];
+    */
   filter(callback, thisArg) {
     const out = this._createInstance({ toElementFn: this._toElementFn, maxLen: this._maxLen });
     let index = 0;
@@ -1837,15 +2362,40 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
     return out;
   }
   /**
-   * Map values into a new list (possibly different element type).
-   * @remarks Time O(N), Space O(N)
-   * @template EM
-   * @template RM
-   * @param callback - Mapping function (value, index, list) → newElement.
-   * @param [options] - Options for the output list (e.g., maxLen, toElementFn).
-   * @param [thisArg] - Value for `this` inside the callback.
-   * @returns A new DoublyLinkedList with mapped values.
-   */
+    * Map values into a new list (possibly different element type).
+    * @remarks Time O(N), Space O(N)
+    * @template EM
+    * @template RM
+    * @param callback - Mapping function (value, index, list) → newElement.
+    * @param [options] - Options for the output list (e.g., maxLen, toElementFn).
+    * @param [thisArg] - Value for `this` inside the callback.
+    * @returns A new DoublyLinkedList with mapped values.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // DoublyLinkedList for...of iteration and map operation
+  *  const list = new DoublyLinkedList<number>([1, 2, 3, 4, 5]);
+  *
+  *     // Iterate through list
+  *     const doubled = list.map(value => value * 2);
+  *     console.log(doubled.length); // 5;
+  *
+  *     // Use for...of loop
+  *     const result: number[] = [];
+  *     for (const item of list) {
+  *       result.push(item);
+  *     }
+  *     console.log(result); // [1, 2, 3, 4, 5];
+    */
   map(callback, options, thisArg) {
     const out = this._createLike([], { ...options != null ? options : {}, maxLen: this._maxLen });
     let index = 0;
@@ -1936,6 +2486,235 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
 __name(_DoublyLinkedList, "DoublyLinkedList");
 var DoublyLinkedList = _DoublyLinkedList;
 
+// src/common/error.ts
+var ERR = {
+  // Range / index
+  indexOutOfRange: /* @__PURE__ */ __name((index, min, max, ctx) => `${ctx ? ctx + ": " : ""}Index ${index} is out of range [${min}, ${max}].`, "indexOutOfRange"),
+  invalidIndex: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Index must be an integer.`, "invalidIndex"),
+  // Type / argument
+  invalidArgument: /* @__PURE__ */ __name((reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`, "invalidArgument"),
+  comparatorRequired: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Comparator is required for non-number/non-string/non-Date keys.`, "comparatorRequired"),
+  invalidKey: /* @__PURE__ */ __name((reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`, "invalidKey"),
+  notAFunction: /* @__PURE__ */ __name((name, ctx) => `${ctx ? ctx + ": " : ""}${name} must be a function.`, "notAFunction"),
+  invalidEntry: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Each entry must be a [key, value] tuple.`, "invalidEntry"),
+  invalidNaN: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}NaN is not a valid key.`, "invalidNaN"),
+  invalidDate: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Invalid Date key.`, "invalidDate"),
+  reduceEmpty: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Reduce of empty structure with no initial value.`, "reduceEmpty"),
+  callbackReturnType: /* @__PURE__ */ __name((expected, got, ctx) => `${ctx ? ctx + ": " : ""}Callback must return ${expected}; got ${got}.`, "callbackReturnType"),
+  // State / operation
+  invalidOperation: /* @__PURE__ */ __name((reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`, "invalidOperation"),
+  // Matrix
+  matrixDimensionMismatch: /* @__PURE__ */ __name((op) => `Matrix: Dimensions must be compatible for ${op}.`, "matrixDimensionMismatch"),
+  matrixSingular: /* @__PURE__ */ __name(() => "Matrix: Singular matrix, inverse does not exist.", "matrixSingular"),
+  matrixNotSquare: /* @__PURE__ */ __name(() => "Matrix: Must be square for inversion.", "matrixNotSquare"),
+  matrixNotRectangular: /* @__PURE__ */ __name(() => "Matrix: Must be rectangular for transposition.", "matrixNotRectangular"),
+  matrixRowMismatch: /* @__PURE__ */ __name((expected, got) => `Matrix: Expected row length ${expected}, but got ${got}.`, "matrixRowMismatch")
+};
+
+// src/common/index.ts
+var DFSOperation = /* @__PURE__ */ ((DFSOperation2) => {
+  DFSOperation2[DFSOperation2["VISIT"] = 0] = "VISIT";
+  DFSOperation2[DFSOperation2["PROCESS"] = 1] = "PROCESS";
+  return DFSOperation2;
+})(DFSOperation || {});
+var _Range = class _Range {
+  constructor(low, high, includeLow = true, includeHigh = true) {
+    this.low = low;
+    this.high = high;
+    this.includeLow = includeLow;
+    this.includeHigh = includeHigh;
+  }
+  // Determine whether a key is within the range
+  isInRange(key, comparator) {
+    const lowCheck = this.includeLow ? comparator(key, this.low) >= 0 : comparator(key, this.low) > 0;
+    const highCheck = this.includeHigh ? comparator(key, this.high) <= 0 : comparator(key, this.high) < 0;
+    return lowCheck && highCheck;
+  }
+};
+__name(_Range, "Range");
+var Range = _Range;
+
+// src/data-structures/base/iterable-entry-base.ts
+var _IterableEntryBase = class _IterableEntryBase {
+  /**
+   * Default iterator yielding `[key, value]` entries.
+   * @returns Iterator of `[K, V]`.
+   * @remarks Time O(n) to iterate, Space O(1)
+   */
+  *[Symbol.iterator](...args) {
+    yield* this._getIterator(...args);
+  }
+  /**
+   * Iterate over `[key, value]` pairs (may yield `undefined` values).
+   * @returns Iterator of `[K, V | undefined]`.
+   * @remarks Time O(n), Space O(1)
+   */
+  *entries() {
+    for (const item of this) {
+      yield item;
+    }
+  }
+  /**
+   * Iterate over keys only.
+   * @returns Iterator of keys.
+   * @remarks Time O(n), Space O(1)
+   */
+  *keys() {
+    for (const item of this) {
+      yield item[0];
+    }
+  }
+  /**
+   * Iterate over values only.
+   * @returns Iterator of values.
+   * @remarks Time O(n), Space O(1)
+   */
+  *values() {
+    for (const item of this) {
+      yield item[1];
+    }
+  }
+  /**
+   * Test whether all entries satisfy the predicate.
+   * @param predicate - `(key, value, index, self) => boolean`.
+   * @param thisArg - Optional `this` for callback.
+   * @returns `true` if all pass; otherwise `false`.
+   * @remarks Time O(n), Space O(1)
+   */
+  every(predicate, thisArg) {
+    let index = 0;
+    for (const item of this) {
+      if (!predicate.call(thisArg, item[1], item[0], index++, this)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Test whether any entry satisfies the predicate.
+   * @param predicate - `(key, value, index, self) => boolean`.
+   * @param thisArg - Optional `this` for callback.
+   * @returns `true` if any passes; otherwise `false`.
+   * @remarks Time O(n), Space O(1)
+   */
+  some(predicate, thisArg) {
+    let index = 0;
+    for (const item of this) {
+      if (predicate.call(thisArg, item[1], item[0], index++, this)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Visit each entry, left-to-right.
+   * @param callbackfn - `(key, value, index, self) => void`.
+   * @param thisArg - Optional `this` for callback.
+   * @remarks Time O(n), Space O(1)
+   */
+  forEach(callbackfn, thisArg) {
+    let index = 0;
+    for (const item of this) {
+      const [key, value] = item;
+      callbackfn.call(thisArg, value, key, index++, this);
+    }
+  }
+  /**
+   * Find the first entry that matches a predicate.
+   * @param callbackfn - `(key, value, index, self) => boolean`.
+   * @param thisArg - Optional `this` for callback.
+   * @returns Matching `[key, value]` or `undefined`.
+   * @remarks Time O(n), Space O(1)
+   */
+  find(callbackfn, thisArg) {
+    let index = 0;
+    for (const item of this) {
+      const [key, value] = item;
+      if (callbackfn.call(thisArg, value, key, index++, this)) return item;
+    }
+    return;
+  }
+  /**
+   * Whether the given key exists.
+   * @param key - Key to test.
+   * @returns `true` if found; otherwise `false`.
+   * @remarks Time O(n) generic, Space O(1)
+   */
+  has(key) {
+    for (const item of this) {
+      const [itemKey] = item;
+      if (itemKey === key) return true;
+    }
+    return false;
+  }
+  /**
+   * Whether there exists an entry with the given value.
+   * @param value - Value to test.
+   * @returns `true` if found; otherwise `false`.
+   * @remarks Time O(n), Space O(1)
+   */
+  hasValue(value) {
+    for (const [, elementValue] of this) {
+      if (elementValue === value) return true;
+    }
+    return false;
+  }
+  /**
+   * Get the value under a key.
+   * @param key - Key to look up.
+   * @returns Value or `undefined`.
+   * @remarks Time O(n) generic, Space O(1)
+   */
+  get(key) {
+    for (const item of this) {
+      const [itemKey, value] = item;
+      if (itemKey === key) return value;
+    }
+    return;
+  }
+  /**
+   * Reduce entries into a single accumulator.
+   * @param callbackfn - `(acc, value, key, index, self) => acc`.
+   * @param initialValue - Initial accumulator.
+   * @returns Final accumulator.
+   * @remarks Time O(n), Space O(1)
+   */
+  reduce(callbackfn, initialValue) {
+    let accumulator = initialValue;
+    let index = 0;
+    for (const item of this) {
+      const [key, value] = item;
+      accumulator = callbackfn(accumulator, value, key, index++, this);
+    }
+    return accumulator;
+  }
+  /**
+   * Converts data structure to `[key, value]` pairs.
+   * @returns Array of entries.
+   * @remarks Time O(n), Space O(n)
+   */
+  toArray() {
+    return [...this];
+  }
+  /**
+   * Visualize the iterable as an array of `[key, value]` pairs (or a custom string).
+   * @returns Array of entries (default) or a string.
+   * @remarks Time O(n), Space O(n)
+   */
+  toVisual() {
+    return [...this];
+  }
+  /**
+   * Print a human-friendly representation to the console.
+   * @remarks Time O(n), Space O(n)
+   */
+  print() {
+    console.log(this.toVisual());
+  }
+};
+__name(_IterableEntryBase, "IterableEntryBase");
+var IterableEntryBase = _IterableEntryBase;
+
 // src/data-structures/linked-list/skip-linked-list.ts
 var _SkipListNode = class _SkipListNode {
   constructor(key, value, level) {
@@ -1944,31 +2723,69 @@ var _SkipListNode = class _SkipListNode {
     __publicField(this, "forward");
     this.key = key;
     this.value = value;
-    this.forward = new Array(level);
+    this.forward = new Array(level).fill(void 0);
   }
 };
 __name(_SkipListNode, "SkipListNode");
 var SkipListNode = _SkipListNode;
-var _SkipList = class _SkipList {
-  constructor(elements = [], options) {
-    __publicField(this, "_head", new SkipListNode(void 0, void 0, this.maxLevel));
+var _comparator, _isDefaultComparator;
+var _SkipList = class _SkipList extends IterableEntryBase {
+  constructor(entries = [], options = {}) {
+    super();
+    __privateAdd(this, _comparator);
+    __privateAdd(this, _isDefaultComparator);
+    // ─── Internal state ──────────────────────────────────────────
+    __publicField(this, "_head");
     __publicField(this, "_level", 0);
+    __publicField(this, "_size", 0);
     __publicField(this, "_maxLevel", 16);
     __publicField(this, "_probability", 0.5);
-    if (options) {
-      const { maxLevel, probability } = options;
-      if (typeof maxLevel === "number") this._maxLevel = maxLevel;
-      if (typeof probability === "number") this._probability = probability;
-    }
-    if (elements) {
-      for (const [key, value] of elements) this.add(key, value);
+    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;
+    __privateSet(this, _isDefaultComparator, comparator === void 0);
+    __privateSet(this, _comparator, comparator != null ? comparator : _SkipList.createDefaultComparator());
+    this._head = new SkipListNode(void 0, void 0, this._maxLevel);
+    for (const item of entries) {
+      let k;
+      let v;
+      if (toEntryFn) {
+        [k, v] = toEntryFn(item);
+      } else {
+        if (!Array.isArray(item) || item.length < 2) {
+          throw new TypeError(ERR.invalidEntry("SkipList"));
+        }
+        [k, v] = item;
+      }
+      this.set(k, v);
     }
   }
-  get head() {
-    return this._head;
+  /**
+   * Creates a default comparator supporting number, string, Date, and bigint.
+   */
+  static createDefaultComparator() {
+    return (a, b) => {
+      if (typeof a === "number" && typeof b === "number") {
+        if (Number.isNaN(a) || Number.isNaN(b)) throw new TypeError(ERR.invalidNaN("SkipList"));
+        return a - b;
+      }
+      if (typeof a === "string" && typeof b === "string") {
+        return a < b ? -1 : a > b ? 1 : 0;
+      }
+      if (a instanceof Date && b instanceof Date) {
+        const ta = a.getTime(), tb = b.getTime();
+        if (Number.isNaN(ta) || Number.isNaN(tb)) throw new TypeError(ERR.invalidDate("SkipList"));
+        return ta - tb;
+      }
+      if (typeof a === "bigint" && typeof b === "bigint") {
+        return a < b ? -1 : a > b ? 1 : 0;
+      }
+      throw new TypeError(ERR.comparatorRequired("SkipList"));
+    };
   }
-  get level() {
-    return this._level;
+  // ─── Size & lifecycle ────────────────────────────────────────
+  get size() {
+    return this._size;
   }
   get maxLevel() {
     return this._maxLevel;
@@ -1976,133 +2793,594 @@ var _SkipList = class _SkipList {
   get probability() {
     return this._probability;
   }
-  get first() {
-    const firstNode = this.head.forward[0];
-    return firstNode ? firstNode.value : void 0;
+  get comparator() {
+    return __privateGet(this, _comparator);
+  }
+  /**
+    * Check if empty
+   
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Check if empty
+  *  const sl = new SkipList<number, string>();
+  *     console.log(sl.isEmpty()); // true;
+    */
+  isEmpty() {
+    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;
+    */
+  clear() {
+    this._head = new SkipListNode(void 0, void 0, this._maxLevel);
+    this._level = 0;
+    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;
+    */
+  clone() {
+    return new _SkipList(this, {
+      comparator: __privateGet(this, _isDefaultComparator) ? void 0 : __privateGet(this, _comparator),
+      maxLevel: this._maxLevel,
+      probability: this._probability
+    });
+  }
+  // ─── Core CRUD ───────────────────────────────────────────────
+  /**
+    * 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';
+    */
+  set(key, value) {
+    const cmp = __privateGet(this, _comparator);
+    const update = this._findUpdate(key);
+    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;
   }
-  get last() {
-    let current = this.head;
-    for (let i = this.level - 1; i >= 0; i--) {
+  /**
+    * 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>(products as any, {
+  *       toEntryFn: (p: any) => [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'];
+    */
+  get(key) {
+    const node = this._findNode(key);
+    return node ? node.value : void 0;
+  }
+  /**
+    * 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;
+    */
+  has(key) {
+    return this._findNode(key) !== void 0;
+  }
+  /**
+    * 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;
+    */
+  delete(key) {
+    const cmp = __privateGet(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;
+  }
+  // ─── Navigation ──────────────────────────────────────────────
+  /**
+    * 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'];
+    */
+  first() {
+    const node = this._head.forward[0];
+    return node ? [node.key, node.value] : void 0;
+  }
+  /**
+    * 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'];
+    */
+  last() {
+    let current = this._head;
+    for (let i = this._level - 1; i >= 0; i--) {
       while (current.forward[i]) {
         current = current.forward[i];
       }
     }
-    return current.value;
-  }
-  add(key, value) {
-    const newNode = new SkipListNode(key, value, this._randomLevel());
-    const update = new Array(this.maxLevel).fill(this.head);
-    let current = this.head;
-    for (let i = this.level - 1; i >= 0; i--) {
-      while (current.forward[i] && current.forward[i].key < key) {
+    return current === this._head ? void 0 : [current.key, current.value];
+  }
+  /**
+    * 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;
+    */
+  pollFirst() {
+    const entry = this.first();
+    if (!entry) return void 0;
+    this.delete(entry[0]);
+    return entry;
+  }
+  /**
+    * 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;
+    */
+  pollLast() {
+    const entry = this.last();
+    if (!entry) return void 0;
+    this.delete(entry[0]);
+    return entry;
+  }
+  /**
+    * 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'];
+    */
+  ceiling(key) {
+    const cmp = __privateGet(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];
       }
-      update[i] = current;
     }
-    for (let i = 0; i < newNode.forward.length; i++) {
-      newNode.forward[i] = update[i].forward[i];
-      update[i].forward[i] = newNode;
-    }
-    if (!newNode.forward[0]) {
-      this._level = Math.max(this.level, newNode.forward.length);
+    const node = current.forward[0];
+    return node ? [node.key, node.value] : void 0;
+  }
+  /**
+    * 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;
+    */
+  floor(key) {
+    const cmp = __privateGet(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 result = current === this._head ? void 0 : current;
+    if (result && cmp(result.key, key) <= 0) return [result.key, result.value];
+    return void 0;
   }
-  get(key) {
-    let current = this.head;
-    for (let i = this.level - 1; i >= 0; i--) {
-      while (current.forward[i] && current.forward[i].key < key) {
+  /**
+    * 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;
+    */
+  higher(key) {
+    const cmp = __privateGet(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];
       }
     }
-    current = current.forward[0];
-    if (current && current.key === key) {
-      return current.value;
+    const node = current.forward[0];
+    return node ? [node.key, node.value] : void 0;
+  }
+  /**
+    * 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;
+    */
+  lower(key) {
+    const cmp = __privateGet(this, _comparator);
+    let current = this._head;
+    let result;
+    for (let i = this._level - 1; i >= 0; i--) {
+      while (current.forward[i] && cmp(current.forward[i].key, key) < 0) {
+        current = current.forward[i];
+      }
+      if (current !== this._head && cmp(current.key, key) < 0) {
+        result = current;
+      }
     }
-    return void 0;
-  }
-  has(key) {
-    return this.get(key) !== void 0;
-  }
-  delete(key) {
-    const update = new Array(this.maxLevel).fill(this.head);
-    let current = this.head;
-    for (let i = this.level - 1; i >= 0; i--) {
-      while (current.forward[i] && current.forward[i].key < key) {
+    return result ? [result.key, result.value] : void 0;
+  }
+  /**
+    * 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']];
+    */
+  rangeSearch(range, options = {}) {
+    const { lowInclusive = true, highInclusive = true } = options;
+    const [low, high] = range;
+    const cmp = __privateGet(this, _comparator);
+    const out = [];
+    let current = this._head;
+    for (let i = this._level - 1; i >= 0; i--) {
+      while (current.forward[i] && cmp(current.forward[i].key, low) < 0) {
         current = current.forward[i];
       }
-      update[i] = current;
     }
     current = current.forward[0];
-    if (current && current.key === key) {
-      for (let i = 0; i < this.level; i++) {
-        if (update[i].forward[i] !== current) {
-          break;
-        }
-        update[i].forward[i] = current.forward[i];
-      }
-      while (this.level > 0 && !this.head.forward[this.level - 1]) {
-        this._level--;
+    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]);
       }
-      return true;
+      current = current.forward[0];
     }
-    return false;
+    return out;
   }
-  higher(key) {
-    let current = this.head;
-    for (let i = this.level - 1; i >= 0; i--) {
-      while (current.forward[i] && current.forward[i].key <= key) {
+  // ─── Functional (overrides) ──────────────────────────────────
+  /**
+    * 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'];
+    */
+  map(callback, options) {
+    const out = new _SkipList([], options != null ? options : {});
+    let i = 0;
+    for (const [k, v] of this) {
+      const [nk, nv] = callback(v, k, i++, this);
+      out.set(nk, nv);
+    }
+    return out;
+  }
+  /**
+    * 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;
+    */
+  filter(callbackfn, thisArg) {
+    const out = new _SkipList([], {
+      comparator: __privateGet(this, _isDefaultComparator) ? void 0 : __privateGet(this, _comparator),
+      maxLevel: this._maxLevel,
+      probability: this._probability
+    });
+    let i = 0;
+    for (const [k, v] of this) {
+      const ok = callbackfn.call(thisArg, v, k, i++, this);
+      if (ok) out.set(k, v);
+    }
+    return out;
+  }
+  // ─── Iterator (required by IterableEntryBase) ────────────────
+  _getIterator() {
+    const head = this._head;
+    return (function* () {
+      let node = head.forward[0];
+      while (node) {
+        yield [node.key, node.value];
+        node = node.forward[0];
+      }
+    })();
+  }
+  // ─── Internal helpers ────────────────────────────────────────
+  /**
+   * Finds the update array (predecessors at each level) for a given key.
+   */
+  _findUpdate(key) {
+    const cmp = __privateGet(this, _comparator);
+    const update = 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;
     }
-    const nextNode = current.forward[0];
-    return nextNode ? nextNode.value : void 0;
+    return update;
   }
-  lower(key) {
-    let current = this.head;
-    let lastLess = void 0;
-    for (let i = this.level - 1; i >= 0; i--) {
-      while (current.forward[i] && current.forward[i].key < key) {
+  /**
+   * Finds the node for a given key, or undefined.
+   */
+  _findNode(key) {
+    const cmp = __privateGet(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];
       }
-      if (current.key < key) {
-        lastLess = current;
-      }
     }
-    return lastLess ? lastLess.value : void 0;
+    const candidate = current.forward[0];
+    if (candidate && cmp(candidate.key, key) === 0) return candidate;
+    return void 0;
   }
   _randomLevel() {
     let level = 1;
-    while (Math.random() < this.probability && level < this.maxLevel) {
+    while (Math.random() < this._probability && level < this._maxLevel) {
       level++;
     }
     return level;
   }
 };
+_comparator = new WeakMap();
+_isDefaultComparator = new WeakMap();
 __name(_SkipList, "SkipList");
 var SkipList = _SkipList;
-
-// src/common/index.ts
-var DFSOperation = /* @__PURE__ */ ((DFSOperation2) => {
-  DFSOperation2[DFSOperation2["VISIT"] = 0] = "VISIT";
-  DFSOperation2[DFSOperation2["PROCESS"] = 1] = "PROCESS";
-  return DFSOperation2;
-})(DFSOperation || {});
-var _Range = class _Range {
-  constructor(low, high, includeLow = true, includeHigh = true) {
-    this.low = low;
-    this.high = high;
-    this.includeLow = includeLow;
-    this.includeHigh = includeHigh;
-  }
-  // Determine whether a key is within the range
-  isInRange(key, comparator) {
-    const lowCheck = this.includeLow ? comparator(key, this.low) >= 0 : comparator(key, this.low) > 0;
-    const highCheck = this.includeHigh ? comparator(key, this.high) <= 0 : comparator(key, this.high) < 0;
-    return lowCheck && highCheck;
-  }
-};
-__name(_Range, "Range");
-var Range = _Range;
 /**
  * data-structure-typed
  *
@@ -2114,6 +3392,7 @@ var Range = _Range;
 exports.DFSOperation = DFSOperation;
 exports.DoublyLinkedList = DoublyLinkedList;
 exports.DoublyLinkedListNode = DoublyLinkedListNode;
+exports.ERR = ERR;
 exports.Range = Range;
 exports.SinglyLinkedList = SinglyLinkedList;
 exports.SinglyLinkedListNode = SinglyLinkedListNode;