graph-typed 2.5.0 → 2.5.2

package/dist/umd/graph-typed.js

@@ -37,7 +37,8 @@ var graphTyped = (() => {
     Range: () => Range,
     UndirectedEdge: () => UndirectedEdge,
     UndirectedGraph: () => UndirectedGraph,
-    UndirectedVertex: () => UndirectedVertex
+    UndirectedVertex: () => UndirectedVertex,
+    raise: () => raise
   });
 
   // src/utils/utils.ts
@@ -62,6 +63,9 @@ var graphTyped = (() => {
   };
 
   // src/common/error.ts
+  function raise(ErrorClass, message) {
+    throw new ErrorClass(message);
+  }
   var ERR = {
     // Range / index
     indexOutOfRange: (index, min, max, ctx) => `${ctx ? ctx + ": " : ""}Index ${index} is out of range [${min}, ${max}].`,
@@ -83,7 +87,9 @@ var graphTyped = (() => {
     matrixSingular: () => "Matrix: Singular matrix, inverse does not exist.",
     matrixNotSquare: () => "Matrix: Must be square for inversion.",
     matrixNotRectangular: () => "Matrix: Must be rectangular for transposition.",
-    matrixRowMismatch: (expected, got) => `Matrix: Expected row length ${expected}, but got ${got}.`
+    matrixRowMismatch: (expected, got) => `Matrix: Expected row length ${expected}, but got ${got}.`,
+    // Order statistic
+    orderStatisticNotEnabled: (method, ctx) => `${ctx ? ctx + ": " : ""}${method}() requires enableOrderStatistic: true.`
   };
 
   // src/common/index.ts
@@ -308,7 +314,7 @@ var graphTyped = (() => {
       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");
       }
     }
     /**
@@ -464,7 +470,7 @@ var graphTyped = (() => {
         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;
       }
@@ -506,6 +512,196 @@ var graphTyped = (() => {
     }
   };
 
+  // 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;
+    }
+  };
+
   // src/data-structures/heap/heap.ts
   var Heap = class _Heap extends IterableElementBase {
     /**
@@ -521,7 +717,7 @@ var graphTyped = (() => {
       __publicField(this, "_elements", []);
       __publicField(this, "_DEFAULT_COMPARATOR", (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;
@@ -557,6 +753,30 @@ var graphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Track heap capacity
     *  const heap = new Heap<number>();
@@ -620,6 +840,30 @@ var graphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // basic Heap creation and add operation
     *  // Create a min heap (default)
@@ -653,6 +897,30 @@ var graphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Add multiple elements
     *  const heap = new Heap<number>([], { comparator: (a, b) => a - b });
@@ -688,6 +956,30 @@ var graphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Heap with custom comparator (MaxHeap behavior)
     *  interface Task {
@@ -739,6 +1031,30 @@ var graphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Heap for event processing with priority
     *  interface Event {
@@ -815,6 +1131,30 @@ var graphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Check if heap is empty
     *  const heap = new Heap<number>([], { comparator: (a, b) => a - b });
@@ -838,6 +1178,30 @@ var graphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Remove all elements
     *  const heap = new Heap<number>([1, 2, 3], { comparator: (a, b) => a - b });
@@ -864,6 +1228,30 @@ var graphTyped = (() => {
       * @returns True if found.
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Check element existence
     *  const heap = new Heap<number>([3, 1, 2], { comparator: (a, b) => a - b });
@@ -887,6 +1275,30 @@ var graphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Remove specific element
     *  const heap = new Heap<number>([3, 1, 4, 1, 5], { comparator: (a, b) => a - b });
@@ -956,6 +1368,30 @@ var graphTyped = (() => {
       * @returns Array of visited elements.
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Depth-first traversal
     *  const heap = new Heap<number>([3, 1, 2], { comparator: (a, b) => a - b });
@@ -1012,6 +1448,30 @@ var graphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Sort elements using heap
     *  const heap = new Heap<number>([5, 1, 3, 2, 4]);
@@ -1041,6 +1501,30 @@ var graphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Create independent copy
     *  const heap = new Heap<number>([3, 1, 4], { comparator: (a, b) => a - b });
@@ -1069,6 +1553,30 @@ var graphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Filter elements
     *  const heap = new Heap<number>([1, 2, 3, 4, 5], { comparator: (a, b) => a - b });
@@ -1104,6 +1612,30 @@ var graphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Transform elements
     *  const heap = new Heap<number>([1, 2, 3], { comparator: (a, b) => a - b });
@@ -1112,7 +1644,7 @@ var graphTyped = (() => {
       */
     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) {
@@ -1201,205 +1733,15 @@ var graphTyped = (() => {
       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);
-    }
-  };
-
-  // 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);
     }
   };
 
