graph-typed 2.5.0 → 2.5.2

package/dist/esm-legacy/index.mjs

@@ -25,6 +25,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"),
@@ -46,7 +50,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
@@ -275,7 +281,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");
     }
   }
   /**
@@ -431,7 +437,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;
     }
@@ -475,6 +481,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 {
   /**
@@ -490,7 +688,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;
@@ -526,6 +724,30 @@ var _Heap = class _Heap extends IterableElementBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Track heap capacity
   *  const heap = new Heap<number>();
@@ -589,6 +811,30 @@ var _Heap = class _Heap extends IterableElementBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // basic Heap creation and add operation
   *  // Create a min heap (default)
@@ -622,6 +868,30 @@ var _Heap = class _Heap extends IterableElementBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Add multiple elements
   *  const heap = new Heap<number>([], { comparator: (a, b) => a - b });
@@ -657,6 +927,30 @@ var _Heap = class _Heap extends IterableElementBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Heap with custom comparator (MaxHeap behavior)
   *  interface Task {
@@ -708,6 +1002,30 @@ var _Heap = class _Heap extends IterableElementBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Heap for event processing with priority
   *  interface Event {
@@ -784,6 +1102,30 @@ var _Heap = class _Heap extends IterableElementBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Check if heap is empty
   *  const heap = new Heap<number>([], { comparator: (a, b) => a - b });
@@ -807,6 +1149,30 @@ var _Heap = class _Heap extends IterableElementBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Remove all elements
   *  const heap = new Heap<number>([1, 2, 3], { comparator: (a, b) => a - b });
@@ -833,6 +1199,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 });
@@ -856,6 +1246,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 });
@@ -925,6 +1339,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 });
@@ -981,6 +1419,30 @@ var _Heap = class _Heap extends IterableElementBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Sort elements using heap
   *  const heap = new Heap<number>([5, 1, 3, 2, 4]);
@@ -1010,6 +1472,30 @@ var _Heap = class _Heap extends IterableElementBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Create independent copy
   *  const heap = new Heap<number>([3, 1, 4], { comparator: (a, b) => a - b });
@@ -1038,6 +1524,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 });
@@ -1073,6 +1583,30 @@ var _Heap = class _Heap extends IterableElementBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Transform elements
   *  const heap = new Heap<number>([1, 2, 3], { comparator: (a, b) => a - b });
@@ -1081,7 +1615,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) {
@@ -1168,213 +1702,21 @@ var _Heap = class _Heap extends IterableElementBase {
   _createLike(elements = [], options) {
     const Ctor = this.constructor;
     return new Ctor(elements, options);
-  }
-  /**
-   * (Protected) Spawn an empty like-kind heap instance.
-   * @remarks Time O(1), Space O(1)
-   * @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)
+  }
+  /**
+   * (Protected) Spawn an empty like-kind heap instance.
+   * @remarks Time O(1), Space O(1)
+   * @template EM
+   * @template RM
+   * @param [options] - Options forwarded to the constructor.
+   * @returns An empty like-kind heap instance.
    */
-  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;
+  _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 {
@@ -1444,6 +1786,30 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Track queue length
   *  const q = new Queue<number>();
@@ -1470,6 +1836,30 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // View the front element
   *  const q = new Queue<string>(['first', 'second', 'third']);
@@ -1512,6 +1902,30 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Queue for...of iteration and isEmpty check
   *  const queue = new Queue<string>(['A', 'B', 'C', 'D']);
@@ -1550,6 +1964,30 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // basic Queue creation and push operation
   *  // Create a simple Queue with initial values
@@ -1595,6 +2033,30 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Queue shift and peek operations
   *  const queue = new Queue<number>([10, 20, 30, 40]);
@@ -1630,6 +2092,30 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Remove specific element
   *  const q = new Queue<number>([1, 2, 3, 2]);
@@ -1658,6 +2144,30 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Access element by index
   *  const q = new Queue<string>(['a', 'b', 'c']);
@@ -1727,6 +2237,30 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Remove all elements
   *  const q = new Queue<number>([1, 2, 3]);
@@ -1749,6 +2283,30 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Reclaim unused memory
   *  const q = new Queue<number>([1, 2, 3, 4, 5]);
@@ -1794,6 +2352,30 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Create independent copy
   *  const q = new Queue<number>([1, 2, 3]);
@@ -1823,6 +2405,30 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Filter elements
   *  const q = new Queue<number>([1, 2, 3, 4, 5]);
@@ -1856,6 +2462,30 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Transform elements
   *  const q = new Queue<number>([1, 2, 3]);
@@ -2090,7 +2720,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"));
       }
     }
   }
