graph-typed 2.5.0 → 2.5.1

package/dist/cjs-legacy/index.cjs

@@ -477,6 +477,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 {
   /**
@@ -528,6 +720,27 @@ var _Heap = class _Heap extends IterableElementBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Track heap capacity
   *  const heap = new Heap<number>();
@@ -591,6 +804,27 @@ var _Heap = class _Heap extends IterableElementBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // basic Heap creation and add operation
   *  // Create a min heap (default)
@@ -624,6 +858,27 @@ var _Heap = class _Heap extends IterableElementBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Add multiple elements
   *  const heap = new Heap<number>([], { comparator: (a, b) => a - b });
@@ -659,7 +914,28 @@ var _Heap = class _Heap extends IterableElementBase {
     
     
     
-     * @example
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
   * // Heap with custom comparator (MaxHeap behavior)
   *  interface Task {
   *       id: number;
@@ -710,6 +986,27 @@ var _Heap = class _Heap extends IterableElementBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Heap for event processing with priority
   *  interface Event {
@@ -786,6 +1083,27 @@ var _Heap = class _Heap extends IterableElementBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Check if heap is empty
   *  const heap = new Heap<number>([], { comparator: (a, b) => a - b });
@@ -809,6 +1127,27 @@ var _Heap = class _Heap extends IterableElementBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Remove all elements
   *  const heap = new Heap<number>([1, 2, 3], { comparator: (a, b) => a - b });
@@ -835,6 +1174,27 @@ var _Heap = class _Heap extends IterableElementBase {
     * @returns True if found.
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Check element existence
   *  const heap = new Heap<number>([3, 1, 2], { comparator: (a, b) => a - b });
@@ -858,6 +1218,27 @@ var _Heap = class _Heap extends IterableElementBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Remove specific element
   *  const heap = new Heap<number>([3, 1, 4, 1, 5], { comparator: (a, b) => a - b });
@@ -927,6 +1308,27 @@ var _Heap = class _Heap extends IterableElementBase {
     * @returns Array of visited elements.
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Depth-first traversal
   *  const heap = new Heap<number>([3, 1, 2], { comparator: (a, b) => a - b });
@@ -983,6 +1385,27 @@ var _Heap = class _Heap extends IterableElementBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Sort elements using heap
   *  const heap = new Heap<number>([5, 1, 3, 2, 4]);
@@ -1012,6 +1435,27 @@ var _Heap = class _Heap extends IterableElementBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Create independent copy
   *  const heap = new Heap<number>([3, 1, 4], { comparator: (a, b) => a - b });
@@ -1040,6 +1484,27 @@ var _Heap = class _Heap extends IterableElementBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Filter elements
   *  const heap = new Heap<number>([1, 2, 3, 4, 5], { comparator: (a, b) => a - b });
@@ -1075,6 +1540,27 @@ var _Heap = class _Heap extends IterableElementBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Transform elements
   *  const heap = new Heap<number>([1, 2, 3], { comparator: (a, b) => a - b });
@@ -1106,277 +1592,85 @@ var _Heap = class _Heap extends IterableElementBase {
       const v = thisArg === void 0 ? callback(x, i++, this) : callback.call(thisArg, x, i++, this);
       out.add(v);
     }
-    return out;
-  }
-  /**
-   * Get the comparator used to order elements.
-   * @remarks Time O(1), Space O(1)
-   * @returns Comparator function.
-   */
-  get comparator() {
-    return this._comparator;
-  }
-  *_getIterator() {
-    for (const element of this.elements) yield element;
-  }
-  _bubbleUp(index) {
-    const element = this.elements[index];
-    while (index > 0) {
-      const parent = index - 1 >> 1;
-      const parentItem = this.elements[parent];
-      if (this.comparator(parentItem, element) <= 0) break;
-      this.elements[index] = parentItem;
-      index = parent;
-    }
-    this.elements[index] = element;
-    return true;
-  }
-  _sinkDown(index, halfLength) {
-    const element = this.elements[index];
-    while (index < halfLength) {
-      let left = index << 1 | 1;
-      const right = left + 1;
-      let minItem = this.elements[left];
-      if (right < this.elements.length && this.comparator(minItem, this.elements[right]) > 0) {
-        left = right;
-        minItem = this.elements[right];
-      }
-      if (this.comparator(minItem, element) >= 0) break;
-      this.elements[index] = minItem;
-      index = left;
-    }
-    this.elements[index] = element;
-    return true;
-  }
-  /**
-   * (Protected) Create an empty instance of the same concrete class.
-   * @remarks Time O(1), Space O(1)
-   * @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);
-  }
-};
-__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;
+    return out;
   }
   /**
-   * Join all elements into a string.
-   * @param separator - Separator string.
-   * @returns Concatenated string.
-   * @remarks Time O(n), Space O(n)
+   * Get the comparator used to order elements.
+   * @remarks Time O(1), Space O(1)
+   * @returns Comparator function.
    */
-  join(separator = ",") {
-    return this.toArray().join(separator);
+  get comparator() {
+    return this._comparator;
   }
-  /**
-   * 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));
+  *_getIterator() {
+    for (const element of this.elements) yield element;
+  }
+  _bubbleUp(index) {
+    const element = this.elements[index];
+    while (index > 0) {
+      const parent = index - 1 >> 1;
+      const parentItem = this.elements[parent];
+      if (this.comparator(parentItem, element) <= 0) break;
+      this.elements[index] = parentItem;
+      index = parent;
     }
-    return array;
+    this.elements[index] = element;
+    return true;
   }
-  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);
+  _sinkDown(index, halfLength) {
+    const element = this.elements[index];
+    while (index < halfLength) {
+      let left = index << 1 | 1;
+      const right = left + 1;
+      let minItem = this.elements[left];
+      if (right < this.elements.length && this.comparator(minItem, this.elements[right]) > 0) {
+        left = right;
+        minItem = this.elements[right];
+      }
+      if (this.comparator(minItem, element) >= 0) break;
+      this.elements[index] = minItem;
+      index = left;
     }
-    return accumulator;
+    this.elements[index] = element;
+    return true;
   }
   /**
-   * 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 an empty instance of the same concrete class.
+   * @remarks Time O(1), Space O(1)
+   * @param [options] - Options to override comparator or toElementFn.
+   * @returns A like-kind empty 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;
+  _createInstance(options) {
+    const Ctor = this.constructor;
+    return new Ctor([], { comparator: this.comparator, toElementFn: this.toElementFn, ...options != null ? 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) 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.
    */
-  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;
+  _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(_LinearBase, "LinearBase");
-var LinearBase = _LinearBase;
+__name(_Heap, "Heap");
+var Heap = _Heap;
 
 // src/data-structures/queue/queue.ts
 var _Queue = class _Queue extends LinearBase {
@@ -1446,6 +1740,27 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Track queue length
   *  const q = new Queue<number>();
@@ -1472,6 +1787,27 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // View the front element
   *  const q = new Queue<string>(['first', 'second', 'third']);
@@ -1514,6 +1850,27 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Queue for...of iteration and isEmpty check
   *  const queue = new Queue<string>(['A', 'B', 'C', 'D']);
@@ -1552,6 +1909,27 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // basic Queue creation and push operation
   *  // Create a simple Queue with initial values
@@ -1597,6 +1975,27 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Queue shift and peek operations
   *  const queue = new Queue<number>([10, 20, 30, 40]);
@@ -1632,6 +2031,27 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Remove specific element
   *  const q = new Queue<number>([1, 2, 3, 2]);
@@ -1660,6 +2080,27 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Access element by index
   *  const q = new Queue<string>(['a', 'b', 'c']);
@@ -1729,6 +2170,27 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Remove all elements
   *  const q = new Queue<number>([1, 2, 3]);
@@ -1751,6 +2213,27 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Reclaim unused memory
   *  const q = new Queue<number>([1, 2, 3, 4, 5]);
@@ -1796,6 +2279,27 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Create independent copy
   *  const q = new Queue<number>([1, 2, 3]);
@@ -1825,6 +2329,27 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Filter elements
   *  const q = new Queue<number>([1, 2, 3, 4, 5]);
@@ -1858,6 +2383,27 @@ var _Queue = class _Queue extends LinearBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Transform elements
   *  const q = new Queue<number>([1, 2, 3]);
@@ -2976,6 +3522,27 @@ var _DirectedGraph = class _DirectedGraph extends AbstractGraph {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Get edge between vertices
   *  const g = new DirectedGraph();
@@ -3040,6 +3607,27 @@ var _DirectedGraph = class _DirectedGraph extends AbstractGraph {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // DirectedGraph deleteEdge and vertex operations
   *  const graph = new DirectedGraph<string>();
@@ -3102,6 +3690,27 @@ var _DirectedGraph = class _DirectedGraph extends AbstractGraph {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Remove a vertex
   *  const g = new DirectedGraph();
@@ -3155,6 +3764,27 @@ var _DirectedGraph = class _DirectedGraph extends AbstractGraph {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Get incoming edges
   *  const g = new DirectedGraph();
@@ -3185,6 +3815,27 @@ var _DirectedGraph = class _DirectedGraph extends AbstractGraph {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Get outgoing edges
   *  const g = new DirectedGraph();
@@ -3268,6 +3919,27 @@ var _DirectedGraph = class _DirectedGraph extends AbstractGraph {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // DirectedGraph topologicalSort for task scheduling
   *  const graph = new DirectedGraph<string>();
@@ -3332,6 +4004,27 @@ var _DirectedGraph = class _DirectedGraph extends AbstractGraph {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Get all edges
   *  const g = new DirectedGraph();
@@ -3358,6 +4051,27 @@ var _DirectedGraph = class _DirectedGraph extends AbstractGraph {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Get outgoing neighbors
   *  const g = new DirectedGraph();
@@ -3437,6 +4151,27 @@ var _DirectedGraph = class _DirectedGraph extends AbstractGraph {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Find strongly connected components
   *  const g = new DirectedGraph();
@@ -3519,6 +4254,27 @@ var _DirectedGraph = class _DirectedGraph extends AbstractGraph {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Get strongly connected components
   *  const g = new DirectedGraph();
@@ -3665,6 +4421,27 @@ var _UndirectedGraph = class _UndirectedGraph extends AbstractGraph {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Get edge between vertices
   *  const g = new UndirectedGraph();
@@ -3726,6 +4503,27 @@ var _UndirectedGraph = class _UndirectedGraph extends AbstractGraph {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // UndirectedGraph deleteEdge and vertex operations
   *  const graph = new UndirectedGraph<string>();
@@ -3786,6 +4584,27 @@ var _UndirectedGraph = class _UndirectedGraph extends AbstractGraph {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Remove vertex and edges
   *  const g = new UndirectedGraph();
@@ -3861,6 +4680,27 @@ var _UndirectedGraph = class _UndirectedGraph extends AbstractGraph {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Get all edges
   *  const g = new UndirectedGraph();
@@ -3891,6 +4731,27 @@ var _UndirectedGraph = class _UndirectedGraph extends AbstractGraph {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // UndirectedGraph connectivity and neighbors
   *  const graph = new UndirectedGraph<string>();
@@ -3991,6 +4852,27 @@ var _UndirectedGraph = class _UndirectedGraph extends AbstractGraph {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Find articulation points and bridges
   *  const g = new UndirectedGraph();
@@ -4113,6 +4995,27 @@ var _UndirectedGraph = class _UndirectedGraph extends AbstractGraph {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Detect cycle
   *  const g = new UndirectedGraph();
@@ -4157,6 +5060,27 @@ var _UndirectedGraph = class _UndirectedGraph extends AbstractGraph {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Find bridge edges
   *  const g = new UndirectedGraph();
@@ -4183,6 +5107,27 @@ var _UndirectedGraph = class _UndirectedGraph extends AbstractGraph {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Find articulation points
   *  const g = new UndirectedGraph();