data-structure-typed 2.6.1 → 2.6.2

package/dist/cjs/graph.cjs

@@ -723,61 +723,19 @@ var Heap = class _Heap extends IterableElementBase {
     return this._elements;
   }
   /**
-    * Get the number of elements.
-    * @remarks Time O(1), Space O(1)
-    * @returns Heap size.
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-     * @example
-  * // Track heap capacity
-  *  const heap = new Heap<number>();
-  *     console.log(heap.size); // 0;
-  *     heap.add(10);
-  *     heap.add(20);
-  *     console.log(heap.size); // 2;
-  *     heap.poll();
-  *     console.log(heap.size); // 1;
-    */
+   * Get the number of elements.
+   * @remarks Time O(1), Space O(1)
+   * @returns Heap size.
+   * @example
+   * // Track heap capacity
+   *  const heap = new Heap<number>();
+   *     console.log(heap.size); // 0;
+   *     heap.add(10);
+   *     heap.add(20);
+   *     console.log(heap.size); // 2;
+   *     heap.poll();
+   *     console.log(heap.size); // 1;
+   */
   get size() {
     return this.elements.length;
   }
@@ -789,6 +747,14 @@ var Heap = class _Heap extends IterableElementBase {
   get leaf() {
     return this.elements[this.size - 1] ?? void 0;
   }
+  /**
+   * Get the comparator used to order elements.
+   * @remarks Time O(1), Space O(1)
+   * @returns Comparator function.
+   */
+  get comparator() {
+    return this._comparator;
+  }
   /**
    * Create a heap of the same class from an iterable.
    * @remarks Time O(N), Space O(N)
@@ -815,123 +781,42 @@ var Heap = class _Heap extends IterableElementBase {
     return new _Heap(elements, options);
   }
   /**
-    * Insert an element.
-    * @remarks Time O(log N) amortized, Space O(1)
-    * @param element - Element to insert.
-    * @returns True.
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-     * @example
-  * // basic Heap creation and add operation
-  *  // Create a min heap (default)
-  *     const minHeap = new Heap([5, 3, 7, 1, 9, 2]);
-  *
-  *     // Verify size
-  *     console.log(minHeap.size); // 6;
-  *
-  *     // Add new element
-  *     minHeap.add(4);
-  *     console.log(minHeap.size); // 7;
-  *
-  *     // Min heap property: smallest element at root
-  *     const min = minHeap.peek();
-  *     console.log(min); // 1;
-    */
+   * Insert an element.
+   * @remarks Time O(log N) amortized, Space O(1)
+   * @param element - Element to insert.
+   * @returns True.
+   * @example
+   * // basic Heap creation and add operation
+   *  // Create a min heap (default)
+   *     const minHeap = new Heap([5, 3, 7, 1, 9, 2]);
+   *
+   *     // Verify size
+   *     console.log(minHeap.size); // 6;
+   *
+   *     // Add new element
+   *     minHeap.add(4);
+   *     console.log(minHeap.size); // 7;
+   *
+   *     // Min heap property: smallest element at root
+   *     const min = minHeap.peek();
+   *     console.log(min); // 1;
+   */
   add(element) {
     this._elements.push(element);
     return this._bubbleUp(this.elements.length - 1);
   }
   /**
-    * Insert many elements from an iterable.
-    * @remarks Time O(N log N), Space O(1)
-    * @param elements - Iterable of elements or raw values.
-    * @returns Array of per-element success flags.
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-     * @example
-  * // Add multiple elements
-  *  const heap = new Heap<number>([], { comparator: (a, b) => a - b });
-  *     heap.addMany([5, 3, 7, 1]);
-  *     console.log(heap.peek()); // 1;
-  *     console.log(heap.size); // 4;
-    */
+   * Insert many elements from an iterable.
+   * @remarks Time O(N log N), Space O(1)
+   * @param elements - Iterable of elements or raw values.
+   * @returns Array of per-element success flags.
+   * @example
+   * // Add multiple elements
+   *  const heap = new Heap<number>([], { comparator: (a, b) => a - b });
+   *     heap.addMany([5, 3, 7, 1]);
+   *     console.log(heap.peek()); // 1;
+   *     console.log(heap.size); // 4;
+   */
   addMany(elements) {
     const flags = [];
     for (const el of elements) {
@@ -946,104 +831,63 @@ var Heap = class _Heap extends IterableElementBase {
     return flags;
   }
   /**
-    * Remove and return the top element.
-    * @remarks Time O(log N), Space O(1)
-    * @returns Top element or undefined.
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-     * @example
-  * // Heap with custom comparator (MaxHeap behavior)
-  *  interface Task {
-  *       id: number;
-  *       priority: number;
-  *       name: string;
-  *     }
-  *
-  *     // Custom comparator for max heap behavior (higher priority first)
-  *     const tasks: Task[] = [
-  *       { id: 1, priority: 5, name: 'Email' },
-  *       { id: 2, priority: 3, name: 'Chat' },
-  *       { id: 3, priority: 8, name: 'Alert' }
-  *     ];
-  *
-  *     const maxHeap = new Heap(tasks, {
-  *       comparator: (a: Task, b: Task) => b.priority - a.priority
-  *     });
-  *
-  *     console.log(maxHeap.size); // 3;
-  *
-  *     // Peek returns highest priority task
-  *     const topTask = maxHeap.peek();
-  *     console.log(topTask?.priority); // 8;
-  *     console.log(topTask?.name); // 'Alert';
-    */
-  /**
-    * @deprecated Use `pop` instead. Will be removed in a future major version.
-    
-    
-    
-     * @example
-  * // Heap with custom comparator (MaxHeap behavior)
-  *  interface Task {
-  *       id: number;
-  *       priority: number;
-  *       name: string;
-  *     }
-  *
-  *     // Custom comparator for max heap behavior (higher priority first)
-  *     const tasks: Task[] = [
-  *       { id: 1, priority: 5, name: 'Email' },
-  *       { id: 2, priority: 3, name: 'Chat' },
-  *       { id: 3, priority: 8, name: 'Alert' }
-  *     ];
-  *
-  *     const maxHeap = new Heap(tasks, {
-  *       comparator: (a: Task, b: Task) => b.priority - a.priority
-  *     });
-  *
-  *     console.log(maxHeap.size); // 3;
-  *
-  *     // Peek returns highest priority task
-  *     const topTask = maxHeap.peek();
-  *     console.log(topTask?.priority); // 8;
-  *     console.log(topTask?.name); // 'Alert';
-    */
+   * Remove and return the top element.
+   * @remarks Time O(log N), Space O(1)
+   * @returns Top element or undefined.
+   * @example
+   * // Heap with custom comparator (MaxHeap behavior)
+   *  interface Task {
+   *       id: number;
+   *       priority: number;
+   *       name: string;
+   *     }
+   *
+   *     // Custom comparator for max heap behavior (higher priority first)
+   *     const tasks: Task[] = [
+   *       { id: 1, priority: 5, name: 'Email' },
+   *       { id: 2, priority: 3, name: 'Chat' },
+   *       { id: 3, priority: 8, name: 'Alert' }
+   *     ];
+   *
+   *     const maxHeap = new Heap(tasks, {
+   *       comparator: (a: Task, b: Task) => b.priority - a.priority
+   *     });
+   *
+   *     console.log(maxHeap.size); // 3;
+   *
+   *     // Peek returns highest priority task
+   *     const topTask = maxHeap.peek();
+   *     console.log(topTask?.priority); // 8;
+   *     console.log(topTask?.name); // 'Alert';
+   */
+  /**
+   * @deprecated Use `pop` instead. Will be removed in a future major version.
+   * @example
+   * // Heap with custom comparator (MaxHeap behavior)
+   *  interface Task {
+   *       id: number;
+   *       priority: number;
+   *       name: string;
+   *     }
+   *
+   *     // Custom comparator for max heap behavior (higher priority first)
+   *     const tasks: Task[] = [
+   *       { id: 1, priority: 5, name: 'Email' },
+   *       { id: 2, priority: 3, name: 'Chat' },
+   *       { id: 3, priority: 8, name: 'Alert' }
+   *     ];
+   *
+   *     const maxHeap = new Heap(tasks, {
+   *       comparator: (a: Task, b: Task) => b.priority - a.priority
+   *     });
+   *
+   *     console.log(maxHeap.size); // 3;
+   *
+   *     // Peek returns highest priority task
+   *     const topTask = maxHeap.peek();
+   *     console.log(topTask?.priority); // 8;
+   *     console.log(topTask?.name); // 'Alert';
+   */
   poll() {
     return this.pop();
   }
@@ -1063,319 +907,125 @@ var Heap = class _Heap extends IterableElementBase {
     return value;
   }
   /**
-    * Get the current top element without removing it.
-    * @remarks Time O(1), Space O(1)
-    * @returns Top element or undefined.
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-     * @example
-  * // Heap for event processing with priority
-  *  interface Event {
-  *       id: number;
-  *       type: 'critical' | 'warning' | 'info';
-  *       timestamp: number;
-  *       message: string;
-  *     }
-  *
-  *     // Custom priority: critical > warning > info
-  *     const priorityMap = { critical: 3, warning: 2, info: 1 };
-  *
-  *     const eventHeap = new Heap<Event>([], {
-  *       comparator: (a: Event, b: Event) => {
-  *         const priorityA = priorityMap[a.type];
-  *         const priorityB = priorityMap[b.type];
-  *         return priorityB - priorityA; // Higher priority first
-  *       }
-  *     });
-  *
-  *     // Add events in random order
-  *     eventHeap.add({ id: 1, type: 'info', timestamp: 100, message: 'User logged in' });
-  *     eventHeap.add({ id: 2, type: 'critical', timestamp: 101, message: 'Server down' });
-  *     eventHeap.add({ id: 3, type: 'warning', timestamp: 102, message: 'High memory' });
-  *     eventHeap.add({ id: 4, type: 'info', timestamp: 103, message: 'Cache cleared' });
-  *     eventHeap.add({ id: 5, type: 'critical', timestamp: 104, message: 'Database error' });
-  *
-  *     console.log(eventHeap.size); // 5;
-  *
-  *     // Process events by priority (critical first)
-  *     const processedOrder: Event[] = [];
-  *     while (eventHeap.size > 0) {
-  *       const event = eventHeap.poll();
-  *       if (event) {
-  *         processedOrder.push(event);
-  *       }
-  *     }
-  *
-  *     // Verify critical events came first
-  *     console.log(processedOrder[0].type); // 'critical';
-  *     console.log(processedOrder[1].type); // 'critical';
-  *     console.log(processedOrder[2].type); // 'warning';
-  *     console.log(processedOrder[3].type); // 'info';
-  *     console.log(processedOrder[4].type); // 'info';
-  *
-  *     // Verify O(log n) operations
-  *     const newHeap = new Heap<number>([5, 3, 7, 1]);
-  *
-  *     // Add - O(log n)
-  *     newHeap.add(2);
-  *     console.log(newHeap.size); // 5;
-  *
-  *     // Poll - O(log n)
-  *     const removed = newHeap.poll();
-  *     console.log(removed); // 1;
-  *
-  *     // Peek - O(1)
-  *     const top = newHeap.peek();
-  *     console.log(top); // 2;
-    */
+   * Get the current top element without removing it.
+   * @remarks Time O(1), Space O(1)
+   * @returns Top element or undefined.
+   * @example
+   * // Heap for event processing with priority
+   *  interface Event {
+   *       id: number;
+   *       type: 'critical' | 'warning' | 'info';
+   *       timestamp: number;
+   *       message: string;
+   *     }
+   *
+   *     // Custom priority: critical > warning > info
+   *     const priorityMap = { critical: 3, warning: 2, info: 1 };
+   *
+   *     const eventHeap = new Heap<Event>([], {
+   *       comparator: (a: Event, b: Event) => {
+   *         const priorityA = priorityMap[a.type];
+   *         const priorityB = priorityMap[b.type];
+   *         return priorityB - priorityA; // Higher priority first
+   *       }
+   *     });
+   *
+   *     // Add events in random order
+   *     eventHeap.add({ id: 1, type: 'info', timestamp: 100, message: 'User logged in' });
+   *     eventHeap.add({ id: 2, type: 'critical', timestamp: 101, message: 'Server down' });
+   *     eventHeap.add({ id: 3, type: 'warning', timestamp: 102, message: 'High memory' });
+   *     eventHeap.add({ id: 4, type: 'info', timestamp: 103, message: 'Cache cleared' });
+   *     eventHeap.add({ id: 5, type: 'critical', timestamp: 104, message: 'Database error' });
+   *
+   *     console.log(eventHeap.size); // 5;
+   *
+   *     // Process events by priority (critical first)
+   *     const processedOrder: Event[] = [];
+   *     while (eventHeap.size > 0) {
+   *       const event = eventHeap.poll();
+   *       if (event) {
+   *         processedOrder.push(event);
+   *       }
+   *     }
+   *
+   *     // Verify critical events came first
+   *     console.log(processedOrder[0].type); // 'critical';
+   *     console.log(processedOrder[1].type); // 'critical';
+   *     console.log(processedOrder[2].type); // 'warning';
+   *     console.log(processedOrder[3].type); // 'info';
+   *     console.log(processedOrder[4].type); // 'info';
+   *
+   *     // Verify O(log n) operations
+   *     const newHeap = new Heap<number>([5, 3, 7, 1]);
+   *
+   *     // Add - O(log n)
+   *     newHeap.add(2);
+   *     console.log(newHeap.size); // 5;
+   *
+   *     // Poll - O(log n)
+   *     const removed = newHeap.poll();
+   *     console.log(removed); // 1;
+   *
+   *     // Peek - O(1)
+   *     const top = newHeap.peek();
+   *     console.log(top); // 2;
+   */
   peek() {
     return this.elements[0];
   }
   /**
-    * Check whether the heap is empty.
-    * @remarks Time O(1), Space O(1)
-    * @returns True if size is 0.
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-     * @example
-  * // Check if heap is empty
-  *  const heap = new Heap<number>([], { comparator: (a, b) => a - b });
-  *     console.log(heap.isEmpty()); // true;
-  *     heap.add(1);
-  *     console.log(heap.isEmpty()); // false;
-    */
+   * Check whether the heap is empty.
+   * @remarks Time O(1), Space O(1)
+   * @returns True if size is 0.
+   * @example
+   * // Check if heap is empty
+   *  const heap = new Heap<number>([], { comparator: (a, b) => a - b });
+   *     console.log(heap.isEmpty()); // true;
+   *     heap.add(1);
+   *     console.log(heap.isEmpty()); // false;
+   */
   isEmpty() {
     return this.size === 0;
   }
   /**
-    * Remove all elements.
-    * @remarks Time O(1), Space O(1)
-    * @returns void
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-     * @example
-  * // Remove all elements
-  *  const heap = new Heap<number>([1, 2, 3], { comparator: (a, b) => a - b });
-  *     heap.clear();
-  *     console.log(heap.isEmpty()); // true;
-    */
+   * Remove all elements.
+   * @remarks Time O(1), Space O(1)
+   * @returns void
+   * @example
+   * // Remove all elements
+   *  const heap = new Heap<number>([1, 2, 3], { comparator: (a, b) => a - b });
+   *     heap.clear();
+   *     console.log(heap.isEmpty()); // true;
+   */
   clear() {
     this._elements = [];
   }
   /**
-    * Check if an equal element exists in the heap.
-    * @remarks Time O(N), Space O(1)
-    * @param element - Element to search for.
-    * @returns True if found.
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-     * @example
-  * // Check element existence
-  *  const heap = new Heap<number>([3, 1, 2], { comparator: (a, b) => a - b });
-  *     console.log(heap.has(1)); // true;
-  *     console.log(heap.has(99)); // false;
-    */
+   * Check if an equal element exists in the heap.
+   * @remarks Time O(N), Space O(1)
+   * @param element - Element to search for.
+   * @returns True if found.
+   * @example
+   * // Check element existence
+   *  const heap = new Heap<number>([3, 1, 2], { comparator: (a, b) => a - b });
+   *     console.log(heap.has(1)); // true;
+   *     console.log(heap.has(99)); // false;
+   */
   has(element) {
     for (const el of this.elements) if (this._equals(el, element)) return true;
     return false;
   }
   /**
-    * Delete one occurrence of an element.
-    * @remarks Time O(N), Space O(1)
-    * @param element - Element to delete.
-    * @returns True if an element was removed.
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-     * @example
-  * // Remove specific element
-  *  const heap = new Heap<number>([3, 1, 4, 1, 5], { comparator: (a, b) => a - b });
-  *     heap.delete(4);
-  *     console.log(heap.toArray().includes(4)); // false;
-    */
+   * Delete one occurrence of an element.
+   * @remarks Time O(N), Space O(1)
+   * @param element - Element to delete.
+   * @returns True if an element was removed.
+   * @example
+   * // Remove specific element
+   *  const heap = new Heap<number>([3, 1, 4, 1, 5], { comparator: (a, b) => a - b });
+   *     heap.delete(4);
+   *     console.log(heap.toArray().includes(4)); // false;
+   */
   delete(element) {
     let index = -1;
     for (let i = 0; i < this.elements.length; i++) {
@@ -1439,49 +1089,16 @@ var Heap = class _Heap extends IterableElementBase {
     return this;
   }
   /**
-    * Traverse the binary heap as a complete binary tree and collect elements.
-    * @remarks Time O(N), Space O(H)
-    * @param [order] - Traversal order: 'PRE' | 'IN' | 'POST'.
-    * @returns Array of visited elements.
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-     * @example
-  * // Depth-first traversal
-  *  const heap = new Heap<number>([3, 1, 2], { comparator: (a, b) => a - b });
-  *     const result = heap.dfs('IN');
-  *     console.log(result.length); // 3;
-    */
+   * Traverse the binary heap as a complete binary tree and collect elements.
+   * @remarks Time O(N), Space O(H)
+   * @param [order] - Traversal order: 'PRE' | 'IN' | 'POST'.
+   * @returns Array of visited elements.
+   * @example
+   * // Depth-first traversal
+   *  const heap = new Heap<number>([3, 1, 2], { comparator: (a, b) => a - b });
+   *     const result = heap.dfs('IN');
+   *     console.log(result.length); // 3;
+   */
   dfs(order = "PRE") {
     const result = [];
     const _dfs = /* @__PURE__ */ __name((index) => {
@@ -1518,57 +1135,15 @@ var Heap = class _Heap extends IterableElementBase {
     return results;
   }
   /**
-    * Return all elements in ascending order by repeatedly polling.
-    * @remarks Time O(N log N), Space O(N)
-    * @returns Sorted array of elements.
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-     * @example
-  * // Sort elements using heap
-  *  const heap = new Heap<number>([5, 1, 3, 2, 4]);
-  *     const sorted = heap.sort();
-  *     console.log(sorted); // [1, 2, 3, 4, 5];
-    */
+   * Return all elements in ascending order by repeatedly polling.
+   * @remarks Time O(N log N), Space O(N)
+   * @returns Sorted array of elements.
+   * @example
+   * // Sort elements using heap
+   *  const heap = new Heap<number>([5, 1, 3, 2, 4]);
+   *     const sorted = heap.sort();
+   *     console.log(sorted); // [1, 2, 3, 4, 5];
+   */
   sort() {
     const visited = [];
     const cloned = this._createInstance();
@@ -1580,114 +1155,34 @@ var Heap = class _Heap extends IterableElementBase {
     return visited;
   }
   /**
-    * Deep clone this heap.
-    * @remarks Time O(N), Space O(N)
-    * @returns A new heap with the same elements.
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-     * @example
-  * // Create independent copy
-  *  const heap = new Heap<number>([3, 1, 4], { comparator: (a, b) => a - b });
-  *     const copy = heap.clone();
-  *     copy.poll();
-  *     console.log(heap.size); // 3;
-  *     console.log(copy.size); // 2;
-    */
+   * Deep clone this heap.
+   * @remarks Time O(N), Space O(N)
+   * @returns A new heap with the same elements.
+   * @example
+   * // Create independent copy
+   *  const heap = new Heap<number>([3, 1, 4], { comparator: (a, b) => a - b });
+   *     const copy = heap.clone();
+   *     copy.poll();
+   *     console.log(heap.size); // 3;
+   *     console.log(copy.size); // 2;
+   */
   clone() {
     const next = this._createInstance();
     for (const x of this.elements) next.add(x);
     return next;
   }
   /**
-    * Filter elements into a new heap of the same class.
-    * @remarks Time O(N log N), Space O(N)
-    * @param callback - Predicate (element, index, heap) → boolean to keep element.
-    * @param [thisArg] - Value for `this` inside the callback.
-    * @returns A new heap with the kept elements.
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-     * @example
-  * // Filter elements
-  *  const heap = new Heap<number>([1, 2, 3, 4, 5], { comparator: (a, b) => a - b });
-  *     const evens = heap.filter(x => x % 2 === 0);
-  *     console.log(evens.size); // 2;
-    */
+   * Filter elements into a new heap of the same class.
+   * @remarks Time O(N log N), Space O(N)
+   * @param callback - Predicate (element, index, heap) → boolean to keep element.
+   * @param [thisArg] - Value for `this` inside the callback.
+   * @returns A new heap with the kept elements.
+   * @example
+   * // Filter elements
+   *  const heap = new Heap<number>([1, 2, 3, 4, 5], { comparator: (a, b) => a - b });
+   *     const evens = heap.filter(x => x % 2 === 0);
+   *     console.log(evens.size); // 2;
+   */
   filter(callback, thisArg) {
     const out = this._createInstance();
     let i = 0;
@@ -1701,59 +1196,20 @@ var Heap = class _Heap extends IterableElementBase {
     return out;
   }
   /**
-    * Map elements into a new heap of possibly different element type.
-    * @remarks Time O(N log N), Space O(N)
-    * @template EM
-    * @template RM
-    * @param callback - Mapping function (element, index, heap) → newElement.
-    * @param options - Options for the output heap, including comparator for EM.
-    * @param [thisArg] - Value for `this` inside the callback.
-    * @returns A new heap with mapped elements.
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-     * @example
-  * // Transform elements
-  *  const heap = new Heap<number>([1, 2, 3], { comparator: (a, b) => a - b });
-  *     const doubled = heap.map(x => x * 2, { comparator: (a, b) => a - b });
-  *     console.log(doubled.peek()); // 2;
-    */
+   * Map elements into a new heap of possibly different element type.
+   * @remarks Time O(N log N), Space O(N)
+   * @template EM
+   * @template RM
+   * @param callback - Mapping function (element, index, heap) → newElement.
+   * @param options - Options for the output heap, including comparator for EM.
+   * @param [thisArg] - Value for `this` inside the callback.
+   * @returns A new heap with mapped elements.
+   * @example
+   * // Transform elements
+   *  const heap = new Heap<number>([1, 2, 3], { comparator: (a, b) => a - b });
+   *     const doubled = heap.map(x => x * 2, { comparator: (a, b) => a - b });
+   *     console.log(doubled.peek()); // 2;
+   */
   map(callback, options, thisArg) {
     const { comparator, toElementFn, ...rest } = options ?? {};
     if (!comparator) raise(TypeError, ERR.comparatorRequired("Heap.map"));
@@ -1790,14 +1246,6 @@ var Heap = class _Heap extends IterableElementBase {
     return 0;
   }, "_DEFAULT_COMPARATOR");
   _comparator = this._DEFAULT_COMPARATOR;
-  /**
-   * 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;
   }
@@ -1923,124 +1371,32 @@ var Queue = class _Queue extends LinearBase {
     this._autoCompactRatio = value;
   }
   /**
-    * Get the number of elements currently in the queue.
-    * @remarks Time O(1), Space O(1)
-    * @returns Current length.
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-     * @example
-  * // Track queue length
-  *  const q = new Queue<number>();
-  *     console.log(q.length); // 0;
-  *     q.push(1);
-  *     q.push(2);
-  *     console.log(q.length); // 2;
-    */
+   * Get the number of elements currently in the queue.
+   * @remarks Time O(1), Space O(1)
+   * @returns Current length.
+   * @example
+   * // Track queue length
+   *  const q = new Queue<number>();
+   *     console.log(q.length); // 0;
+   *     q.push(1);
+   *     q.push(2);
+   *     console.log(q.length); // 2;
+   */
   get length() {
     return this.elements.length - this._offset;
   }
   /**
-    * Get the first element (front) without removing it.
-    * @remarks Time O(1), Space O(1)
-    * @returns Front element or undefined.
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-     * @example
-  * // View the front element
-  *  const q = new Queue<string>(['first', 'second', 'third']);
-  *     console.log(q.first); // 'first';
-  *     console.log(q.length); // 3;
-    */
-  get first() {
-    return this.length > 0 ? this.elements[this._offset] : void 0;
-  }
-  /**
-   * Peek at the front element without removing it (alias for `first`).
+   * Get the first element (front) without removing it.
    * @remarks Time O(1), Space O(1)
    * @returns Front element or undefined.
+   * @example
+   * // View the front element
+   *  const q = new Queue<string>(['first', 'second', 'third']);
+   *     console.log(q.first); // 'first';
+   *     console.log(q.length); // 3;
    */
-  peek() {
-    return this.first;
+  get first() {
+    return this.length > 0 ? this.elements[this._offset] : void 0;
   }
   /**
    * Get the last element (back) without removing it.
@@ -2061,131 +1417,55 @@ var Queue = class _Queue extends LinearBase {
     return new _Queue(elements);
   }
   /**
-    * Check whether the queue is empty.
-    * @remarks Time O(1), Space O(1)
-    * @returns True if length is 0.
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-     * @example
-  * // Queue for...of iteration and isEmpty check
-  *  const queue = new Queue<string>(['A', 'B', 'C', 'D']);
-  *
-  *     const elements: string[] = [];
-  *     for (const item of queue) {
-  *       elements.push(item);
-  *     }
-  *
-  *     // Verify all elements are iterated in order
-  *     console.log(elements); // ['A', 'B', 'C', 'D'];
-  *
-  *     // Process all elements
-  *     while (queue.length > 0) {
-  *       queue.shift();
-  *     }
-  *
-  *     console.log(queue.length); // 0;
-    */
+   * Peek at the front element without removing it (alias for `first`).
+   * @remarks Time O(1), Space O(1)
+   * @returns Front element or undefined.
+   */
+  peek() {
+    return this.first;
+  }
+  /**
+   * Check whether the queue is empty.
+   * @remarks Time O(1), Space O(1)
+   * @returns True if length is 0.
+   * @example
+   * // Queue for...of iteration and isEmpty check
+   *  const queue = new Queue<string>(['A', 'B', 'C', 'D']);
+   *
+   *     const elements: string[] = [];
+   *     for (const item of queue) {
+   *       elements.push(item);
+   *     }
+   *
+   *     // Verify all elements are iterated in order
+   *     console.log(elements); // ['A', 'B', 'C', 'D'];
+   *
+   *     // Process all elements
+   *     while (queue.length > 0) {
+   *       queue.shift();
+   *     }
+   *
+   *     console.log(queue.length); // 0;
+   */
   isEmpty() {
     return this.length === 0;
   }
   /**
-    * Enqueue one element at the back.
-    * @remarks Time O(1), Space O(1)
-    * @param element - Element to enqueue.
-    * @returns True on success.
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-     * @example
-  * // basic Queue creation and push operation
-  *  // Create a simple Queue with initial values
-  *     const queue = new Queue([1, 2, 3, 4, 5]);
-  *
-  *     // Verify the queue maintains insertion order
-  *     console.log([...queue]); // [1, 2, 3, 4, 5];
-  *
-  *     // Check length
-  *     console.log(queue.length); // 5;
-    */
+   * Enqueue one element at the back.
+   * @remarks Time O(1), Space O(1)
+   * @param element - Element to enqueue.
+   * @returns True on success.
+   * @example
+   * // basic Queue creation and push operation
+   *  // Create a simple Queue with initial values
+   *     const queue = new Queue([1, 2, 3, 4, 5]);
+   *
+   *     // Verify the queue maintains insertion order
+   *     console.log([...queue]); // [1, 2, 3, 4, 5];
+   *
+   *     // Check length
+   *     console.log(queue.length); // 5;
+   */
   push(element) {
     this.elements.push(element);
     if (this._maxLen > 0 && this.length > this._maxLen) this.shift();
@@ -2206,66 +1486,24 @@ var Queue = class _Queue extends LinearBase {
     return ans;
   }
   /**
-    * Dequeue one element from the front (amortized via offset).
-    * @remarks Time O(1) amortized, Space O(1)
-    * @returns Removed element or undefined.
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-     * @example
-  * // Queue shift and peek operations
-  *  const queue = new Queue<number>([10, 20, 30, 40]);
-  *
-  *     // Peek at the front element without removing it
-  *     console.log(queue.first); // 10;
-  *
-  *     // Remove and get the first element (FIFO)
-  *     const first = queue.shift();
-  *     console.log(first); // 10;
-  *
-  *     // Verify remaining elements and length decreased
-  *     console.log([...queue]); // [20, 30, 40];
-  *     console.log(queue.length); // 3;
-    */
+   * Dequeue one element from the front (amortized via offset).
+   * @remarks Time O(1) amortized, Space O(1)
+   * @returns Removed element or undefined.
+   * @example
+   * // Queue shift and peek operations
+   *  const queue = new Queue<number>([10, 20, 30, 40]);
+   *
+   *     // Peek at the front element without removing it
+   *     console.log(queue.first); // 10;
+   *
+   *     // Remove and get the first element (FIFO)
+   *     const first = queue.shift();
+   *     console.log(first); // 10;
+   *
+   *     // Verify remaining elements and length decreased
+   *     console.log([...queue]); // [20, 30, 40];
+   *     console.log(queue.length); // 3;
+   */
   shift() {
     if (this.length === 0) return void 0;
     const first = this.first;
@@ -2274,55 +1512,16 @@ var Queue = class _Queue extends LinearBase {
     return first;
   }
   /**
-    * Delete the first occurrence of a specific element.
-    * @remarks Time O(N), Space O(1)
-    * @param element - Element to remove (strict equality via Object.is).
-    * @returns True if an element was removed.
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-     * @example
-  * // Remove specific element
-  *  const q = new Queue<number>([1, 2, 3, 2]);
-  *     q.delete(2);
-  *     console.log(q.length); // 3;
-    */
+   * Delete the first occurrence of a specific element.
+   * @remarks Time O(N), Space O(1)
+   * @param element - Element to remove (strict equality via Object.is).
+   * @returns True if an element was removed.
+   * @example
+   * // Remove specific element
+   *  const q = new Queue<number>([1, 2, 3, 2]);
+   *     q.delete(2);
+   *     console.log(q.length); // 3;
+   */
   delete(element) {
     for (let i = this._offset; i < this.elements.length; i++) {
       if (Object.is(this.elements[i], element)) {
@@ -2333,55 +1532,16 @@ var Queue = class _Queue extends LinearBase {
     return false;
   }
   /**
-    * Get the element at a given logical index.
-    * @remarks Time O(1), Space O(1)
-    * @param index - Zero-based index from the front.
-    * @returns Element or undefined.
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-     * @example
-  * // Access element by index
-  *  const q = new Queue<string>(['a', 'b', 'c']);
-  *     console.log(q.at(0)); // 'a';
-  *     console.log(q.at(2)); // 'c';
-    */
+   * Get the element at a given logical index.
+   * @remarks Time O(1), Space O(1)
+   * @param index - Zero-based index from the front.
+   * @returns Element or undefined.
+   * @example
+   * // Access element by index
+   *  const q = new Queue<string>(['a', 'b', 'c']);
+   *     console.log(q.at(0)); // 'a';
+   *     console.log(q.at(2)); // 'c';
+   */
   at(index) {
     if (index < 0 || index >= this.length) return void 0;
     return this._elements[this._offset + index];
@@ -2448,110 +1608,31 @@ var Queue = class _Queue extends LinearBase {
     return this;
   }
   /**
-    * Remove all elements and reset offset.
-    * @remarks Time O(1), Space O(1)
-    * @returns void
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-     * @example
-  * // Remove all elements
-  *  const q = new Queue<number>([1, 2, 3]);
-  *     q.clear();
-  *     console.log(q.length); // 0;
-    */
+   * Remove all elements and reset offset.
+   * @remarks Time O(1), Space O(1)
+   * @returns void
+   * @example
+   * // Remove all elements
+   *  const q = new Queue<number>([1, 2, 3]);
+   *     q.clear();
+   *     console.log(q.length); // 0;
+   */
   clear() {
     this._elements = [];
     this._offset = 0;
   }
   /**
-    * Compact storage by discarding consumed head elements.
-    * @remarks Time O(N), Space O(N)
-    * @returns True when compaction performed.
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-     * @example
-  * // Reclaim unused memory
-  *  const q = new Queue<number>([1, 2, 3, 4, 5]);
-  *     q.shift();
-  *     q.shift();
-  *     q.compact();
-  *     console.log(q.length); // 3;
-    */
+   * Compact storage by discarding consumed head elements.
+   * @remarks Time O(N), Space O(N)
+   * @returns True when compaction performed.
+   * @example
+   * // Reclaim unused memory
+   *  const q = new Queue<number>([1, 2, 3, 4, 5]);
+   *     q.shift();
+   *     q.shift();
+   *     q.compact();
+   *     console.log(q.length); // 3;
+   */
   compact() {
     this._elements = this.elements.slice(this._offset);
     this._offset = 0;
@@ -2577,57 +1658,17 @@ var Queue = class _Queue extends LinearBase {
     return removed;
   }
   /**
-    * Deep clone this queue and its parameters.
-    * @remarks Time O(N), Space O(N)
-    * @returns A new queue with the same content and options.
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-     * @example
-  * // Create independent copy
-  *  const q = new Queue<number>([1, 2, 3]);
-  *     const copy = q.clone();
-  *     copy.shift();
-  *     console.log(q.length); // 3;
-  *     console.log(copy.length); // 2;
-    */
+   * Deep clone this queue and its parameters.
+   * @remarks Time O(N), Space O(N)
+   * @returns A new queue with the same content and options.
+   * @example
+   * // Create independent copy
+   *  const q = new Queue<number>([1, 2, 3]);
+   *     const copy = q.clone();
+   *     copy.shift();
+   *     console.log(q.length); // 3;
+   *     console.log(copy.length); // 2;
+   */
   clone() {
     const out = this._createInstance({ toElementFn: this.toElementFn, maxLen: this._maxLen });
     out._setAutoCompactRatio(this._autoCompactRatio);
@@ -2635,57 +1676,17 @@ var Queue = class _Queue extends LinearBase {
     return out;
   }
   /**
-    * Filter elements into a new queue of the same class.
-    * @remarks Time O(N), Space O(N)
-    * @param predicate - Predicate (element, index, queue) → boolean to keep element.
-    * @param [thisArg] - Value for `this` inside the predicate.
-    * @returns A new queue with kept elements.
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-     * @example
-  * // Filter elements
-  *  const q = new Queue<number>([1, 2, 3, 4, 5]);
-  *     const evens = q.filter(x => x % 2 === 0);
-  *     console.log(evens.length); // 2;
-    */
+   * Filter elements into a new queue of the same class.
+   * @remarks Time O(N), Space O(N)
+   * @param predicate - Predicate (element, index, queue) → boolean to keep element.
+   * @param [thisArg] - Value for `this` inside the predicate.
+   * @returns A new queue with kept elements.
+   * @example
+   * // Filter elements
+   *  const q = new Queue<number>([1, 2, 3, 4, 5]);
+   *     const evens = q.filter(x => x % 2 === 0);
+   *     console.log(evens.length); // 2;
+   */
   filter(predicate, thisArg) {
     const out = this._createInstance({ toElementFn: this.toElementFn, maxLen: this._maxLen });
     out._setAutoCompactRatio(this._autoCompactRatio);
@@ -2697,59 +1698,20 @@ var Queue = class _Queue extends LinearBase {
     return out;
   }
   /**
-    * Map each element to a new element in a possibly different-typed queue.
-    * @remarks Time O(N), Space O(N)
-    * @template EM
-    * @template RM
-    * @param callback - Mapping function (element, index, queue) → newElement.
-    * @param [options] - Options for the output queue (e.g., toElementFn, maxLen, autoCompactRatio).
-    * @param [thisArg] - Value for `this` inside the callback.
-    * @returns A new Queue with mapped elements.
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-     * @example
-  * // Transform elements
-  *  const q = new Queue<number>([1, 2, 3]);
-  *     const doubled = q.map(x => x * 2);
-  *     console.log(doubled.toArray()); // [2, 4, 6];
-    */
+   * Map each element to a new element in a possibly different-typed queue.
+   * @remarks Time O(N), Space O(N)
+   * @template EM
+   * @template RM
+   * @param callback - Mapping function (element, index, queue) → newElement.
+   * @param [options] - Options for the output queue (e.g., toElementFn, maxLen, autoCompactRatio).
+   * @param [thisArg] - Value for `this` inside the callback.
+   * @returns A new Queue with mapped elements.
+   * @example
+   * // Transform elements
+   *  const q = new Queue<number>([1, 2, 3]);
+   *     const doubled = q.map(x => x * 2);
+   *     console.log(doubled.toArray()); // [2, 4, 6];
+   */
   map(callback, options, thisArg) {
     const out = new this.constructor([], {
       toElementFn: options?.toElementFn,
@@ -2892,6 +1854,13 @@ var AbstractGraph = class extends IterableEntryBase {
   get size() {
     return this._vertexMap.size;
   }
+  /**
+   * The edge connector string used in visual output.
+   * Override in subclasses (e.g., '--' for undirected, '->' for directed).
+   */
+  get _edgeConnector() {
+    return "--";
+  }
   /**
    * Get vertex instance by key.
    * @param vertexKey - Vertex key.
@@ -2979,7 +1948,10 @@ var AbstractGraph = class extends IterableEntryBase {
         const newEdge = this.createEdge(srcOrEdge, dest, weight, value);
         return this._addEdge(newEdge);
       } else {
-        raise(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")
+        );
       }
     }
   }
@@ -3535,6 +2507,7 @@ var AbstractGraph = class extends IterableEntryBase {
     }
     return mapped;
   }
+  // ===== Same-species factory & cloning helpers =====
   /**
    * Create a deep clone of the graph with the same species.
    * @remarks Time O(V + E), Space O(V + E)
@@ -3547,7 +2520,85 @@ var AbstractGraph = class extends IterableEntryBase {
   clone() {
     return this._createLike(void 0, this._snapshotOptions());
   }
-  // ===== Same-species factory & cloning helpers =====
+  /**
+   * Generate a text-based visual representation of the graph.
+   *
+   * **Adjacency list format:**
+   * ```
+   * Graph (5 vertices, 6 edges):
+   * A -> B (1), C (2)
+   * B -> D (3)
+   * C -> (no outgoing edges)
+   * D -> A (1)
+   * E (isolated)
+   * ```
+   *
+   * @param options - Optional display settings.
+   * @param options.showWeight - Whether to show edge weights (default: true).
+   * @returns The visual string.
+   */
+  toVisual(options) {
+    const showWeight = options?.showWeight ?? true;
+    const vertices = [...this._vertexMap.values()];
+    const vertexCount = vertices.length;
+    const edgeCount = this.edgeSet().length;
+    const lines = [`Graph (${vertexCount} vertices, ${edgeCount} edges):`];
+    for (const vertex of vertices) {
+      const neighbors = this.getNeighbors(vertex);
+      if (neighbors.length === 0) {
+        lines.push(`  ${vertex.key} (isolated)`);
+      } else {
+        const edgeStrs = neighbors.map((neighbor) => {
+          const edge = this.getEdge(vertex, neighbor);
+          if (edge && showWeight && edge.weight !== void 0 && edge.weight !== 1) {
+            return `${neighbor.key} (${edge.weight})`;
+          }
+          return `${neighbor.key}`;
+        });
+        lines.push(`  ${vertex.key} ${this._edgeConnector} ${edgeStrs.join(", ")}`);
+      }
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Generate DOT language representation for Graphviz.
+   *
+   * @param options - Optional display settings.
+   * @param options.name - Graph name (default: 'G').
+   * @param options.showWeight - Whether to label edges with weight (default: true).
+   * @returns DOT format string.
+   */
+  toDot(options) {
+    const name = options?.name ?? "G";
+    const showWeight = options?.showWeight ?? true;
+    const isDirected = this._edgeConnector === "->";
+    const graphType = isDirected ? "digraph" : "graph";
+    const edgeOp = isDirected ? "->" : "--";
+    const lines = [`${graphType} ${name} {`];
+    for (const vertex of this._vertexMap.values()) {
+      lines.push(`  "${vertex.key}";`);
+    }
+    const visited = /* @__PURE__ */ new Set();
+    for (const vertex of this._vertexMap.values()) {
+      for (const neighbor of this.getNeighbors(vertex)) {
+        const edgeId = isDirected ? `${vertex.key}->${neighbor.key}` : [vertex.key, neighbor.key].sort().join("--");
+        if (visited.has(edgeId)) continue;
+        visited.add(edgeId);
+        const edge = this.getEdge(vertex, neighbor);
+        const label = edge && showWeight && edge.weight !== void 0 && edge.weight !== 1 ? ` [label="${edge.weight}"]` : "";
+        lines.push(`  "${vertex.key}" ${edgeOp} "${neighbor.key}"${label};`);
+      }
+    }
+    lines.push("}");
+    return lines.join("\n");
+  }
+  /**
+   * Print the graph to console.
+   * @param options - Display settings passed to `toVisual`.
+   */
+  print(options) {
+    console.log(this.toVisual(options));
+  }
   /**
    * Internal iterator over `[key, value]` entries in insertion order.
    * @returns Iterator of `[VertexKey, V | undefined]`.
@@ -3659,92 +2710,6 @@ var AbstractGraph = class extends IterableEntryBase {
   _getVertexKey(vertexOrKey) {
     return vertexOrKey instanceof AbstractVertex ? vertexOrKey.key : vertexOrKey;
   }
-  /**
-   * The edge connector string used in visual output.
-   * Override in subclasses (e.g., '--' for undirected, '->' for directed).
-   */
-  get _edgeConnector() {
-    return "--";
-  }
-  /**
-   * Generate a text-based visual representation of the graph.
-   *
-   * **Adjacency list format:**
-   * ```
-   * Graph (5 vertices, 6 edges):
-   * A -> B (1), C (2)
-   * B -> D (3)
-   * C -> (no outgoing edges)
-   * D -> A (1)
-   * E (isolated)
-   * ```
-   *
-   * @param options - Optional display settings.
-   * @param options.showWeight - Whether to show edge weights (default: true).
-   * @returns The visual string.
-   */
-  toVisual(options) {
-    const showWeight = options?.showWeight ?? true;
-    const vertices = [...this._vertexMap.values()];
-    const vertexCount = vertices.length;
-    const edgeCount = this.edgeSet().length;
-    const lines = [`Graph (${vertexCount} vertices, ${edgeCount} edges):`];
-    for (const vertex of vertices) {
-      const neighbors = this.getNeighbors(vertex);
-      if (neighbors.length === 0) {
-        lines.push(`  ${vertex.key} (isolated)`);
-      } else {
-        const edgeStrs = neighbors.map((neighbor) => {
-          const edge = this.getEdge(vertex, neighbor);
-          if (edge && showWeight && edge.weight !== void 0 && edge.weight !== 1) {
-            return `${neighbor.key} (${edge.weight})`;
-          }
-          return `${neighbor.key}`;
-        });
-        lines.push(`  ${vertex.key} ${this._edgeConnector} ${edgeStrs.join(", ")}`);
-      }
-    }
-    return lines.join("\n");
-  }
-  /**
-   * Generate DOT language representation for Graphviz.
-   *
-   * @param options - Optional display settings.
-   * @param options.name - Graph name (default: 'G').
-   * @param options.showWeight - Whether to label edges with weight (default: true).
-   * @returns DOT format string.
-   */
-  toDot(options) {
-    const name = options?.name ?? "G";
-    const showWeight = options?.showWeight ?? true;
-    const isDirected = this._edgeConnector === "->";
-    const graphType = isDirected ? "digraph" : "graph";
-    const edgeOp = isDirected ? "->" : "--";
-    const lines = [`${graphType} ${name} {`];
-    for (const vertex of this._vertexMap.values()) {
-      lines.push(`  "${vertex.key}";`);
-    }
-    const visited = /* @__PURE__ */ new Set();
-    for (const vertex of this._vertexMap.values()) {
-      for (const neighbor of this.getNeighbors(vertex)) {
-        const edgeId = isDirected ? `${vertex.key}->${neighbor.key}` : [vertex.key, neighbor.key].sort().join("--");
-        if (visited.has(edgeId)) continue;
-        visited.add(edgeId);
-        const edge = this.getEdge(vertex, neighbor);
-        const label = edge && showWeight && edge.weight !== void 0 && edge.weight !== 1 ? ` [label="${edge.weight}"]` : "";
-        lines.push(`  "${vertex.key}" ${edgeOp} "${neighbor.key}"${label};`);
-      }
-    }
-    lines.push("}");
-    return lines.join("\n");
-  }
-  /**
-   * Print the graph to console.
-   * @param options - Display settings passed to `toVisual`.
-   */
-  print(options) {
-    console.log(this.toVisual(options));
-  }
 };
 
 // src/data-structures/graph/directed-graph.ts
@@ -3780,9 +2745,6 @@ var DirectedGraph = class _DirectedGraph extends AbstractGraph {
   constructor(options) {
     super(options);
   }
-  get _edgeConnector() {
-    return "->";
-  }
   _outEdgeMap = /* @__PURE__ */ new Map();
   get outEdgeMap() {
     return this._outEdgeMap;
@@ -3797,6 +2759,9 @@ var DirectedGraph = class _DirectedGraph extends AbstractGraph {
   set inEdgeMap(v) {
     this._inEdgeMap = v;
   }
+  get _edgeConnector() {
+    return "->";
+  }
   /**
    * Construct a directed graph from keys with value initializer `v => v`.
    * @template K - Vertex key type.
@@ -3846,59 +2811,20 @@ var DirectedGraph = class _DirectedGraph extends AbstractGraph {
     return new DirectedEdge(src, dest, weight ?? this.options.defaultEdgeWeight ?? 1, value);
   }
   /**
-    * Get the unique edge from `src` to `dest`, if present.
-    * @param srcOrKey - Source vertex or key.
-    * @param destOrKey - Destination vertex or key.
-    * @returns Edge instance or `undefined`.
-    * @remarks Time O(1) avg, Space O(1)
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-     * @example
-  * // Get edge between vertices
-  *  const g = new DirectedGraph();
-  *     g.addVertex('A');
-  *     g.addVertex('B');
-  *     g.addEdge('A', 'B', 5);
-  *     const edge = g.getEdge('A', 'B');
-  *     console.log(edge?.weight); // 5;
-    */
+   * Get the unique edge from `src` to `dest`, if present.
+   * @param srcOrKey - Source vertex or key.
+   * @param destOrKey - Destination vertex or key.
+   * @returns Edge instance or `undefined`.
+   * @remarks Time O(1) avg, Space O(1)
+   * @example
+   * // Get edge between vertices
+   *  const g = new DirectedGraph();
+   *     g.addVertex('A');
+   *     g.addVertex('B');
+   *     g.addEdge('A', 'B', 5);
+   *     const edge = g.getEdge('A', 'B');
+   *     console.log(edge?.weight); // 5;
+   */
   getEdge(srcOrKey, destOrKey) {
     let edgeMap = [];
     if (srcOrKey !== void 0 && destOrKey !== void 0) {
@@ -3938,79 +2864,37 @@ var DirectedGraph = class _DirectedGraph extends AbstractGraph {
     return removed;
   }
   /**
-    * Delete an edge by instance or by `(srcKey, destKey)`.
-    * @param edgeOrSrcVertexKey - Edge instance or source vertex/key.
-    * @param destVertexKey - Optional destination vertex/key when deleting by pair.
-    * @returns Removed edge or `undefined`.
-    * @remarks Time O(1) avg, Space O(1)
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-     * @example
-  * // DirectedGraph deleteEdge and vertex operations
-  *  const graph = new DirectedGraph<string>();
-  *
-  *     // Build a small graph
-  *     graph.addVertex('X');
-  *     graph.addVertex('Y');
-  *     graph.addVertex('Z');
-  *     graph.addEdge('X', 'Y', 1);
-  *     graph.addEdge('Y', 'Z', 2);
-  *
-  *     // Delete an edge
-  *     graph.deleteEdgeSrcToDest('X', 'Y');
-  *     console.log(graph.hasEdge('X', 'Y')); // false;
-  *
-  *     // Edge in other direction should not exist
-  *     console.log(graph.hasEdge('Y', 'X')); // false;
-  *
-  *     // Other edges should remain
-  *     console.log(graph.hasEdge('Y', 'Z')); // true;
-  *
-  *     // Delete a vertex
-  *     graph.deleteVertex('Y');
-  *     console.log(graph.hasVertex('Y')); // false;
-  *     console.log(graph.size); // 2;
-    */
+   * Delete an edge by instance or by `(srcKey, destKey)`.
+   * @param edgeOrSrcVertexKey - Edge instance or source vertex/key.
+   * @param destVertexKey - Optional destination vertex/key when deleting by pair.
+   * @returns Removed edge or `undefined`.
+   * @remarks Time O(1) avg, Space O(1)
+   * @example
+   * // DirectedGraph deleteEdge and vertex operations
+   *  const graph = new DirectedGraph<string>();
+   *
+   *     // Build a small graph
+   *     graph.addVertex('X');
+   *     graph.addVertex('Y');
+   *     graph.addVertex('Z');
+   *     graph.addEdge('X', 'Y', 1);
+   *     graph.addEdge('Y', 'Z', 2);
+   *
+   *     // Delete an edge
+   *     graph.deleteEdgeSrcToDest('X', 'Y');
+   *     console.log(graph.hasEdge('X', 'Y')); // false;
+   *
+   *     // Edge in other direction should not exist
+   *     console.log(graph.hasEdge('Y', 'X')); // false;
+   *
+   *     // Other edges should remain
+   *     console.log(graph.hasEdge('Y', 'Z')); // true;
+   *
+   *     // Delete a vertex
+   *     graph.deleteVertex('Y');
+   *     console.log(graph.hasVertex('Y')); // false;
+   *     console.log(graph.size); // 2;
+   */
   deleteEdge(edgeOrSrcVertexKey, destVertexKey) {
     let removed = void 0;
     let src, dest;
@@ -4038,56 +2922,17 @@ var DirectedGraph = class _DirectedGraph extends AbstractGraph {
     return removed;
   }
   /**
-    * Remove a vertex
-   
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-     * @example
-  * // Remove a vertex
-  *  const g = new DirectedGraph();
-  *     g.addVertex('A');
-  *     g.addVertex('B');
-  *     g.addEdge('A', 'B');
-  *     g.deleteVertex('A');
-  *     console.log(g.hasVertex('A')); // false;
-  *     console.log(g.hasEdge('A', 'B')); // false;
-    */
+   * Remove a vertex
+   * @example
+   * // Remove a vertex
+   *  const g = new DirectedGraph();
+   *     g.addVertex('A');
+   *     g.addVertex('B');
+   *     g.addEdge('A', 'B');
+   *     g.deleteVertex('A');
+   *     console.log(g.hasVertex('A')); // false;
+   *     console.log(g.hasEdge('A', 'B')); // false;
+   */
   deleteVertex(vertexOrKey) {
     let vertexKey;
     let vertex;
@@ -4119,59 +2964,20 @@ var DirectedGraph = class _DirectedGraph extends AbstractGraph {
     return removed;
   }
   /**
-    * Incoming edges of a vertex.
-    * @param vertexOrKey - Vertex or key.
-    * @returns Array of incoming edges.
-    * @remarks Time O(deg_in), Space O(deg_in)
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-     * @example
-  * // Get incoming edges
-  *  const g = new DirectedGraph();
-  *     g.addVertex('A');
-  *     g.addVertex('B');
-  *     g.addVertex('C');
-  *     g.addEdge('A', 'C');
-  *     g.addEdge('B', 'C');
-  *     console.log(g.incomingEdgesOf('C').length); // 2;
-    */
+   * Incoming edges of a vertex.
+   * @param vertexOrKey - Vertex or key.
+   * @returns Array of incoming edges.
+   * @remarks Time O(deg_in), Space O(deg_in)
+   * @example
+   * // Get incoming edges
+   *  const g = new DirectedGraph();
+   *     g.addVertex('A');
+   *     g.addVertex('B');
+   *     g.addVertex('C');
+   *     g.addEdge('A', 'C');
+   *     g.addEdge('B', 'C');
+   *     console.log(g.incomingEdgesOf('C').length); // 2;
+   */
   incomingEdgesOf(vertexOrKey) {
     const target = this._getVertex(vertexOrKey);
     if (target) {
@@ -4180,59 +2986,20 @@ var DirectedGraph = class _DirectedGraph extends AbstractGraph {
     return [];
   }
   /**
-    * Outgoing edges of a vertex.
-    * @param vertexOrKey - Vertex or key.
-    * @returns Array of outgoing edges.
-    * @remarks Time O(deg_out), Space O(deg_out)
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-     * @example
-  * // Get outgoing edges
-  *  const g = new DirectedGraph();
-  *     g.addVertex('A');
-  *     g.addVertex('B');
-  *     g.addVertex('C');
-  *     g.addEdge('A', 'B');
-  *     g.addEdge('A', 'C');
-  *     console.log(g.outgoingEdgesOf('A').length); // 2;
-    */
+   * Outgoing edges of a vertex.
+   * @param vertexOrKey - Vertex or key.
+   * @returns Array of outgoing edges.
+   * @remarks Time O(deg_out), Space O(deg_out)
+   * @example
+   * // Get outgoing edges
+   *  const g = new DirectedGraph();
+   *     g.addVertex('A');
+   *     g.addVertex('B');
+   *     g.addVertex('C');
+   *     g.addEdge('A', 'B');
+   *     g.addEdge('A', 'C');
+   *     console.log(g.outgoingEdgesOf('A').length); // 2;
+   */
   outgoingEdgesOf(vertexOrKey) {
     const target = this._getVertex(vertexOrKey);
     if (target) {
@@ -4291,75 +3058,33 @@ var DirectedGraph = class _DirectedGraph extends AbstractGraph {
     return destinations;
   }
   /**
-    * Topological sort if DAG; returns `undefined` if a cycle exists.
-    * @param propertyName - `'key'` to map to keys; `'vertex'` to keep instances.
-    * @returns Array of keys/vertices, or `undefined` when cycle is found.
-    * @remarks Time O(V + E), Space O(V)
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-     * @example
-  * // DirectedGraph topologicalSort for task scheduling
-  *  const graph = new DirectedGraph<string>();
-  *
-  *     // Build a DAG (Directed Acyclic Graph) for task dependencies
-  *     graph.addVertex('Design');
-  *     graph.addVertex('Implement');
-  *     graph.addVertex('Test');
-  *     graph.addVertex('Deploy');
-  *
-  *     // Add dependency edges
-  *     graph.addEdge('Design', 'Implement', 1); // Design must come before Implement
-  *     graph.addEdge('Implement', 'Test', 1); // Implement must come before Test
-  *     graph.addEdge('Test', 'Deploy', 1); // Test must come before Deploy
-  *
-  *     // Topological sort gives valid execution order
-  *     const executionOrder = graph.topologicalSort();
-  *     console.log(executionOrder); // defined;
-  *     console.log(executionOrder); // ['Design', 'Implement', 'Test', 'Deploy'];
-  *
-  *     // All vertices should be included
-  *     console.log(executionOrder?.length); // 4;
-    */
+   * Topological sort if DAG; returns `undefined` if a cycle exists.
+   * @param propertyName - `'key'` to map to keys; `'vertex'` to keep instances.
+   * @returns Array of keys/vertices, or `undefined` when cycle is found.
+   * @remarks Time O(V + E), Space O(V)
+   * @example
+   * // DirectedGraph topologicalSort for task scheduling
+   *  const graph = new DirectedGraph<string>();
+   *
+   *     // Build a DAG (Directed Acyclic Graph) for task dependencies
+   *     graph.addVertex('Design');
+   *     graph.addVertex('Implement');
+   *     graph.addVertex('Test');
+   *     graph.addVertex('Deploy');
+   *
+   *     // Add dependency edges
+   *     graph.addEdge('Design', 'Implement', 1); // Design must come before Implement
+   *     graph.addEdge('Implement', 'Test', 1); // Implement must come before Test
+   *     graph.addEdge('Test', 'Deploy', 1); // Test must come before Deploy
+   *
+   *     // Topological sort gives valid execution order
+   *     const executionOrder = graph.topologicalSort();
+   *     console.log(executionOrder); // defined;
+   *     console.log(executionOrder); // ['Design', 'Implement', 'Test', 'Deploy'];
+   *
+   *     // All vertices should be included
+   *     console.log(executionOrder?.length); // 4;
+   */
   topologicalSort(propertyName) {
     propertyName = propertyName ?? "key";
     const statusMap = /* @__PURE__ */ new Map();
@@ -4392,54 +3117,15 @@ var DirectedGraph = class _DirectedGraph extends AbstractGraph {
     return sorted.reverse();
   }
   /**
-    * Get all edges
-   
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-     * @example
-  * // Get all edges
-  *  const g = new DirectedGraph();
-  *     g.addVertex('A');
-  *     g.addVertex('B');
-  *     g.addEdge('A', 'B', 3);
-  *     console.log(g.edgeSet().length); // 1;
-    */
+   * Get all edges
+   * @example
+   * // Get all edges
+   *  const g = new DirectedGraph();
+   *     g.addVertex('A');
+   *     g.addVertex('B');
+   *     g.addEdge('A', 'B', 3);
+   *     console.log(g.edgeSet().length); // 1;
+   */
   edgeSet() {
     let edgeMap = [];
     this._outEdgeMap.forEach((outEdges) => {
@@ -4448,58 +3134,18 @@ var DirectedGraph = class _DirectedGraph extends AbstractGraph {
     return edgeMap;
   }
   /**
-    * Get outgoing neighbors
-   
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-     * @example
-  * // Get outgoing neighbors
-  *  const g = new DirectedGraph();
-  *     g.addVertex('A');
-  *     g.addVertex('B');
-  *     g.addVertex('C');
-  *     g.addEdge('A', 'B');
-  *     g.addEdge('A', 'C');
-  *     const neighbors = g.getNeighbors('A');
-  *     console.log(neighbors.map(v => v.key).sort()); // ['B', 'C'];
-    */
+   * Get outgoing neighbors
+   * @example
+   * // Get outgoing neighbors
+   *  const g = new DirectedGraph();
+   *     g.addVertex('A');
+   *     g.addVertex('B');
+   *     g.addVertex('C');
+   *     g.addEdge('A', 'B');
+   *     g.addEdge('A', 'C');
+   *     const neighbors = g.getNeighbors('A');
+   *     console.log(neighbors.map(v => v.key).sort()); // ['B', 'C'];
+   */
   getNeighbors(vertexOrKey) {
     const neighbors = [];
     const vertex = this._getVertex(vertexOrKey);
@@ -4557,62 +3203,23 @@ var DirectedGraph = class _DirectedGraph extends AbstractGraph {
     return super.clone();
   }
   /**
-    * Tarjan's algorithm for strongly connected components.
-    * @returns `{ dfnMap, lowMap, SCCs }`.
-    * @remarks Time O(V + E), Space O(V + E)
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-     * @example
-  * // Find strongly connected components
-  *  const g = new DirectedGraph();
-  *     g.addVertex('A');
-  *     g.addVertex('B');
-  *     g.addVertex('C');
-  *     g.addEdge('A', 'B');
-  *     g.addEdge('B', 'C');
-  *     g.addEdge('C', 'A');
-  *     const { SCCs } = g.tarjan();
-  *     // A→B→C→A forms one SCC with 3 members
-  *     const sccArrays = [...SCCs.values()];
-  *     console.log(sccArrays.some(scc => scc.length === 3)); // true;
-    */
+   * Tarjan's algorithm for strongly connected components.
+   * @returns `{ dfnMap, lowMap, SCCs }`.
+   * @remarks Time O(V + E), Space O(V + E)
+   * @example
+   * // Find strongly connected components
+   *  const g = new DirectedGraph();
+   *     g.addVertex('A');
+   *     g.addVertex('B');
+   *     g.addVertex('C');
+   *     g.addEdge('A', 'B');
+   *     g.addEdge('B', 'C');
+   *     g.addEdge('C', 'A');
+   *     const { SCCs } = g.tarjan();
+   *     // A→B→C→A forms one SCC with 3 members
+   *     const sccArrays = [...SCCs.values()];
+   *     console.log(sccArrays.some(scc => scc.length === 3)); // true;
+   */
   tarjan() {
     const dfnMap = /* @__PURE__ */ new Map();
     const lowMap = /* @__PURE__ */ new Map();
@@ -4670,60 +3277,21 @@ var DirectedGraph = class _DirectedGraph extends AbstractGraph {
     return this.tarjan().lowMap;
   }
   /**
-    * Strongly connected components computed by `tarjan()`.
-    * @returns Map from SCC id to vertices.
-    * @remarks Time O(#SCC + V), Space O(V)
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-     * @example
-  * // Get strongly connected components
-  *  const g = new DirectedGraph();
-  *     g.addVertex(1);
-  *     g.addVertex(2);
-  *     g.addVertex(3);
-  *     g.addEdge(1, 2);
-  *     g.addEdge(2, 3);
-  *     g.addEdge(3, 1);
-  *     const sccs = g.getSCCs(); // Map<number, VO[]>
-  *     console.log(sccs.size); // >= 1;
-    */
+   * Strongly connected components computed by `tarjan()`.
+   * @returns Map from SCC id to vertices.
+   * @remarks Time O(#SCC + V), Space O(V)
+   * @example
+   * // Get strongly connected components
+   *  const g = new DirectedGraph();
+   *     g.addVertex(1);
+   *     g.addVertex(2);
+   *     g.addVertex(3);
+   *     g.addEdge(1, 2);
+   *     g.addEdge(2, 3);
+   *     g.addEdge(3, 1);
+   *     const sccs = g.getSCCs(); // Map<number, VO[]>
+   *     console.log(sccs.size); // >= 1;
+   */
   getSCCs() {
     return this.tarjan().SCCs;
   }
@@ -4847,58 +3415,19 @@ var UndirectedGraph = class _UndirectedGraph extends AbstractGraph {
     return new UndirectedEdge(v1, v2, weight ?? this.options.defaultEdgeWeight ?? 1, value);
   }
   /**
-    * Get an undirected edge between two vertices, if present.
-    * @param v1 - One vertex or key.
-    * @param v2 - The other vertex or key.
-    * @returns Edge instance or `undefined`.
-    * @remarks Time O(1) avg, Space O(1)
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-     * @example
-  * // Get edge between vertices
-  *  const g = new UndirectedGraph();
-  *     g.addVertex('A');
-  *     g.addVertex('B');
-  *     g.addEdge('A', 'B', 7);
-  *     console.log(g.getEdge('A', 'B')?.weight); // 7;
-    */
+   * Get an undirected edge between two vertices, if present.
+   * @param v1 - One vertex or key.
+   * @param v2 - The other vertex or key.
+   * @returns Edge instance or `undefined`.
+   * @remarks Time O(1) avg, Space O(1)
+   * @example
+   * // Get edge between vertices
+   *  const g = new UndirectedGraph();
+   *     g.addVertex('A');
+   *     g.addVertex('B');
+   *     g.addEdge('A', 'B', 7);
+   *     console.log(g.getEdge('A', 'B')?.weight); // 7;
+   */
   getEdge(v1, v2) {
     let edgeMap = [];
     if (v1 !== void 0 && v2 !== void 0) {
@@ -4935,81 +3464,39 @@ var UndirectedGraph = class _UndirectedGraph extends AbstractGraph {
     return removed;
   }
   /**
-    * Delete an edge by instance or by a pair of keys.
-    * @param edgeOrOneSideVertexKey - Edge instance or one endpoint vertex/key.
-    * @param otherSideVertexKey - Required second endpoint when deleting by pair.
-    * @returns Removed edge or `undefined`.
-    * @remarks Time O(1) avg, Space O(1)
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-     * @example
-  * // UndirectedGraph deleteEdge and vertex operations
-  *  const graph = new UndirectedGraph<string>();
-  *
-  *     // Build a simple undirected graph
-  *     graph.addVertex('X');
-  *     graph.addVertex('Y');
-  *     graph.addVertex('Z');
-  *     graph.addEdge('X', 'Y', 1);
-  *     graph.addEdge('Y', 'Z', 2);
-  *     graph.addEdge('X', 'Z', 3);
-  *
-  *     // Delete an edge
-  *     graph.deleteEdge('X', 'Y');
-  *     console.log(graph.hasEdge('X', 'Y')); // false;
-  *
-  *     // Bidirectional deletion confirmed
-  *     console.log(graph.hasEdge('Y', 'X')); // false;
-  *
-  *     // Other edges should remain
-  *     console.log(graph.hasEdge('Y', 'Z')); // true;
-  *     console.log(graph.hasEdge('Z', 'Y')); // true;
-  *
-  *     // Delete a vertex
-  *     graph.deleteVertex('Y');
-  *     console.log(graph.hasVertex('Y')); // false;
-  *     console.log(graph.size); // 2;
-    */
+   * Delete an edge by instance or by a pair of keys.
+   * @param edgeOrOneSideVertexKey - Edge instance or one endpoint vertex/key.
+   * @param otherSideVertexKey - Required second endpoint when deleting by pair.
+   * @returns Removed edge or `undefined`.
+   * @remarks Time O(1) avg, Space O(1)
+   * @example
+   * // UndirectedGraph deleteEdge and vertex operations
+   *  const graph = new UndirectedGraph<string>();
+   *
+   *     // Build a simple undirected graph
+   *     graph.addVertex('X');
+   *     graph.addVertex('Y');
+   *     graph.addVertex('Z');
+   *     graph.addEdge('X', 'Y', 1);
+   *     graph.addEdge('Y', 'Z', 2);
+   *     graph.addEdge('X', 'Z', 3);
+   *
+   *     // Delete an edge
+   *     graph.deleteEdge('X', 'Y');
+   *     console.log(graph.hasEdge('X', 'Y')); // false;
+   *
+   *     // Bidirectional deletion confirmed
+   *     console.log(graph.hasEdge('Y', 'X')); // false;
+   *
+   *     // Other edges should remain
+   *     console.log(graph.hasEdge('Y', 'Z')); // true;
+   *     console.log(graph.hasEdge('Z', 'Y')); // true;
+   *
+   *     // Delete a vertex
+   *     graph.deleteVertex('Y');
+   *     console.log(graph.hasVertex('Y')); // false;
+   *     console.log(graph.size); // 2;
+   */
   deleteEdge(edgeOrOneSideVertexKey, otherSideVertexKey) {
     let oneSide, otherSide;
     if (this.isVertexKey(edgeOrOneSideVertexKey)) {
@@ -5030,58 +3517,19 @@ var UndirectedGraph = class _UndirectedGraph extends AbstractGraph {
     }
   }
   /**
-    * Delete a vertex and remove it from all neighbor lists.
-    * @param vertexOrKey - Vertex or key.
-    * @returns `true` if removed; otherwise `false`.
-    * @remarks Time O(deg), Space O(1)
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-     * @example
-  * // Remove vertex and edges
-  *  const g = new UndirectedGraph();
-  *     g.addVertex('A');
-  *     g.addVertex('B');
-  *     g.addEdge('A', 'B');
-  *     g.deleteVertex('A');
-  *     console.log(g.hasVertex('A')); // false;
-    */
+   * Delete a vertex and remove it from all neighbor lists.
+   * @param vertexOrKey - Vertex or key.
+   * @returns `true` if removed; otherwise `false`.
+   * @remarks Time O(deg), Space O(1)
+   * @example
+   * // Remove vertex and edges
+   *  const g = new UndirectedGraph();
+   *     g.addVertex('A');
+   *     g.addVertex('B');
+   *     g.addEdge('A', 'B');
+   *     g.deleteVertex('A');
+   *     console.log(g.hasVertex('A')); // false;
+   */
   deleteVertex(vertexOrKey) {
     let vertexKey;
     let vertex;
@@ -5136,56 +3584,17 @@ var UndirectedGraph = class _UndirectedGraph extends AbstractGraph {
     }
   }
   /**
-    * Unique set of undirected edges across endpoints.
-    * @returns Array of edges.
-    * @remarks Time O(E), Space O(E)
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-     * @example
-  * // Get all edges
-  *  const g = new UndirectedGraph();
-  *     g.addVertex('A');
-  *     g.addVertex('B');
-  *     g.addEdge('A', 'B');
-  *     console.log(g.edgeSet().length); // 1;
-    */
+   * Unique set of undirected edges across endpoints.
+   * @returns Array of edges.
+   * @remarks Time O(E), Space O(E)
+   * @example
+   * // Get all edges
+   *  const g = new UndirectedGraph();
+   *     g.addVertex('A');
+   *     g.addVertex('B');
+   *     g.addEdge('A', 'B');
+   *     console.log(g.edgeSet().length); // 1;
+   */
   edgeSet() {
     const edgeSet = /* @__PURE__ */ new Set();
     this._edgeMap.forEach((edgeMap) => {
@@ -5196,82 +3605,40 @@ var UndirectedGraph = class _UndirectedGraph extends AbstractGraph {
     return [...edgeSet];
   }
   /**
-    * UndirectedGraph connectivity and neighbors
-   
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-     * @example
-  * // UndirectedGraph connectivity and neighbors
-  *  const graph = new UndirectedGraph<string>();
-  *
-  *     // Build a friendship network
-  *     const people = ['Alice', 'Bob', 'Charlie', 'Diana', 'Eve'];
-  *     for (const person of people) {
-  *       graph.addVertex(person);
-  *     }
-  *
-  *     // Add friendships (undirected edges)
-  *     graph.addEdge('Alice', 'Bob', 1);
-  *     graph.addEdge('Alice', 'Charlie', 1);
-  *     graph.addEdge('Bob', 'Diana', 1);
-  *     graph.addEdge('Charlie', 'Eve', 1);
-  *     graph.addEdge('Diana', 'Eve', 1);
-  *
-  *     // Get friends of each person
-  *     const aliceFriends = graph.getNeighbors('Alice');
-  *     console.log(aliceFriends[0].key); // 'Bob';
-  *     console.log(aliceFriends[1].key); // 'Charlie';
-  *     console.log(aliceFriends.length); // 2;
-  *
-  *     const dianaFriends = graph.getNeighbors('Diana');
-  *     console.log(dianaFriends[0].key); // 'Bob';
-  *     console.log(dianaFriends[1].key); // 'Eve';
-  *     console.log(dianaFriends.length); // 2;
-  *
-  *     // Verify bidirectional friendship
-  *     const bobFriends = graph.getNeighbors('Bob');
-  *     console.log(bobFriends[0].key); // 'Alice'; // Alice -> Bob -> Alice ✓
-  *     console.log(bobFriends[1].key); // 'Diana';
-    */
+   * UndirectedGraph connectivity and neighbors
+   * @example
+   * // UndirectedGraph connectivity and neighbors
+   *  const graph = new UndirectedGraph<string>();
+   *
+   *     // Build a friendship network
+   *     const people = ['Alice', 'Bob', 'Charlie', 'Diana', 'Eve'];
+   *     for (const person of people) {
+   *       graph.addVertex(person);
+   *     }
+   *
+   *     // Add friendships (undirected edges)
+   *     graph.addEdge('Alice', 'Bob', 1);
+   *     graph.addEdge('Alice', 'Charlie', 1);
+   *     graph.addEdge('Bob', 'Diana', 1);
+   *     graph.addEdge('Charlie', 'Eve', 1);
+   *     graph.addEdge('Diana', 'Eve', 1);
+   *
+   *     // Get friends of each person
+   *     const aliceFriends = graph.getNeighbors('Alice');
+   *     console.log(aliceFriends[0].key); // 'Bob';
+   *     console.log(aliceFriends[1].key); // 'Charlie';
+   *     console.log(aliceFriends.length); // 2;
+   *
+   *     const dianaFriends = graph.getNeighbors('Diana');
+   *     console.log(dianaFriends[0].key); // 'Bob';
+   *     console.log(dianaFriends[1].key); // 'Eve';
+   *     console.log(dianaFriends.length); // 2;
+   *
+   *     // Verify bidirectional friendship
+   *     const bobFriends = graph.getNeighbors('Bob');
+   *     console.log(bobFriends[0].key); // 'Alice'; // Alice -> Bob -> Alice ✓
+   *     console.log(bobFriends[1].key); // 'Diana';
+   */
   getNeighbors(vertexOrKey) {
     const neighbors = [];
     const vertex = this._getVertex(vertexOrKey);
@@ -5328,59 +3695,20 @@ var UndirectedGraph = class _UndirectedGraph extends AbstractGraph {
     return super.clone();
   }
   /**
-    * Tarjan-based bridge and articulation point detection.
-    * @returns `{ dfnMap, lowMap, bridges, cutVertices }`.
-    * @remarks Time O(V + E), Space O(V + E)
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-     * @example
-  * // Find articulation points and bridges
-  *  const g = new UndirectedGraph();
-  *     g.addVertex('A');
-  *     g.addVertex('B');
-  *     g.addVertex('C');
-  *     g.addEdge('A', 'B');
-  *     g.addEdge('B', 'C');
-  *     const result = g.tarjan();
-  *     console.log(result); // defined;
-    */
+   * Tarjan-based bridge and articulation point detection.
+   * @returns `{ dfnMap, lowMap, bridges, cutVertices }`.
+   * @remarks Time O(V + E), Space O(V + E)
+   * @example
+   * // Find articulation points and bridges
+   *  const g = new UndirectedGraph();
+   *     g.addVertex('A');
+   *     g.addVertex('B');
+   *     g.addVertex('C');
+   *     g.addEdge('A', 'B');
+   *     g.addEdge('B', 'C');
+   *     const result = g.tarjan();
+   *     console.log(result); // defined;
+   */
   tarjan() {
     const dfnMap = /* @__PURE__ */ new Map();
     const lowMap = /* @__PURE__ */ new Map();
@@ -5480,61 +3808,22 @@ var UndirectedGraph = class _UndirectedGraph extends AbstractGraph {
     return components;
   }
   /**
-    * Detect whether the graph contains a cycle.
-    * Uses DFS with parent tracking.
-    * @returns `true` if a cycle exists, `false` otherwise.
-    * @remarks Time O(V + E), Space O(V)
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-     * @example
-  * // Detect cycle
-  *  const g = new UndirectedGraph();
-  *     g.addVertex('A');
-  *     g.addVertex('B');
-  *     g.addVertex('C');
-  *     g.addEdge('A', 'B');
-  *     g.addEdge('B', 'C');
-  *     console.log(g.hasCycle()); // false;
-  *     g.addEdge('C', 'A');
-  *     console.log(g.hasCycle()); // true;
-    */
+   * Detect whether the graph contains a cycle.
+   * Uses DFS with parent tracking.
+   * @returns `true` if a cycle exists, `false` otherwise.
+   * @remarks Time O(V + E), Space O(V)
+   * @example
+   * // Detect cycle
+   *  const g = new UndirectedGraph();
+   *     g.addVertex('A');
+   *     g.addVertex('B');
+   *     g.addVertex('C');
+   *     g.addEdge('A', 'B');
+   *     g.addEdge('B', 'C');
+   *     console.log(g.hasCycle()); // false;
+   *     g.addEdge('C', 'A');
+   *     console.log(g.hasCycle()); // true;
+   */
   hasCycle() {
     const visited = /* @__PURE__ */ new Set();
     const dfs = /* @__PURE__ */ __name((vertex, parent) => {
@@ -5556,117 +3845,39 @@ var UndirectedGraph = class _UndirectedGraph extends AbstractGraph {
     return false;
   }
   /**
-    * Get bridges discovered by `tarjan()`.
-    * @returns Array of edges that are bridges.
-    * @remarks Time O(B), Space O(1)
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-     * @example
-  * // Find bridge edges
-  *  const g = new UndirectedGraph();
-  *     g.addVertex('A');
-  *     g.addVertex('B');
-  *     g.addVertex('C');
-  *     g.addEdge('A', 'B');
-  *     g.addEdge('B', 'C');
-  *     const bridges = g.getBridges();
-  *     console.log(bridges.length); // 2;
-    */
+   * Get bridges discovered by `tarjan()`.
+   * @returns Array of edges that are bridges.
+   * @remarks Time O(B), Space O(1)
+   * @example
+   * // Find bridge edges
+   *  const g = new UndirectedGraph();
+   *     g.addVertex('A');
+   *     g.addVertex('B');
+   *     g.addVertex('C');
+   *     g.addEdge('A', 'B');
+   *     g.addEdge('B', 'C');
+   *     const bridges = g.getBridges();
+   *     console.log(bridges.length); // 2;
+   */
   getBridges() {
     return this.tarjan().bridges;
   }
   /**
-    * Get articulation points discovered by `tarjan()`.
-    * @returns Array of cut vertices.
-    * @remarks Time O(C), Space O(1)
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-     * @example
-  * // Find articulation points
-  *  const g = new UndirectedGraph();
-  *     g.addVertex('A');
-  *     g.addVertex('B');
-  *     g.addVertex('C');
-  *     g.addEdge('A', 'B');
-  *     g.addEdge('B', 'C');
-  *     const cuts = g.getCutVertices();
-  *     console.log(cuts.length); // 1;
-  *     console.log(cuts[0].key); // 'B';
-    */
+   * Get articulation points discovered by `tarjan()`.
+   * @returns Array of cut vertices.
+   * @remarks Time O(C), Space O(1)
+   * @example
+   * // Find articulation points
+   *  const g = new UndirectedGraph();
+   *     g.addVertex('A');
+   *     g.addVertex('B');
+   *     g.addVertex('C');
+   *     g.addEdge('A', 'B');
+   *     g.addEdge('B', 'C');
+   *     const cuts = g.getCutVertices();
+   *     console.log(cuts.length); // 1;
+   *     console.log(cuts[0].key); // 'B';
+   */
   getCutVertices() {
     return this.tarjan().cutVertices;
   }