undirected-graph-typed 2.5.0 → 2.5.2

package/dist/cjs-legacy/index.cjs

@@ -27,6 +27,10 @@ var arrayRemove = /* @__PURE__ */ __name(function(array, predicate) {
 }, "arrayRemove");
 
 // 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"),
@@ -48,7 +52,9 @@ var ERR = {
   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")
+  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
@@ -277,7 +283,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");
     }
   }
   /**
@@ -433,7 +439,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;
     }
@@ -477,6 +483,198 @@ var _IterableElementBase = class _IterableElementBase {
 __name(_IterableElementBase, "IterableElementBase");
 var IterableElementBase = _IterableElementBase;
 
+// src/data-structures/base/linear-base.ts
+var _LinearBase = class _LinearBase extends IterableElementBase {
+  /**
+   * Construct a linear container with runtime options.
+   * @param options - `{ maxLen?, ... }` bounds/behavior options.
+   * @remarks Time O(1), Space O(1)
+   */
+  constructor(options) {
+    super(options);
+    __publicField(this, "_maxLen", -1);
+    if (options) {
+      const { maxLen } = options;
+      if (typeof maxLen === "number" && maxLen > 0 && maxLen % 1 === 0) this._maxLen = maxLen;
+    }
+  }
+  /**
+   * Upper bound for length (if positive), or `-1` when unbounded.
+   * @returns Maximum allowed length.
+   * @remarks Time O(1), Space O(1)
+   */
+  get maxLen() {
+    return this._maxLen;
+  }
+  /**
+   * First index of a value from the left.
+   * @param searchElement - Value to match.
+   * @param fromIndex - Start position (supports negative index).
+   * @returns Index or `-1` if not found.
+   * @remarks Time O(n), Space O(1)
+   */
+  indexOf(searchElement, fromIndex = 0) {
+    if (this.length === 0) return -1;
+    if (fromIndex < 0) fromIndex = this.length + fromIndex;
+    if (fromIndex < 0) fromIndex = 0;
+    for (let i = fromIndex; i < this.length; i++) {
+      const element = this.at(i);
+      if (element === searchElement) return i;
+    }
+    return -1;
+  }
+  /**
+   * Last index of a value from the right.
+   * @param searchElement - Value to match.
+   * @param fromIndex - Start position (supports negative index).
+   * @returns Index or `-1` if not found.
+   * @remarks Time O(n), Space O(1)
+   */
+  lastIndexOf(searchElement, fromIndex = this.length - 1) {
+    if (this.length === 0) return -1;
+    if (fromIndex >= this.length) fromIndex = this.length - 1;
+    if (fromIndex < 0) fromIndex = this.length + fromIndex;
+    for (let i = fromIndex; i >= 0; i--) {
+      const element = this.at(i);
+      if (element === searchElement) return i;
+    }
+    return -1;
+  }
+  /**
+   * Find the first index matching a predicate.
+   * @param predicate - `(element, index, self) => boolean`.
+   * @param thisArg - Optional `this` for callback.
+   * @returns Index or `-1`.
+   * @remarks Time O(n), Space O(1)
+   */
+  findIndex(predicate, thisArg) {
+    for (let i = 0; i < this.length; i++) {
+      const item = this.at(i);
+      if (item !== void 0 && predicate.call(thisArg, item, i, this)) return i;
+    }
+    return -1;
+  }
+  /**
+   * Concatenate elements and/or containers.
+   * @param items - Elements or other containers.
+   * @returns New container with combined elements (`this` type).
+   * @remarks Time O(sum(length)), Space O(sum(length))
+   */
+  concat(...items) {
+    const newList = this.clone();
+    for (const item of items) {
+      if (item instanceof _LinearBase) {
+        newList.pushMany(item);
+      } else {
+        newList.push(item);
+      }
+    }
+    return newList;
+  }
+  /**
+   * In-place stable order via array sort semantics.
+   * @param compareFn - Comparator `(a, b) => number`.
+   * @returns This container.
+   * @remarks Time O(n log n), Space O(n) (materializes to array temporarily)
+   */
+  sort(compareFn) {
+    const arr = this.toArray();
+    arr.sort(compareFn);
+    this.clear();
+    for (const item of arr) this.push(item);
+    return this;
+  }
+  /**
+   * Remove and/or insert elements at a position (array-compatible).
+   * @param start - Start index (supports negative index).
+   * @param deleteCount - How many to remove.
+   * @param items - Elements to insert.
+   * @returns Removed elements as a new list (`this` type).
+   * @remarks Time O(n + m), Space O(min(n, m)) where `m = items.length`
+   */
+  splice(start, deleteCount = 0, ...items) {
+    const removedList = this._createInstance();
+    start = start < 0 ? this.length + start : start;
+    start = Math.max(0, Math.min(start, this.length));
+    deleteCount = Math.max(0, Math.min(deleteCount, this.length - start));
+    for (let i = 0; i < deleteCount; i++) {
+      const removed = this.deleteAt(start);
+      if (removed !== void 0) {
+        removedList.push(removed);
+      }
+    }
+    for (let i = 0; i < items.length; i++) {
+      this.addAt(start + i, items[i]);
+    }
+    return removedList;
+  }
+  /**
+   * Join all elements into a string.
+   * @param separator - Separator string.
+   * @returns Concatenated string.
+   * @remarks Time O(n), Space O(n)
+   */
+  join(separator = ",") {
+    return this.toArray().join(separator);
+  }
+  /**
+   * Snapshot elements into a reversed array.
+   * @returns New reversed array.
+   * @remarks Time O(n), Space O(n)
+   */
+  toReversedArray() {
+    const array = [];
+    for (let i = this.length - 1; i >= 0; i--) {
+      array.push(this.at(i));
+    }
+    return array;
+  }
+  reduceRight(callbackfn, initialValue) {
+    let accumulator = initialValue != null ? initialValue : 0;
+    for (let i = this.length - 1; i >= 0; i--) {
+      accumulator = callbackfn(accumulator, this.at(i), i, this);
+    }
+    return accumulator;
+  }
+  /**
+   * Create a shallow copy of a subrange.
+   * @param start - Inclusive start (supports negative index).
+   * @param end - Exclusive end (supports negative index).
+   * @returns New list with the range (`this` type).
+   * @remarks Time O(n), Space O(n)
+   */
+  slice(start = 0, end = this.length) {
+    start = start < 0 ? this.length + start : start;
+    end = end < 0 ? this.length + end : end;
+    const newList = this._createInstance();
+    for (let i = start; i < end; i++) {
+      newList.push(this.at(i));
+    }
+    return newList;
+  }
+  /**
+   * Fill a range with a value.
+   * @param value - Value to set.
+   * @param start - Inclusive start.
+   * @param end - Exclusive end.
+   * @returns This list.
+   * @remarks Time O(n), Space O(1)
+   */
+  fill(value, start = 0, end = this.length) {
+    start = start < 0 ? this.length + start : start;
+    end = end < 0 ? this.length + end : end;
+    if (start < 0) start = 0;
+    if (end > this.length) end = this.length;
+    if (start >= end) return this;
+    for (let i = start; i < end; i++) {
+      this.setAt(i, value);
+    }
+    return this;
+  }
+};
+__name(_LinearBase, "LinearBase");
+var LinearBase = _LinearBase;
+
 // src/data-structures/heap/heap.ts
 var _Heap = class _Heap extends IterableElementBase {
   /**
@@ -492,7 +690,7 @@ var _Heap = class _Heap extends IterableElementBase {
     __publicField(this, "_elements", []);
     __publicField(this, "_DEFAULT_COMPARATOR", /* @__PURE__ */ __name((a, b) => {
       if (typeof a === "object" || typeof b === "object") {
-        throw new TypeError(ERR.comparatorRequired("Heap"));
+        raise(TypeError, ERR.comparatorRequired("Heap"));
       }
       if (a > b) return 1;
       if (a < b) return -1;
@@ -528,6 +726,30 @@ var _Heap = class _Heap extends IterableElementBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Track heap capacity
   *  const heap = new Heap<number>();
@@ -591,6 +813,30 @@ var _Heap = class _Heap extends IterableElementBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // basic Heap creation and add operation
   *  // Create a min heap (default)
@@ -624,6 +870,30 @@ var _Heap = class _Heap extends IterableElementBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Add multiple elements
   *  const heap = new Heap<number>([], { comparator: (a, b) => a - b });
@@ -659,6 +929,30 @@ var _Heap = class _Heap extends IterableElementBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Heap with custom comparator (MaxHeap behavior)
   *  interface Task {
@@ -710,6 +1004,30 @@ var _Heap = class _Heap extends IterableElementBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Heap for event processing with priority
   *  interface Event {
@@ -786,6 +1104,30 @@ var _Heap = class _Heap extends IterableElementBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Check if heap is empty
   *  const heap = new Heap<number>([], { comparator: (a, b) => a - b });
@@ -809,6 +1151,30 @@ var _Heap = class _Heap extends IterableElementBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Remove all elements
   *  const heap = new Heap<number>([1, 2, 3], { comparator: (a, b) => a - b });
@@ -835,6 +1201,30 @@ var _Heap = class _Heap extends IterableElementBase {
     * @returns True if found.
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Check element existence
   *  const heap = new Heap<number>([3, 1, 2], { comparator: (a, b) => a - b });
@@ -858,6 +1248,30 @@ var _Heap = class _Heap extends IterableElementBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Remove specific element
   *  const heap = new Heap<number>([3, 1, 4, 1, 5], { comparator: (a, b) => a - b });
@@ -927,6 +1341,30 @@ var _Heap = class _Heap extends IterableElementBase {
     * @returns Array of visited elements.
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Depth-first traversal
   *  const heap = new Heap<number>([3, 1, 2], { comparator: (a, b) => a - b });
@@ -983,6 +1421,30 @@ var _Heap = class _Heap extends IterableElementBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Sort elements using heap
   *  const heap = new Heap<number>([5, 1, 3, 2, 4]);
@@ -1012,6 +1474,30 @@ var _Heap = class _Heap extends IterableElementBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Create independent copy
   *  const heap = new Heap<number>([3, 1, 4], { comparator: (a, b) => a - b });
@@ -1040,6 +1526,30 @@ var _Heap = class _Heap extends IterableElementBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Filter elements
   *  const heap = new Heap<number>([1, 2, 3, 4, 5], { comparator: (a, b) => a - b });
@@ -1075,6 +1585,30 @@ var _Heap = class _Heap extends IterableElementBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Transform elements
   *  const heap = new Heap<number>([1, 2, 3], { comparator: (a, b) => a - b });
@@ -1083,7 +1617,7 @@ var _Heap = class _Heap extends IterableElementBase {
     */
   map(callback, options, thisArg) {
     const { comparator, toElementFn, ...rest } = options != null ? options : {};
-    if (!comparator) throw new TypeError(ERR.comparatorRequired("Heap.map"));
+    if (!comparator) raise(TypeError, ERR.comparatorRequired("Heap.map"));
     const out = this._createLike([], { ...rest, comparator, toElementFn });
     let i = 0;
     for (const x of this) {
@@ -1177,206 +1711,14 @@ var _Heap = class _Heap extends IterableElementBase {
    * @template EM
    * @template RM
    * @param [options] - Options forwarded to the constructor.
-   * @returns An empty like-kind heap instance.
-   */
-  _spawnLike(options) {
-    return this._createLike([], options);
-  }
-};
-__name(_Heap, "Heap");
-var Heap = _Heap;
-
-// src/data-structures/base/linear-base.ts
-var _LinearBase = class _LinearBase extends IterableElementBase {
-  /**
-   * Construct a linear container with runtime options.
-   * @param options - `{ maxLen?, ... }` bounds/behavior options.
-   * @remarks Time O(1), Space O(1)
-   */
-  constructor(options) {
-    super(options);
-    __publicField(this, "_maxLen", -1);
-    if (options) {
-      const { maxLen } = options;
-      if (typeof maxLen === "number" && maxLen > 0 && maxLen % 1 === 0) this._maxLen = maxLen;
-    }
-  }
-  /**
-   * Upper bound for length (if positive), or `-1` when unbounded.
-   * @returns Maximum allowed length.
-   * @remarks Time O(1), Space O(1)
-   */
-  get maxLen() {
-    return this._maxLen;
-  }
-  /**
-   * First index of a value from the left.
-   * @param searchElement - Value to match.
-   * @param fromIndex - Start position (supports negative index).
-   * @returns Index or `-1` if not found.
-   * @remarks Time O(n), Space O(1)
-   */
-  indexOf(searchElement, fromIndex = 0) {
-    if (this.length === 0) return -1;
-    if (fromIndex < 0) fromIndex = this.length + fromIndex;
-    if (fromIndex < 0) fromIndex = 0;
-    for (let i = fromIndex; i < this.length; i++) {
-      const element = this.at(i);
-      if (element === searchElement) return i;
-    }
-    return -1;
-  }
-  /**
-   * Last index of a value from the right.
-   * @param searchElement - Value to match.
-   * @param fromIndex - Start position (supports negative index).
-   * @returns Index or `-1` if not found.
-   * @remarks Time O(n), Space O(1)
-   */
-  lastIndexOf(searchElement, fromIndex = this.length - 1) {
-    if (this.length === 0) return -1;
-    if (fromIndex >= this.length) fromIndex = this.length - 1;
-    if (fromIndex < 0) fromIndex = this.length + fromIndex;
-    for (let i = fromIndex; i >= 0; i--) {
-      const element = this.at(i);
-      if (element === searchElement) return i;
-    }
-    return -1;
-  }
-  /**
-   * Find the first index matching a predicate.
-   * @param predicate - `(element, index, self) => boolean`.
-   * @param thisArg - Optional `this` for callback.
-   * @returns Index or `-1`.
-   * @remarks Time O(n), Space O(1)
-   */
-  findIndex(predicate, thisArg) {
-    for (let i = 0; i < this.length; i++) {
-      const item = this.at(i);
-      if (item !== void 0 && predicate.call(thisArg, item, i, this)) return i;
-    }
-    return -1;
-  }
-  /**
-   * Concatenate elements and/or containers.
-   * @param items - Elements or other containers.
-   * @returns New container with combined elements (`this` type).
-   * @remarks Time O(sum(length)), Space O(sum(length))
-   */
-  concat(...items) {
-    const newList = this.clone();
-    for (const item of items) {
-      if (item instanceof _LinearBase) {
-        newList.pushMany(item);
-      } else {
-        newList.push(item);
-      }
-    }
-    return newList;
-  }
-  /**
-   * In-place stable order via array sort semantics.
-   * @param compareFn - Comparator `(a, b) => number`.
-   * @returns This container.
-   * @remarks Time O(n log n), Space O(n) (materializes to array temporarily)
-   */
-  sort(compareFn) {
-    const arr = this.toArray();
-    arr.sort(compareFn);
-    this.clear();
-    for (const item of arr) this.push(item);
-    return this;
-  }
-  /**
-   * Remove and/or insert elements at a position (array-compatible).
-   * @param start - Start index (supports negative index).
-   * @param deleteCount - How many to remove.
-   * @param items - Elements to insert.
-   * @returns Removed elements as a new list (`this` type).
-   * @remarks Time O(n + m), Space O(min(n, m)) where `m = items.length`
-   */
-  splice(start, deleteCount = 0, ...items) {
-    const removedList = this._createInstance();
-    start = start < 0 ? this.length + start : start;
-    start = Math.max(0, Math.min(start, this.length));
-    deleteCount = Math.max(0, Math.min(deleteCount, this.length - start));
-    for (let i = 0; i < deleteCount; i++) {
-      const removed = this.deleteAt(start);
-      if (removed !== void 0) {
-        removedList.push(removed);
-      }
-    }
-    for (let i = 0; i < items.length; i++) {
-      this.addAt(start + i, items[i]);
-    }
-    return removedList;
-  }
-  /**
-   * Join all elements into a string.
-   * @param separator - Separator string.
-   * @returns Concatenated string.
-   * @remarks Time O(n), Space O(n)
-   */
-  join(separator = ",") {
-    return this.toArray().join(separator);
-  }
-  /**
-   * Snapshot elements into a reversed array.
-   * @returns New reversed array.
-   * @remarks Time O(n), Space O(n)
-   */
-  toReversedArray() {
-    const array = [];
-    for (let i = this.length - 1; i >= 0; i--) {
-      array.push(this.at(i));
-    }
-    return array;
-  }
-  reduceRight(callbackfn, initialValue) {
-    let accumulator = initialValue != null ? initialValue : 0;
-    for (let i = this.length - 1; i >= 0; i--) {
-      accumulator = callbackfn(accumulator, this.at(i), i, this);
-    }
-    return accumulator;
-  }
-  /**
-   * Create a shallow copy of a subrange.
-   * @param start - Inclusive start (supports negative index).
-   * @param end - Exclusive end (supports negative index).
-   * @returns New list with the range (`this` type).
-   * @remarks Time O(n), Space O(n)
-   */
-  slice(start = 0, end = this.length) {
-    start = start < 0 ? this.length + start : start;
-    end = end < 0 ? this.length + end : end;
-    const newList = this._createInstance();
-    for (let i = start; i < end; i++) {
-      newList.push(this.at(i));
-    }
-    return newList;
-  }
-  /**
-   * Fill a range with a value.
-   * @param value - Value to set.
-   * @param start - Inclusive start.
-   * @param end - Exclusive end.
-   * @returns This list.
-   * @remarks Time O(n), Space O(1)
-   */
-  fill(value, start = 0, end = this.length) {
-    start = start < 0 ? this.length + start : start;
-    end = end < 0 ? this.length + end : end;
-    if (start < 0) start = 0;
-    if (end > this.length) end = this.length;
-    if (start >= end) return this;
-    for (let i = start; i < end; i++) {
-      this.setAt(i, value);
-    }
-    return this;
+   * @returns An empty like-kind heap instance.
+   */
+  _spawnLike(options) {
+    return this._createLike([], options);
   }
 };
-__name(_LinearBase, "LinearBase");
-var LinearBase = _LinearBase;
+__name(_Heap, "Heap");
+var Heap = _Heap;
 
 // src/data-structures/queue/queue.ts
 var _Queue = class _Queue extends LinearBase {
@@ -1446,6 +1788,30 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Track queue length
   *  const q = new Queue<number>();
@@ -1472,6 +1838,30 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // View the front element
   *  const q = new Queue<string>(['first', 'second', 'third']);
@@ -1514,6 +1904,30 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Queue for...of iteration and isEmpty check
   *  const queue = new Queue<string>(['A', 'B', 'C', 'D']);
@@ -1552,6 +1966,30 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // basic Queue creation and push operation
   *  // Create a simple Queue with initial values
@@ -1597,6 +2035,30 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Queue shift and peek operations
   *  const queue = new Queue<number>([10, 20, 30, 40]);
@@ -1632,6 +2094,30 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Remove specific element
   *  const q = new Queue<number>([1, 2, 3, 2]);
@@ -1660,6 +2146,30 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Access element by index
   *  const q = new Queue<string>(['a', 'b', 'c']);
@@ -1729,6 +2239,30 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Remove all elements
   *  const q = new Queue<number>([1, 2, 3]);
@@ -1751,6 +2285,30 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Reclaim unused memory
   *  const q = new Queue<number>([1, 2, 3, 4, 5]);
@@ -1796,6 +2354,30 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Create independent copy
   *  const q = new Queue<number>([1, 2, 3]);
@@ -1825,6 +2407,30 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Filter elements
   *  const q = new Queue<number>([1, 2, 3, 4, 5]);
@@ -1858,6 +2464,30 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Transform elements
   *  const q = new Queue<number>([1, 2, 3]);
@@ -2092,7 +2722,7 @@ var _AbstractGraph = class _AbstractGraph extends IterableEntryBase {
         const newEdge = this.createEdge(srcOrEdge, dest, weight, value);
         return this._addEdge(newEdge);
       } else {
-        throw new TypeError(ERR.invalidArgument("dest must be a Vertex or vertex key when srcOrEdge is an Edge.", "Graph"));
+        raise(TypeError, ERR.invalidArgument("dest must be a Vertex or vertex key when srcOrEdge is an Edge.", "Graph"));
       }
     }
   }
@@ -2965,6 +3595,30 @@ var _UndirectedGraph = class _UndirectedGraph extends AbstractGraph {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Get edge between vertices
   *  const g = new UndirectedGraph();
@@ -3026,6 +3680,30 @@ var _UndirectedGraph = class _UndirectedGraph extends AbstractGraph {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // UndirectedGraph deleteEdge and vertex operations
   *  const graph = new UndirectedGraph<string>();
@@ -3086,6 +3764,30 @@ var _UndirectedGraph = class _UndirectedGraph extends AbstractGraph {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Remove vertex and edges
   *  const g = new UndirectedGraph();
@@ -3161,6 +3863,30 @@ var _UndirectedGraph = class _UndirectedGraph extends AbstractGraph {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Get all edges
   *  const g = new UndirectedGraph();
@@ -3191,6 +3917,30 @@ var _UndirectedGraph = class _UndirectedGraph extends AbstractGraph {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // UndirectedGraph connectivity and neighbors
   *  const graph = new UndirectedGraph<string>();
@@ -3291,6 +4041,30 @@ var _UndirectedGraph = class _UndirectedGraph extends AbstractGraph {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Find articulation points and bridges
   *  const g = new UndirectedGraph();
@@ -3413,6 +4187,30 @@ var _UndirectedGraph = class _UndirectedGraph extends AbstractGraph {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Detect cycle
   *  const g = new UndirectedGraph();
@@ -3457,6 +4255,30 @@ var _UndirectedGraph = class _UndirectedGraph extends AbstractGraph {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Find bridge edges
   *  const g = new UndirectedGraph();
@@ -3483,6 +4305,30 @@ var _UndirectedGraph = class _UndirectedGraph extends AbstractGraph {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Find articulation points
   *  const g = new UndirectedGraph();
@@ -3552,5 +4398,6 @@ exports.Range = Range;
 exports.UndirectedEdge = UndirectedEdge;
 exports.UndirectedGraph = UndirectedGraph;
 exports.UndirectedVertex = UndirectedVertex;
+exports.raise = raise;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map