linked-list-typed 2.5.0 → 2.5.2

package/dist/cjs-legacy/index.cjs

@@ -12,6 +12,60 @@ var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read fr
 var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value), value);
 
+// src/common/error.ts
+function raise(ErrorClass, message) {
+  throw new ErrorClass(message);
+}
+__name(raise, "raise");
+var ERR = {
+  // Range / index
+  indexOutOfRange: /* @__PURE__ */ __name((index, min, max, ctx) => `${ctx ? ctx + ": " : ""}Index ${index} is out of range [${min}, ${max}].`, "indexOutOfRange"),
+  invalidIndex: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Index must be an integer.`, "invalidIndex"),
+  // Type / argument
+  invalidArgument: /* @__PURE__ */ __name((reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`, "invalidArgument"),
+  comparatorRequired: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Comparator is required for non-number/non-string/non-Date keys.`, "comparatorRequired"),
+  invalidKey: /* @__PURE__ */ __name((reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`, "invalidKey"),
+  notAFunction: /* @__PURE__ */ __name((name, ctx) => `${ctx ? ctx + ": " : ""}${name} must be a function.`, "notAFunction"),
+  invalidEntry: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Each entry must be a [key, value] tuple.`, "invalidEntry"),
+  invalidNaN: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}NaN is not a valid key.`, "invalidNaN"),
+  invalidDate: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Invalid Date key.`, "invalidDate"),
+  reduceEmpty: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Reduce of empty structure with no initial value.`, "reduceEmpty"),
+  callbackReturnType: /* @__PURE__ */ __name((expected, got, ctx) => `${ctx ? ctx + ": " : ""}Callback must return ${expected}; got ${got}.`, "callbackReturnType"),
+  // State / operation
+  invalidOperation: /* @__PURE__ */ __name((reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`, "invalidOperation"),
+  // Matrix
+  matrixDimensionMismatch: /* @__PURE__ */ __name((op) => `Matrix: Dimensions must be compatible for ${op}.`, "matrixDimensionMismatch"),
+  matrixSingular: /* @__PURE__ */ __name(() => "Matrix: Singular matrix, inverse does not exist.", "matrixSingular"),
+  matrixNotSquare: /* @__PURE__ */ __name(() => "Matrix: Must be square for inversion.", "matrixNotSquare"),
+  matrixNotRectangular: /* @__PURE__ */ __name(() => "Matrix: Must be rectangular for transposition.", "matrixNotRectangular"),
+  matrixRowMismatch: /* @__PURE__ */ __name((expected, got) => `Matrix: Expected row length ${expected}, but got ${got}.`, "matrixRowMismatch"),
+  // Order statistic
+  orderStatisticNotEnabled: /* @__PURE__ */ __name((method, ctx) => `${ctx ? ctx + ": " : ""}${method}() requires enableOrderStatistic: true.`, "orderStatisticNotEnabled")
+};
+
+// src/common/index.ts
+var DFSOperation = /* @__PURE__ */ ((DFSOperation2) => {
+  DFSOperation2[DFSOperation2["VISIT"] = 0] = "VISIT";
+  DFSOperation2[DFSOperation2["PROCESS"] = 1] = "PROCESS";
+  return DFSOperation2;
+})(DFSOperation || {});
+var _Range = class _Range {
+  constructor(low, high, includeLow = true, includeHigh = true) {
+    this.low = low;
+    this.high = high;
+    this.includeLow = includeLow;
+    this.includeHigh = includeHigh;
+  }
+  // Determine whether a key is within the range
+  isInRange(key, comparator) {
+    const lowCheck = this.includeLow ? comparator(key, this.low) >= 0 : comparator(key, this.low) > 0;
+    const highCheck = this.includeHigh ? comparator(key, this.high) <= 0 : comparator(key, this.high) < 0;
+    return lowCheck && highCheck;
+  }
+};
+__name(_Range, "Range");
+var Range = _Range;
+
 // src/data-structures/base/iterable-element-base.ts
 var _IterableElementBase = class _IterableElementBase {
   /**
@@ -34,7 +88,7 @@ var _IterableElementBase = class _IterableElementBase {
     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");
     }
   }
   /**
@@ -190,7 +244,7 @@ var _IterableElementBase = class _IterableElementBase {
       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;
     }
@@ -743,6 +797,30 @@ var _SinglyLinkedList = class _SinglyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // basic SinglyLinkedList creation and push operation
   *  // Create a simple SinglyLinkedList with initial values
@@ -786,6 +864,30 @@ var _SinglyLinkedList = class _SinglyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // SinglyLinkedList pop and shift operations
   *  const list = new SinglyLinkedList<number>([10, 20, 30, 40, 50]);
@@ -835,6 +937,30 @@ var _SinglyLinkedList = class _SinglyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Remove from the front
   *  const list = new SinglyLinkedList<number>([10, 20, 30]);
@@ -865,6 +991,30 @@ var _SinglyLinkedList = class _SinglyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // SinglyLinkedList unshift and forward traversal
   *  const list = new SinglyLinkedList<number>([20, 30, 40]);
@@ -956,6 +1106,30 @@ var _SinglyLinkedList = class _SinglyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Access element by index
   *  const list = new SinglyLinkedList<string>(['a', 'b', 'c', 'd']);
@@ -991,6 +1165,30 @@ var _SinglyLinkedList = class _SinglyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Get node at index
   *  const list = new SinglyLinkedList<string>(['a', 'b', 'c']);
@@ -1015,6 +1213,30 @@ var _SinglyLinkedList = class _SinglyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Remove by index
   *  const list = new SinglyLinkedList<string>(['a', 'b', 'c']);
@@ -1045,6 +1267,30 @@ var _SinglyLinkedList = class _SinglyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Remove first occurrence
   *  const list = new SinglyLinkedList<number>([1, 2, 3, 2]);
@@ -1080,22 +1326,46 @@ var _SinglyLinkedList = class _SinglyLinkedList extends LinearLinkedBase {
     
     
     
-     * @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.
@@ -1123,6 +1393,30 @@ var _SinglyLinkedList = class _SinglyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Check empty
   *  console.log(new SinglyLinkedList().isEmpty()); // true;
@@ -1143,6 +1437,30 @@ var _SinglyLinkedList = class _SinglyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Remove all
   *  const list = new SinglyLinkedList<number>([1, 2, 3]);
@@ -1169,6 +1487,30 @@ var _SinglyLinkedList = class _SinglyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Reverse the list in-place
   *  const list = new SinglyLinkedList<number>([1, 2, 3, 4]);
@@ -1361,6 +1703,30 @@ var _SinglyLinkedList = class _SinglyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Deep copy
   *  const list = new SinglyLinkedList<number>([1, 2, 3]);
@@ -1391,6 +1757,30 @@ var _SinglyLinkedList = class _SinglyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // SinglyLinkedList filter and map operations
   *  const list = new SinglyLinkedList<number>([1, 2, 3, 4, 5]);
@@ -1449,6 +1839,30 @@ var _SinglyLinkedList = class _SinglyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Transform elements
   *  const list = new SinglyLinkedList<number>([1, 2, 3]);
@@ -1745,6 +2159,30 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // basic DoublyLinkedList creation and push operation
   *  // Create a simple DoublyLinkedList with initial values
@@ -1790,6 +2228,30 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // DoublyLinkedList pop and shift operations
   *  const list = new DoublyLinkedList<number>([10, 20, 30, 40, 50]);
@@ -1834,6 +2296,30 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Remove from the front
   *  const list = new DoublyLinkedList<number>([10, 20, 30]);
@@ -1869,6 +2355,30 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Add to the front
   *  const list = new DoublyLinkedList<number>([2, 3]);
@@ -1933,6 +2443,30 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Access by index
   *  const list = new DoublyLinkedList<string>(['a', 'b', 'c']);
@@ -1958,6 +2492,30 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Get node at index
   *  const list = new DoublyLinkedList<string>(['a', 'b', 'c']);
@@ -2014,6 +2572,30 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Insert at position
   *  const list = new DoublyLinkedList<number>([1, 3]);
@@ -2098,6 +2680,30 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Remove by index
   *  const list = new DoublyLinkedList<string>(['a', 'b', 'c']);
@@ -2129,6 +2735,30 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Remove first occurrence
   *  const list = new DoublyLinkedList<number>([1, 2, 3, 2]);
@@ -2162,6 +2792,30 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Check empty
   *  console.log(new DoublyLinkedList().isEmpty()); // true;
@@ -2182,6 +2836,30 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Remove all
   *  const list = new DoublyLinkedList<number>([1, 2]);
@@ -2206,6 +2884,30 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Search with predicate
   *  const list = new DoublyLinkedList<number>([10, 20, 30]);
@@ -2234,6 +2936,30 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Find value scanning from tail
   *  const list = new DoublyLinkedList<number>([1, 2, 3, 4]);
@@ -2265,22 +2991,46 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
     
     
     
-     * @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];
-    while (current) {
-      const next = current.next;
-      [current.prev, current.next] = [current.next, current.prev];
-      current = next;
-    }
-    return this;
-  }
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @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];
+    while (current) {
+      const next = current.next;
+      [current.prev, current.next] = [current.next, current.prev];
+      current = next;
+    }
+    return this;
+  }
   /**
    * Set the equality comparator used to compare values.
    * @remarks Time O(1), Space O(1)
@@ -2304,6 +3054,30 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Deep copy
   *  const list = new DoublyLinkedList<number>([1, 2, 3]);
@@ -2333,6 +3107,30 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Filter elements
   *  const list = new DoublyLinkedList<number>([1, 2, 3, 4, 5]);
@@ -2381,6 +3179,30 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // DoublyLinkedList for...of iteration and map operation
   *  const list = new DoublyLinkedList<number>([1, 2, 3, 4, 5]);
@@ -2486,54 +3308,6 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
 __name(_DoublyLinkedList, "DoublyLinkedList");
 var DoublyLinkedList = _DoublyLinkedList;
 
-// src/common/error.ts
-var ERR = {
-  // Range / index
-  indexOutOfRange: /* @__PURE__ */ __name((index, min, max, ctx) => `${ctx ? ctx + ": " : ""}Index ${index} is out of range [${min}, ${max}].`, "indexOutOfRange"),
-  invalidIndex: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Index must be an integer.`, "invalidIndex"),
-  // Type / argument
-  invalidArgument: /* @__PURE__ */ __name((reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`, "invalidArgument"),
-  comparatorRequired: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Comparator is required for non-number/non-string/non-Date keys.`, "comparatorRequired"),
-  invalidKey: /* @__PURE__ */ __name((reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`, "invalidKey"),
-  notAFunction: /* @__PURE__ */ __name((name, ctx) => `${ctx ? ctx + ": " : ""}${name} must be a function.`, "notAFunction"),
-  invalidEntry: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Each entry must be a [key, value] tuple.`, "invalidEntry"),
-  invalidNaN: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}NaN is not a valid key.`, "invalidNaN"),
-  invalidDate: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Invalid Date key.`, "invalidDate"),
-  reduceEmpty: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Reduce of empty structure with no initial value.`, "reduceEmpty"),
-  callbackReturnType: /* @__PURE__ */ __name((expected, got, ctx) => `${ctx ? ctx + ": " : ""}Callback must return ${expected}; got ${got}.`, "callbackReturnType"),
-  // State / operation
-  invalidOperation: /* @__PURE__ */ __name((reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`, "invalidOperation"),
-  // Matrix
-  matrixDimensionMismatch: /* @__PURE__ */ __name((op) => `Matrix: Dimensions must be compatible for ${op}.`, "matrixDimensionMismatch"),
-  matrixSingular: /* @__PURE__ */ __name(() => "Matrix: Singular matrix, inverse does not exist.", "matrixSingular"),
-  matrixNotSquare: /* @__PURE__ */ __name(() => "Matrix: Must be square for inversion.", "matrixNotSquare"),
-  matrixNotRectangular: /* @__PURE__ */ __name(() => "Matrix: Must be rectangular for transposition.", "matrixNotRectangular"),
-  matrixRowMismatch: /* @__PURE__ */ __name((expected, got) => `Matrix: Expected row length ${expected}, but got ${got}.`, "matrixRowMismatch")
-};
-
-// src/common/index.ts
-var DFSOperation = /* @__PURE__ */ ((DFSOperation2) => {
-  DFSOperation2[DFSOperation2["VISIT"] = 0] = "VISIT";
-  DFSOperation2[DFSOperation2["PROCESS"] = 1] = "PROCESS";
-  return DFSOperation2;
-})(DFSOperation || {});
-var _Range = class _Range {
-  constructor(low, high, includeLow = true, includeHigh = true) {
-    this.low = low;
-    this.high = high;
-    this.includeLow = includeLow;
-    this.includeHigh = includeHigh;
-  }
-  // Determine whether a key is within the range
-  isInRange(key, comparator) {
-    const lowCheck = this.includeLow ? comparator(key, this.low) >= 0 : comparator(key, this.low) > 0;
-    const highCheck = this.includeHigh ? comparator(key, this.high) <= 0 : comparator(key, this.high) < 0;
-    return lowCheck && highCheck;
-  }
-};
-__name(_Range, "Range");
-var Range = _Range;
-
 // src/data-structures/base/iterable-entry-base.ts
 var _IterableEntryBase = class _IterableEntryBase {
   /**
@@ -2753,7 +3527,7 @@ var _SkipList = class _SkipList extends IterableEntryBase {
         [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;
       }
@@ -2766,7 +3540,7 @@ var _SkipList = class _SkipList extends IterableEntryBase {
   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") {
@@ -2774,13 +3548,13 @@ var _SkipList = class _SkipList extends IterableEntryBase {
       }
       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 ────────────────────────────────────────
@@ -2806,6 +3580,30 @@ var _SkipList = class _SkipList extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Check if empty
   *  const sl = new SkipList<number, string>();
@@ -2824,6 +3622,30 @@ var _SkipList = class _SkipList extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Remove all entries
   *  const sl = new SkipList<number, string>([[1, 'a'], [2, 'b']]);
@@ -2845,6 +3667,30 @@ var _SkipList = class _SkipList extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Create independent copy
   *  const sl = new SkipList<number, string>([[1, 'a'], [2, 'b']]);
@@ -2874,6 +3720,30 @@ var _SkipList = class _SkipList extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // In-memory sorted key-value store
   *  const store = new SkipList<number, string>();
@@ -2928,7 +3798,31 @@ var _SkipList = class _SkipList extends IterableEntryBase {
     
     
     
-     * @example
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
   * // Building a sorted index
   *  type Product = { id: number; name: string; price: number };
   *     const products: Product[] = [
@@ -2937,8 +3831,8 @@ var _SkipList = class _SkipList extends IterableEntryBase {
   *       { 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
@@ -2967,6 +3861,30 @@ var _SkipList = class _SkipList extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Check key existence
   *  const sl = new SkipList<number, string>([[1, 'a'], [3, 'c'], [5, 'e']]);
@@ -2989,6 +3907,30 @@ var _SkipList = class _SkipList extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Fast lookup with deletion
   *  const cache = new SkipList<string, number>();
@@ -3031,6 +3973,30 @@ var _SkipList = class _SkipList extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Access the minimum entry
   *  const sl = new SkipList<number, string>([[5, 'e'], [1, 'a'], [3, 'c']]);
@@ -3053,6 +4019,30 @@ var _SkipList = class _SkipList extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Access the maximum entry
   *  const sl = new SkipList<number, string>([[5, 'e'], [1, 'a'], [3, 'c']]);
@@ -3077,6 +4067,30 @@ var _SkipList = class _SkipList extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Remove and return smallest
   *  const sl = new SkipList<number, string>([[1, 'a'], [2, 'b'], [3, 'c']]);
@@ -3099,6 +4113,30 @@ var _SkipList = class _SkipList extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Remove and return largest
   *  const sl = new SkipList<number, string>([[1, 'a'], [2, 'b'], [3, 'c']]);
@@ -3124,6 +4162,30 @@ var _SkipList = class _SkipList extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Least entry ≥ key
   *  const sl = new SkipList<number, string>([[10, 'a'], [20, 'b'], [30, 'c']]);
@@ -3154,6 +4216,30 @@ var _SkipList = class _SkipList extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Greatest entry ≤ key
   *  const sl = new SkipList<number, string>([[10, 'a'], [20, 'b'], [30, 'c']]);
@@ -3182,6 +4268,30 @@ var _SkipList = class _SkipList extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Strictly greater entry
   *  const sl = new SkipList<number, string>([[10, 'a'], [20, 'b'], [30, 'c']]);
@@ -3209,6 +4319,30 @@ var _SkipList = class _SkipList extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Strictly less entry
   *  const sl = new SkipList<number, string>([[10, 'a'], [20, 'b'], [30, 'c']]);
@@ -3242,6 +4376,30 @@ var _SkipList = class _SkipList extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Find entries in a range
   *  const sl = new SkipList<number, string>([[1, 'a'], [2, 'b'], [3, 'c'], [4, 'd'], [5, 'e']]);
@@ -3283,6 +4441,30 @@ var _SkipList = class _SkipList extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Transform entries
   *  const sl = new SkipList<number, string>([[1, 'a'], [2, 'b']]);
@@ -3308,6 +4490,30 @@ var _SkipList = class _SkipList extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Filter entries
   *  const sl = new SkipList<number, string>([[1, 'a'], [2, 'b'], [3, 'c']]);
@@ -3398,5 +4604,6 @@ exports.SinglyLinkedList = SinglyLinkedList;
 exports.SinglyLinkedListNode = SinglyLinkedListNode;
 exports.SkipList = SkipList;
 exports.SkipListNode = SkipListNode;
+exports.raise = raise;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map