linked-list-typed 2.5.0 → 2.5.2

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

@@ -38,9 +38,61 @@ var linkedListTyped = (() => {
     SinglyLinkedList: () => SinglyLinkedList,
     SinglyLinkedListNode: () => SinglyLinkedListNode,
     SkipList: () => SkipList,
-    SkipListNode: () => SkipListNode
+    SkipListNode: () => SkipListNode,
+    raise: () => raise
   });
 
+  // src/common/error.ts
+  function raise(ErrorClass, message) {
+    throw new ErrorClass(message);
+  }
+  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}.`,
+    // Order statistic
+    orderStatisticNotEnabled: (method, ctx) => `${ctx ? ctx + ": " : ""}${method}() requires enableOrderStatistic: true.`
+  };
+
+  // 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-element-base.ts
   var IterableElementBase = class {
     /**
@@ -63,7 +115,7 @@ var linkedListTyped = (() => {
       if (options) {
         const { toElementFn } = options;
         if (typeof toElementFn === "function") this._toElementFn = toElementFn;
-        else if (toElementFn) throw new TypeError("toElementFn must be a function type");
+        else if (toElementFn) raise(TypeError, "toElementFn must be a function type");
       }
     }
     /**
@@ -219,7 +271,7 @@ var linkedListTyped = (() => {
         acc = initialValue;
       } else {
         const first = iter.next();
-        if (first.done) throw new TypeError("Reduce of empty structure with no initial value");
+        if (first.done) raise(TypeError, "Reduce of empty structure with no initial value");
         acc = first.value;
         index = 1;
       }
@@ -762,6 +814,30 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // basic SinglyLinkedList creation and push operation
     *  // Create a simple SinglyLinkedList with initial values
@@ -805,6 +881,30 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // SinglyLinkedList pop and shift operations
     *  const list = new SinglyLinkedList<number>([10, 20, 30, 40, 50]);
@@ -854,6 +954,30 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Remove from the front
     *  const list = new SinglyLinkedList<number>([10, 20, 30]);
@@ -884,6 +1008,30 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // SinglyLinkedList unshift and forward traversal
     *  const list = new SinglyLinkedList<number>([20, 30, 40]);
@@ -975,6 +1123,30 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Access element by index
     *  const list = new SinglyLinkedList<string>(['a', 'b', 'c', 'd']);
@@ -1010,6 +1182,30 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Get node at index
     *  const list = new SinglyLinkedList<string>(['a', 'b', 'c']);
@@ -1034,6 +1230,30 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Remove by index
     *  const list = new SinglyLinkedList<string>(['a', 'b', 'c']);
@@ -1064,6 +1284,30 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Remove first occurrence
     *  const list = new SinglyLinkedList<number>([1, 2, 3, 2]);
@@ -1099,24 +1343,48 @@ var linkedListTyped = (() => {
       
       
       
-       * @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);
-      if (index === this._length) return this.push(newElementOrNode);
-      const newNode = this._ensureNode(newElementOrNode);
-      const prevNode = this.getNodeAt(index - 1);
-      newNode.next = prevNode.next;
-      prevNode.next = newNode;
-      this._length++;
-      return true;
-    }
-    /**
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+       * @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);
+      if (index === this._length) return this.push(newElementOrNode);
+      const newNode = this._ensureNode(newElementOrNode);
+      const prevNode = this.getNodeAt(index - 1);
+      newNode.next = prevNode.next;
+      prevNode.next = newNode;
+      this._length++;
+      return true;
+    }
+    /**
      * Set the element value at an index.
      * @remarks Time O(N), Space O(1)
      * @param index - Zero-based index.
@@ -1142,6 +1410,30 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Check empty
     *  console.log(new SinglyLinkedList().isEmpty()); // true;
@@ -1162,6 +1454,30 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Remove all
     *  const list = new SinglyLinkedList<number>([1, 2, 3]);
@@ -1188,6 +1504,30 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Reverse the list in-place
     *  const list = new SinglyLinkedList<number>([1, 2, 3, 4]);
@@ -1380,6 +1720,30 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Deep copy
     *  const list = new SinglyLinkedList<number>([1, 2, 3]);
@@ -1410,6 +1774,30 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // SinglyLinkedList filter and map operations
     *  const list = new SinglyLinkedList<number>([1, 2, 3, 4, 5]);
@@ -1468,6 +1856,30 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Transform elements
     *  const list = new SinglyLinkedList<number>([1, 2, 3]);
@@ -1759,6 +2171,30 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // basic DoublyLinkedList creation and push operation
     *  // Create a simple DoublyLinkedList with initial values
@@ -1804,6 +2240,30 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // DoublyLinkedList pop and shift operations
     *  const list = new DoublyLinkedList<number>([10, 20, 30, 40, 50]);
@@ -1848,28 +2308,52 @@ var linkedListTyped = (() => {
       
       
       
-       * @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;
-      if (this.head === this.tail) {
-        this._head = void 0;
-        this._tail = void 0;
-      } else {
-        this._head = removed.next;
-        this.head.prev = void 0;
-      }
-      this._length--;
-      return removed.value;
-    }
-    /**
-      * Prepend an element/node to the head.
-      * @remarks Time O(1), Space O(1)
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+       * @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;
+      if (this.head === this.tail) {
+        this._head = void 0;
+        this._tail = void 0;
+      } else {
+        this._head = removed.next;
+        this.head.prev = void 0;
+      }
+      this._length--;
+      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.
       
@@ -1883,6 +2367,30 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Add to the front
     *  const list = new DoublyLinkedList<number>([2, 3]);
@@ -1947,6 +2455,30 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Access by index
     *  const list = new DoublyLinkedList<string>(['a', 'b', 'c']);
@@ -1972,6 +2504,30 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Get node at index
     *  const list = new DoublyLinkedList<string>(['a', 'b', 'c']);
@@ -2028,6 +2584,30 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Insert at position
     *  const list = new DoublyLinkedList<number>([1, 3]);
@@ -2112,6 +2692,30 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Remove by index
     *  const list = new DoublyLinkedList<string>(['a', 'b', 'c']);
@@ -2143,6 +2747,30 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Remove first occurrence
     *  const list = new DoublyLinkedList<number>([1, 2, 3, 2]);
@@ -2176,6 +2804,30 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Check empty
     *  console.log(new DoublyLinkedList().isEmpty()); // true;
@@ -2196,6 +2848,30 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Remove all
     *  const list = new DoublyLinkedList<number>([1, 2]);
@@ -2220,24 +2896,48 @@ var linkedListTyped = (() => {
       
       
       
-       * @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;
-      while (current) {
-        if (predicate(current)) return current.value;
-        current = current.next;
-      }
-      return void 0;
-    }
-    /**
-      * Find the first value matching a predicate scanning backward.
-      * @remarks Time O(N), Space O(1)
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+       * @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;
+      while (current) {
+        if (predicate(current)) return current.value;
+        current = current.next;
+      }
+      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.
       
@@ -2248,6 +2948,30 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Find value scanning from tail
     *  const list = new DoublyLinkedList<number>([1, 2, 3, 4]);
@@ -2279,6 +3003,30 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Reverse in-place
     *  const list = new DoublyLinkedList<number>([1, 2, 3]);
@@ -2318,6 +3066,30 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Deep copy
     *  const list = new DoublyLinkedList<number>([1, 2, 3]);
@@ -2347,6 +3119,30 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Filter elements
     *  const list = new DoublyLinkedList<number>([1, 2, 3, 4, 5]);
@@ -2395,6 +3191,30 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // DoublyLinkedList for...of iteration and map operation
     *  const list = new DoublyLinkedList<number>([1, 2, 3, 4, 5]);
@@ -2498,52 +3318,6 @@ 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 {
     /**
@@ -2759,7 +3533,7 @@ var linkedListTyped = (() => {
           [k, v] = toEntryFn(item);
         } else {
           if (!Array.isArray(item) || item.length < 2) {
-            throw new TypeError(ERR.invalidEntry("SkipList"));
+            raise(TypeError, ERR.invalidEntry("SkipList"));
           }
           [k, v] = item;
         }
@@ -2772,7 +3546,7 @@ var linkedListTyped = (() => {
     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"));
+          if (Number.isNaN(a) || Number.isNaN(b)) raise(TypeError, ERR.invalidNaN("SkipList"));
           return a - b;
         }
         if (typeof a === "string" && typeof b === "string") {
@@ -2780,13 +3554,13 @@ var linkedListTyped = (() => {
         }
         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"));
+          if (Number.isNaN(ta) || Number.isNaN(tb)) raise(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"));
+        raise(TypeError, ERR.comparatorRequired("SkipList"));
       };
     }
     // ─── Size & lifecycle ────────────────────────────────────────
@@ -2812,6 +3586,30 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Check if empty
     *  const sl = new SkipList<number, string>();
@@ -2830,6 +3628,30 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Remove all entries
     *  const sl = new SkipList<number, string>([[1, 'a'], [2, 'b']]);
@@ -2851,7 +3673,31 @@ var linkedListTyped = (() => {
       
       
       
-       * @example
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+       * @example
     * // Create independent copy
     *  const sl = new SkipList<number, string>([[1, 'a'], [2, 'b']]);
     *     const copy = sl.clone();
@@ -2880,6 +3726,30 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // In-memory sorted key-value store
     *  const store = new SkipList<number, string>();
@@ -2934,6 +3804,30 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Building a sorted index
     *  type Product = { id: number; name: string; price: number };
@@ -2943,8 +3837,8 @@ var linkedListTyped = (() => {
     *       { id: 3, name: 'Doohickey', price: 15 }
     *     ];
     *
-    *     const index = new SkipList<number, Product>(products as any, {
-    *       toEntryFn: (p: any) => [p.price, p]
+    *     const index = new SkipList<number, Product, Product>(products, {
+    *       toEntryFn: (p: Product) => [p.price, p]
     *     });
     *
     *     // Iterate in sorted order by price
@@ -2973,6 +3867,30 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Check key existence
     *  const sl = new SkipList<number, string>([[1, 'a'], [3, 'c'], [5, 'e']]);
@@ -2995,6 +3913,30 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Fast lookup with deletion
     *  const cache = new SkipList<string, number>();
@@ -3037,6 +3979,30 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Access the minimum entry
     *  const sl = new SkipList<number, string>([[5, 'e'], [1, 'a'], [3, 'c']]);
@@ -3059,6 +4025,30 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Access the maximum entry
     *  const sl = new SkipList<number, string>([[5, 'e'], [1, 'a'], [3, 'c']]);
@@ -3083,6 +4073,30 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Remove and return smallest
     *  const sl = new SkipList<number, string>([[1, 'a'], [2, 'b'], [3, 'c']]);
@@ -3105,6 +4119,30 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Remove and return largest
     *  const sl = new SkipList<number, string>([[1, 'a'], [2, 'b'], [3, 'c']]);
@@ -3130,6 +4168,30 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Least entry ≥ key
     *  const sl = new SkipList<number, string>([[10, 'a'], [20, 'b'], [30, 'c']]);
@@ -3160,6 +4222,30 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Greatest entry ≤ key
     *  const sl = new SkipList<number, string>([[10, 'a'], [20, 'b'], [30, 'c']]);
@@ -3188,6 +4274,30 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Strictly greater entry
     *  const sl = new SkipList<number, string>([[10, 'a'], [20, 'b'], [30, 'c']]);
@@ -3215,6 +4325,30 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Strictly less entry
     *  const sl = new SkipList<number, string>([[10, 'a'], [20, 'b'], [30, 'c']]);
@@ -3248,6 +4382,30 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Find entries in a range
     *  const sl = new SkipList<number, string>([[1, 'a'], [2, 'b'], [3, 'c'], [4, 'd'], [5, 'e']]);
@@ -3289,6 +4447,30 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Transform entries
     *  const sl = new SkipList<number, string>([[1, 'a'], [2, 'b']]);
@@ -3314,6 +4496,30 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Filter entries
     *  const sl = new SkipList<number, string>([[1, 'a'], [2, 'b'], [3, 'c']]);