@@ -1471,6 +1813,30 @@ var graphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Track queue length
     *  const q = new Queue<number>();
@@ -1497,6 +1863,30 @@ var graphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // View the front element
     *  const q = new Queue<string>(['first', 'second', 'third']);
@@ -1539,6 +1929,30 @@ var graphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Queue for...of iteration and isEmpty check
     *  const queue = new Queue<string>(['A', 'B', 'C', 'D']);
@@ -1577,6 +1991,30 @@ var graphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // basic Queue creation and push operation
     *  // Create a simple Queue with initial values
@@ -1622,6 +2060,30 @@ var graphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Queue shift and peek operations
     *  const queue = new Queue<number>([10, 20, 30, 40]);
@@ -1657,6 +2119,30 @@ var graphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Remove specific element
     *  const q = new Queue<number>([1, 2, 3, 2]);
@@ -1685,6 +2171,30 @@ var graphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Access element by index
     *  const q = new Queue<string>(['a', 'b', 'c']);
@@ -1754,6 +2264,30 @@ var graphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Remove all elements
     *  const q = new Queue<number>([1, 2, 3]);
@@ -1776,6 +2310,30 @@ var graphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Reclaim unused memory
     *  const q = new Queue<number>([1, 2, 3, 4, 5]);
@@ -1821,6 +2379,30 @@ var graphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Create independent copy
     *  const q = new Queue<number>([1, 2, 3]);
@@ -1850,6 +2432,30 @@ var graphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Filter elements
     *  const q = new Queue<number>([1, 2, 3, 4, 5]);
@@ -1883,6 +2489,30 @@ var graphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Transform elements
     *  const q = new Queue<number>([1, 2, 3]);
@@ -2111,7 +2741,7 @@ var graphTyped = (() => {
           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"));
         }
       }
     }
@@ -2989,6 +3619,30 @@ var graphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Get edge between vertices
     *  const g = new DirectedGraph();
@@ -3053,6 +3707,30 @@ var graphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // DirectedGraph deleteEdge and vertex operations
     *  const graph = new DirectedGraph<string>();
@@ -3115,6 +3793,30 @@ var graphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Remove a vertex
     *  const g = new DirectedGraph();
@@ -3168,6 +3870,30 @@ var graphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Get incoming edges
     *  const g = new DirectedGraph();
@@ -3198,6 +3924,30 @@ var graphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Get outgoing edges
     *  const g = new DirectedGraph();
@@ -3281,6 +4031,30 @@ var graphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // DirectedGraph topologicalSort for task scheduling
     *  const graph = new DirectedGraph<string>();
@@ -3345,6 +4119,30 @@ var graphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Get all edges
     *  const g = new DirectedGraph();
@@ -3371,6 +4169,30 @@ var graphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Get outgoing neighbors
     *  const g = new DirectedGraph();
@@ -3450,6 +4272,30 @@ var graphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Find strongly connected components
     *  const g = new DirectedGraph();
@@ -3532,6 +4378,30 @@ var graphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Get strongly connected components
     *  const g = new DirectedGraph();
@@ -3672,6 +4542,30 @@ var graphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Get edge between vertices
     *  const g = new UndirectedGraph();
@@ -3733,6 +4627,30 @@ var graphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // UndirectedGraph deleteEdge and vertex operations
     *  const graph = new UndirectedGraph<string>();
@@ -3793,6 +4711,30 @@ var graphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Remove vertex and edges
     *  const g = new UndirectedGraph();
@@ -3868,6 +4810,30 @@ var graphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Get all edges
     *  const g = new UndirectedGraph();
@@ -3898,6 +4864,30 @@ var graphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // UndirectedGraph connectivity and neighbors
     *  const graph = new UndirectedGraph<string>();
@@ -3998,6 +4988,30 @@ var graphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Find articulation points and bridges
     *  const g = new UndirectedGraph();
@@ -4120,6 +5134,30 @@ var graphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Detect cycle
     *  const g = new UndirectedGraph();
@@ -4164,6 +5202,30 @@ var graphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Find bridge edges
     *  const g = new UndirectedGraph();
@@ -4190,6 +5252,30 @@ var graphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Find articulation points
     *  const g = new UndirectedGraph();