linked-list-typed 2.4.4 → 2.5.0

package/dist/umd/linked-list-typed.js

@@ -4,6 +4,9 @@ var linkedListTyped = (() => {
   var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
   var __getOwnPropNames = Object.getOwnPropertyNames;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
+  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 __export = (target, all) => {
     for (var name in all)
@@ -19,6 +22,10 @@ var linkedListTyped = (() => {
   };
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
   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"), setter ? setter.call(obj, value) : member.set(obj, value), value);
 
   // src/index.ts
   var src_exports = {};
@@ -26,6 +33,7 @@ var linkedListTyped = (() => {
     DFSOperation: () => DFSOperation,
     DoublyLinkedList: () => DoublyLinkedList,
     DoublyLinkedListNode: () => DoublyLinkedListNode,
+    ERR: () => ERR,
     Range: () => Range,
     SinglyLinkedList: () => SinglyLinkedList,
     SinglyLinkedListNode: () => SinglyLinkedListNode,
@@ -739,11 +747,37 @@ var linkedListTyped = (() => {
       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) {
@@ -757,10 +791,36 @@ var linkedListTyped = (() => {
       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;
@@ -780,10 +840,26 @@ var linkedListTyped = (() => {
       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;
@@ -793,11 +869,42 @@ var linkedListTyped = (() => {
       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) {
@@ -853,11 +960,28 @@ var linkedListTyped = (() => {
       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;
@@ -874,11 +998,23 @@ var linkedListTyped = (() => {
       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;
@@ -886,11 +1022,24 @@ var linkedListTyped = (() => {
       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();
@@ -903,11 +1052,24 @@ var linkedListTyped = (() => {
       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);
@@ -924,12 +1086,25 @@ var linkedListTyped = (() => {
       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);
@@ -955,28 +1130,70 @@ var linkedListTyped = (() => {
       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;
@@ -1151,22 +1368,64 @@ var linkedListTyped = (() => {
       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;
@@ -1190,15 +1449,31 @@ var linkedListTyped = (() => {
       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;
@@ -1469,11 +1744,37 @@ var linkedListTyped = (() => {
       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) {
@@ -1489,10 +1790,36 @@ var linkedListTyped = (() => {
       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;
@@ -1507,10 +1834,26 @@ var linkedListTyped = (() => {
       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;
@@ -1525,11 +1868,27 @@ var linkedListTyped = (() => {
       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) {
@@ -1573,11 +1932,27 @@ var linkedListTyped = (() => {
       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;
@@ -1585,11 +1960,23 @@ var linkedListTyped = (() => {
       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;
@@ -1628,12 +2015,25 @@ var linkedListTyped = (() => {
       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);
@@ -1700,11 +2100,24 @@ var linkedListTyped = (() => {
       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();
@@ -1718,11 +2131,24 @@ var linkedListTyped = (() => {
       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;
@@ -1738,29 +2164,68 @@ var linkedListTyped = (() => {
       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;
@@ -1771,11 +2236,25 @@ var linkedListTyped = (() => {
       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;
@@ -1786,10 +2265,26 @@ var linkedListTyped = (() => {
       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];
@@ -1811,22 +2306,53 @@ var linkedListTyped = (() => {
       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;
@@ -1850,15 +2376,40 @@ var linkedListTyped = (() => {
       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;
@@ -1947,6 +2498,231 @@ var linkedListTyped = (() => {
     }
   };
 
+  // src/common/error.ts
+  var ERR = {
+    // Range / index
+    indexOutOfRange: (index, min, max, ctx) => `${ctx ? ctx + ": " : ""}Index ${index} is out of range [${min}, ${max}].`,
+    invalidIndex: (ctx) => `${ctx ? ctx + ": " : ""}Index must be an integer.`,
+    // Type / argument
+    invalidArgument: (reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`,
+    comparatorRequired: (ctx) => `${ctx ? ctx + ": " : ""}Comparator is required for non-number/non-string/non-Date keys.`,
+    invalidKey: (reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`,
+    notAFunction: (name, ctx) => `${ctx ? ctx + ": " : ""}${name} must be a function.`,
+    invalidEntry: (ctx) => `${ctx ? ctx + ": " : ""}Each entry must be a [key, value] tuple.`,
+    invalidNaN: (ctx) => `${ctx ? ctx + ": " : ""}NaN is not a valid key.`,
+    invalidDate: (ctx) => `${ctx ? ctx + ": " : ""}Invalid Date key.`,
+    reduceEmpty: (ctx) => `${ctx ? ctx + ": " : ""}Reduce of empty structure with no initial value.`,
+    callbackReturnType: (expected, got, ctx) => `${ctx ? ctx + ": " : ""}Callback must return ${expected}; got ${got}.`,
+    // State / operation
+    invalidOperation: (reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`,
+    // Matrix
+    matrixDimensionMismatch: (op) => `Matrix: Dimensions must be compatible for ${op}.`,
+    matrixSingular: () => "Matrix: Singular matrix, inverse does not exist.",
+    matrixNotSquare: () => "Matrix: Must be square for inversion.",
+    matrixNotRectangular: () => "Matrix: Must be rectangular for transposition.",
+    matrixRowMismatch: (expected, got) => `Matrix: Expected row length ${expected}, but got ${got}.`
+  };
+
+  // src/common/index.ts
+  var DFSOperation = /* @__PURE__ */ ((DFSOperation2) => {
+    DFSOperation2[DFSOperation2["VISIT"] = 0] = "VISIT";
+    DFSOperation2[DFSOperation2["PROCESS"] = 1] = "PROCESS";
+    return DFSOperation2;
+  })(DFSOperation || {});
+  var Range = class {
+    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;
+    }
+  };
+
+  // src/data-structures/base/iterable-entry-base.ts
+  var IterableEntryBase = class {
+    /**
+     * 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());
+    }
+  };
+
   // src/data-structures/linked-list/skip-linked-list.ts
   var SkipListNode = class {
     constructor(key, value, level) {
@@ -1955,29 +2731,67 @@ var linkedListTyped = (() => {
       __publicField(this, "forward");
       this.key = key;
       this.value = value;
-      this.forward = new Array(level);
+      this.forward = new Array(level).fill(void 0);
     }
   };
-  var SkipList = class {
-    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;
@@ -1985,129 +2799,593 @@ var linkedListTyped = (() => {
     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;
     }
   };
-
-  // src/common/index.ts
-  var DFSOperation = /* @__PURE__ */ ((DFSOperation2) => {
-    DFSOperation2[DFSOperation2["VISIT"] = 0] = "VISIT";
-    DFSOperation2[DFSOperation2["PROCESS"] = 1] = "PROCESS";
-    return DFSOperation2;
-  })(DFSOperation || {});
-  var Range = class {
-    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;
-    }
-  };
+  _comparator = new WeakMap();
+  _isDefaultComparator = new WeakMap();
+  var SkipList = _SkipList;
   return __toCommonJS(src_exports);
 })();
 /**