directed-graph-typed 2.5.0 → 2.5.1

package/dist/umd/directed-graph-typed.js

@@ -500,6 +500,196 @@ var directedGraphTyped = (() => {
     }
   };
 
+  // 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 {
     /**
@@ -551,6 +741,27 @@ var directedGraphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Track heap capacity
     *  const heap = new Heap<number>();
@@ -614,6 +825,27 @@ var directedGraphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // basic Heap creation and add operation
     *  // Create a min heap (default)
@@ -647,6 +879,27 @@ var directedGraphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Add multiple elements
     *  const heap = new Heap<number>([], { comparator: (a, b) => a - b });
@@ -682,6 +935,27 @@ var directedGraphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Heap with custom comparator (MaxHeap behavior)
     *  interface Task {
@@ -733,6 +1007,27 @@ var directedGraphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Heap for event processing with priority
     *  interface Event {
@@ -809,6 +1104,27 @@ var directedGraphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Check if heap is empty
     *  const heap = new Heap<number>([], { comparator: (a, b) => a - b });
@@ -832,6 +1148,27 @@ var directedGraphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Remove all elements
     *  const heap = new Heap<number>([1, 2, 3], { comparator: (a, b) => a - b });
@@ -858,6 +1195,27 @@ var directedGraphTyped = (() => {
       * @returns True if found.
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Check element existence
     *  const heap = new Heap<number>([3, 1, 2], { comparator: (a, b) => a - b });
@@ -881,6 +1239,27 @@ var directedGraphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Remove specific element
     *  const heap = new Heap<number>([3, 1, 4, 1, 5], { comparator: (a, b) => a - b });
@@ -950,6 +1329,27 @@ var directedGraphTyped = (() => {
       * @returns Array of visited elements.
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Depth-first traversal
     *  const heap = new Heap<number>([3, 1, 2], { comparator: (a, b) => a - b });
@@ -1006,6 +1406,27 @@ var directedGraphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Sort elements using heap
     *  const heap = new Heap<number>([5, 1, 3, 2, 4]);
@@ -1035,6 +1456,27 @@ var directedGraphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Create independent copy
     *  const heap = new Heap<number>([3, 1, 4], { comparator: (a, b) => a - b });
@@ -1063,6 +1505,27 @@ var directedGraphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Filter elements
     *  const heap = new Heap<number>([1, 2, 3, 4, 5], { comparator: (a, b) => a - b });
@@ -1098,6 +1561,27 @@ var directedGraphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Transform elements
     *  const heap = new Heap<number>([1, 2, 3], { comparator: (a, b) => a - b });
@@ -1177,223 +1661,33 @@ var directedGraphTyped = (() => {
      * @param [options] - Options to override comparator or toElementFn.
      * @returns A like-kind empty heap instance.
      */
-    _createInstance(options) {
-      const Ctor = this.constructor;
-      return new Ctor([], { comparator: this.comparator, toElementFn: this.toElementFn, ...options != null ? options : {} });
-    }
-    /**
-     * (Protected) Create a like-kind instance seeded by elements.
-     * @remarks Time O(N log N), Space O(N)
-     * @template EM
-     * @template RM
-     * @param [elements] - Iterable of elements or raw values to seed.
-     * @param [options] - Options forwarded to the constructor.
-     * @returns A like-kind heap instance.
-     */
-    _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);
-    }
-  };
-
-  // 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;
+    _createInstance(options) {
+      const Ctor = this.constructor;
+      return new Ctor([], { comparator: this.comparator, toElementFn: this.toElementFn, ...options != null ? options : {} });
     }
     /**
-     * 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)
+     * (Protected) Create a like-kind instance seeded by elements.
+     * @remarks Time O(N log N), Space O(N)
+     * @template EM
+     * @template RM
+     * @param [elements] - Iterable of elements or raw values to seed.
+     * @param [options] - Options forwarded to the constructor.
+     * @returns A like-kind heap instance.
      */
-    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;
+    _createLike(elements = [], options) {
+      const Ctor = this.constructor;
+      return new Ctor(elements, options);
     }
     /**
-     * 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);
     }
   };
 
@@ -1465,6 +1759,27 @@ var directedGraphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Track queue length
     *  const q = new Queue<number>();
@@ -1491,6 +1806,27 @@ var directedGraphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // View the front element
     *  const q = new Queue<string>(['first', 'second', 'third']);
@@ -1533,6 +1869,27 @@ var directedGraphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Queue for...of iteration and isEmpty check
     *  const queue = new Queue<string>(['A', 'B', 'C', 'D']);
@@ -1571,6 +1928,27 @@ var directedGraphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // basic Queue creation and push operation
     *  // Create a simple Queue with initial values
@@ -1616,6 +1994,27 @@ var directedGraphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Queue shift and peek operations
     *  const queue = new Queue<number>([10, 20, 30, 40]);
@@ -1651,6 +2050,27 @@ var directedGraphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Remove specific element
     *  const q = new Queue<number>([1, 2, 3, 2]);
@@ -1679,6 +2099,27 @@ var directedGraphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Access element by index
     *  const q = new Queue<string>(['a', 'b', 'c']);
@@ -1748,6 +2189,27 @@ var directedGraphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Remove all elements
     *  const q = new Queue<number>([1, 2, 3]);
@@ -1770,6 +2232,27 @@ var directedGraphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Reclaim unused memory
     *  const q = new Queue<number>([1, 2, 3, 4, 5]);
@@ -1815,6 +2298,27 @@ var directedGraphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Create independent copy
     *  const q = new Queue<number>([1, 2, 3]);
@@ -1844,6 +2348,27 @@ var directedGraphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Filter elements
     *  const q = new Queue<number>([1, 2, 3, 4, 5]);
@@ -1877,6 +2402,27 @@ var directedGraphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Transform elements
     *  const q = new Queue<number>([1, 2, 3]);
@@ -2983,6 +3529,27 @@ var directedGraphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Get edge between vertices
     *  const g = new DirectedGraph();
@@ -3047,6 +3614,27 @@ var directedGraphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // DirectedGraph deleteEdge and vertex operations
     *  const graph = new DirectedGraph<string>();
@@ -3109,6 +3697,27 @@ var directedGraphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Remove a vertex
     *  const g = new DirectedGraph();
@@ -3162,6 +3771,27 @@ var directedGraphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Get incoming edges
     *  const g = new DirectedGraph();
@@ -3192,6 +3822,27 @@ var directedGraphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Get outgoing edges
     *  const g = new DirectedGraph();
@@ -3275,6 +3926,27 @@ var directedGraphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // DirectedGraph topologicalSort for task scheduling
     *  const graph = new DirectedGraph<string>();
@@ -3339,6 +4011,27 @@ var directedGraphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Get all edges
     *  const g = new DirectedGraph();
@@ -3365,6 +4058,27 @@ var directedGraphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Get outgoing neighbors
     *  const g = new DirectedGraph();
@@ -3444,6 +4158,27 @@ var directedGraphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Find strongly connected components
     *  const g = new DirectedGraph();
@@ -3526,6 +4261,27 @@ var directedGraphTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Get strongly connected components
     *  const g = new DirectedGraph();