@@ -2974,6 +3604,30 @@ var _DirectedGraph = class _DirectedGraph extends AbstractGraph {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Get edge between vertices
   *  const g = new DirectedGraph();
@@ -3038,6 +3692,30 @@ var _DirectedGraph = class _DirectedGraph extends AbstractGraph {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // DirectedGraph deleteEdge and vertex operations
   *  const graph = new DirectedGraph<string>();
@@ -3100,6 +3778,30 @@ var _DirectedGraph = class _DirectedGraph extends AbstractGraph {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Remove a vertex
   *  const g = new DirectedGraph();
@@ -3153,6 +3855,30 @@ var _DirectedGraph = class _DirectedGraph extends AbstractGraph {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Get incoming edges
   *  const g = new DirectedGraph();
@@ -3183,6 +3909,30 @@ var _DirectedGraph = class _DirectedGraph extends AbstractGraph {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Get outgoing edges
   *  const g = new DirectedGraph();
@@ -3266,6 +4016,30 @@ var _DirectedGraph = class _DirectedGraph extends AbstractGraph {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // DirectedGraph topologicalSort for task scheduling
   *  const graph = new DirectedGraph<string>();
@@ -3330,6 +4104,30 @@ var _DirectedGraph = class _DirectedGraph extends AbstractGraph {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Get all edges
   *  const g = new DirectedGraph();
@@ -3356,6 +4154,30 @@ var _DirectedGraph = class _DirectedGraph extends AbstractGraph {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Get outgoing neighbors
   *  const g = new DirectedGraph();
@@ -3435,6 +4257,30 @@ var _DirectedGraph = class _DirectedGraph extends AbstractGraph {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Find strongly connected components
   *  const g = new DirectedGraph();
@@ -3517,6 +4363,30 @@ var _DirectedGraph = class _DirectedGraph extends AbstractGraph {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Get strongly connected components
   *  const g = new DirectedGraph();
@@ -3663,6 +4533,30 @@ var _UndirectedGraph = class _UndirectedGraph extends AbstractGraph {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Get edge between vertices
   *  const g = new UndirectedGraph();
@@ -3724,6 +4618,30 @@ var _UndirectedGraph = class _UndirectedGraph extends AbstractGraph {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // UndirectedGraph deleteEdge and vertex operations
   *  const graph = new UndirectedGraph<string>();
@@ -3784,6 +4702,30 @@ var _UndirectedGraph = class _UndirectedGraph extends AbstractGraph {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Remove vertex and edges
   *  const g = new UndirectedGraph();
@@ -3859,6 +4801,30 @@ var _UndirectedGraph = class _UndirectedGraph extends AbstractGraph {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Get all edges
   *  const g = new UndirectedGraph();
@@ -3889,6 +4855,30 @@ var _UndirectedGraph = class _UndirectedGraph extends AbstractGraph {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // UndirectedGraph connectivity and neighbors
   *  const graph = new UndirectedGraph<string>();
@@ -3989,6 +4979,30 @@ var _UndirectedGraph = class _UndirectedGraph extends AbstractGraph {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Find articulation points and bridges
   *  const g = new UndirectedGraph();
@@ -4111,6 +5125,30 @@ var _UndirectedGraph = class _UndirectedGraph extends AbstractGraph {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Detect cycle
   *  const g = new UndirectedGraph();
@@ -4155,6 +5193,30 @@ var _UndirectedGraph = class _UndirectedGraph extends AbstractGraph {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Find bridge edges
   *  const g = new UndirectedGraph();
@@ -4181,6 +5243,30 @@ var _UndirectedGraph = class _UndirectedGraph extends AbstractGraph {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Find articulation points
   *  const g = new UndirectedGraph();
@@ -4339,6 +5425,6 @@ var MapGraph = _MapGraph;
  * @license MIT License
  */
 
-export { AbstractEdge, AbstractGraph, AbstractVertex, DFSOperation, DirectedEdge, DirectedGraph, DirectedVertex, ERR, MapEdge, MapGraph, MapVertex, Range, UndirectedEdge, UndirectedGraph, UndirectedVertex };
+export { AbstractEdge, AbstractGraph, AbstractVertex, DFSOperation, DirectedEdge, DirectedGraph, DirectedVertex, ERR, MapEdge, MapGraph, MapVertex, Range, UndirectedEdge, UndirectedGraph, UndirectedVertex, raise };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map