graph-typed 2.4.4 → 2.5.0

package/dist/umd/graph-typed.js

@@ -30,6 +30,7 @@ var graphTyped = (() => {
     DirectedEdge: () => DirectedEdge,
     DirectedGraph: () => DirectedGraph,
     DirectedVertex: () => DirectedVertex,
+    ERR: () => ERR,
     MapEdge: () => MapEdge,
     MapGraph: () => MapGraph,
     MapVertex: () => MapVertex,
@@ -60,6 +61,52 @@ var graphTyped = (() => {
     return result;
   };
 
+  // src/common/error.ts
+  var ERR = {
+    // Range / index
+    indexOutOfRange: (index, min, max, ctx) => `${ctx ? ctx + ": " : ""}Index ${index} is out of range [${min}, ${max}].`,
+    invalidIndex: (ctx) => `${ctx ? ctx + ": " : ""}Index must be an integer.`,
+    // Type / argument
+    invalidArgument: (reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`,
+    comparatorRequired: (ctx) => `${ctx ? ctx + ": " : ""}Comparator is required for non-number/non-string/non-Date keys.`,
+    invalidKey: (reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`,
+    notAFunction: (name, ctx) => `${ctx ? ctx + ": " : ""}${name} must be a function.`,
+    invalidEntry: (ctx) => `${ctx ? ctx + ": " : ""}Each entry must be a [key, value] tuple.`,
+    invalidNaN: (ctx) => `${ctx ? ctx + ": " : ""}NaN is not a valid key.`,
+    invalidDate: (ctx) => `${ctx ? ctx + ": " : ""}Invalid Date key.`,
+    reduceEmpty: (ctx) => `${ctx ? ctx + ": " : ""}Reduce of empty structure with no initial value.`,
+    callbackReturnType: (expected, got, ctx) => `${ctx ? ctx + ": " : ""}Callback must return ${expected}; got ${got}.`,
+    // State / operation
+    invalidOperation: (reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`,
+    // Matrix
+    matrixDimensionMismatch: (op) => `Matrix: Dimensions must be compatible for ${op}.`,
+    matrixSingular: () => "Matrix: Singular matrix, inverse does not exist.",
+    matrixNotSquare: () => "Matrix: Must be square for inversion.",
+    matrixNotRectangular: () => "Matrix: Must be rectangular for transposition.",
+    matrixRowMismatch: (expected, got) => `Matrix: Expected row length ${expected}, but got ${got}.`
+  };
+
+  // src/common/index.ts
+  var DFSOperation = /* @__PURE__ */ ((DFSOperation2) => {
+    DFSOperation2[DFSOperation2["VISIT"] = 0] = "VISIT";
+    DFSOperation2[DFSOperation2["PROCESS"] = 1] = "PROCESS";
+    return DFSOperation2;
+  })(DFSOperation || {});
+  var Range = class {
+    constructor(low, high, includeLow = true, includeHigh = true) {
+      this.low = low;
+      this.high = high;
+      this.includeLow = includeLow;
+      this.includeHigh = includeHigh;
+    }
+    // Determine whether a key is within the range
+    isInRange(key, comparator) {
+      const lowCheck = this.includeLow ? comparator(key, this.low) >= 0 : comparator(key, this.low) > 0;
+      const highCheck = this.includeHigh ? comparator(key, this.high) <= 0 : comparator(key, this.high) < 0;
+      return lowCheck && highCheck;
+    }
+  };
+
   // src/data-structures/base/iterable-entry-base.ts
   var IterableEntryBase = class {
     /**
@@ -474,7 +521,7 @@ var graphTyped = (() => {
       __publicField(this, "_elements", []);
       __publicField(this, "_DEFAULT_COMPARATOR", (a, b) => {
         if (typeof a === "object" || typeof b === "object") {
-          throw TypeError("When comparing object types, define a custom comparator in options.");
+          throw new TypeError(ERR.comparatorRequired("Heap"));
         }
         if (a > b) return 1;
         if (a < b) return -1;
@@ -496,10 +543,30 @@ var graphTyped = (() => {
       return this._elements;
     }
     /**
-     * Get the number of elements.
-     * @remarks Time O(1), Space O(1)
-     * @returns Heap size.
-     */
+      * 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;
     }
@@ -538,21 +605,61 @@ var graphTyped = (() => {
       return new _Heap(elements, options);
     }
     /**
-     * Insert an element.
-     * @remarks Time O(1) amortized, Space O(1)
-     * @param element - Element to insert.
-     * @returns True.
-     */
+      * Insert an element.
+      * @remarks Time O(1) 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.
-     */
+      * 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) {
@@ -567,10 +674,46 @@ var graphTyped = (() => {
       return flags;
     }
     /**
-     * Remove and return the top element.
-     * @remarks Time O(log N), Space O(1)
-     * @returns Top element or undefined.
-     */
+      * 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';
+      */
     poll() {
       if (this.elements.length === 0) return;
       const value = this.elements[0];
@@ -582,26 +725,125 @@ var graphTyped = (() => {
       return value;
     }
     /**
-     * Get the current top element without removing it.
-     * @remarks Time O(1), Space O(1)
-     * @returns Top element or undefined.
-     */
+      * 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.
-     */
+      * 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
-     */
+      * 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 = [];
     }
@@ -616,21 +858,41 @@ var graphTyped = (() => {
       return this.fix();
     }
     /**
-     * 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.
-     */
+      * 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.
-     */
+      * 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++) {
@@ -688,11 +950,18 @@ var graphTyped = (() => {
       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.
-     */
+      * 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 = (index) => {
@@ -729,10 +998,26 @@ var graphTyped = (() => {
       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.
-     */
+      * 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();
@@ -744,22 +1029,52 @@ var graphTyped = (() => {
       return visited;
     }
     /**
-     * Deep clone this heap.
-     * @remarks Time O(N), Space O(N)
-     * @returns A new heap with the same elements.
-     */
+      * 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.
-     */
+      * 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;
@@ -773,18 +1088,31 @@ var graphTyped = (() => {
       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.
-     */
+      * 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 != null ? options : {};
-      if (!comparator) throw new TypeError("Heap.map requires options.comparator for EM");
+      if (!comparator) throw new TypeError(ERR.comparatorRequired("Heap.map"));
       const out = this._createLike([], { ...rest, comparator, toElementFn });
       let i = 0;
       for (const x of this) {
@@ -1129,18 +1457,52 @@ var graphTyped = (() => {
       this._autoCompactRatio = value;
     }
     /**
-     * Get the number of elements currently in the queue.
-     * @remarks Time O(1), Space O(1)
-     * @returns Current length.
-     */
+      * 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.
-     */
+      * 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;
     }
@@ -1163,19 +1525,69 @@ var graphTyped = (() => {
       return new _Queue(elements);
     }
     /**
-     * Check whether the queue is empty.
-     * @remarks Time O(1), Space O(1)
-     * @returns True if length is 0.
-     */
+      * 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.
-     */
+      * 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();
@@ -1196,10 +1608,35 @@ var graphTyped = (() => {
       return ans;
     }
     /**
-     * Dequeue one element from the front (amortized via offset).
-     * @remarks Time O(1) amortized, Space O(1)
-     * @returns Removed element or undefined.
-     */
+      * 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;
@@ -1208,11 +1645,24 @@ var graphTyped = (() => {
       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.
-     */
+      * 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)) {
@@ -1223,11 +1673,24 @@ var graphTyped = (() => {
       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.
-     */
+      * 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];
@@ -1279,19 +1742,48 @@ var graphTyped = (() => {
       return this;
     }
     /**
-     * Remove all elements and reset offset.
-     * @remarks Time O(1), Space O(1)
-     * @returns void
-     */
+      * 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.
-     */
+      * 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;
@@ -1317,10 +1809,26 @@ var graphTyped = (() => {
       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.
-     */
+      * 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);
@@ -1328,12 +1836,26 @@ var graphTyped = (() => {
       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.
-     */
+      * 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);
@@ -1345,15 +1867,28 @@ var graphTyped = (() => {
       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.
-     */
+      * 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) {
       var _a, _b;
       const out = new this.constructor([], {
@@ -1576,7 +2111,7 @@ var graphTyped = (() => {
           const newEdge = this.createEdge(srcOrEdge, dest, weight, value);
           return this._addEdge(newEdge);
         } else {
-          throw new Error("dest must be a Vertex or vertex key while srcOrEdge is an Edge");
+          throw new TypeError(ERR.invalidArgument("dest must be a Vertex or vertex key when srcOrEdge is an Edge.", "Graph"));
         }
       }
     }
@@ -2260,6 +2795,94 @@ var graphTyped = (() => {
     _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) {
+      var _a;
+      const showWeight = (_a = options == null ? void 0 : options.showWeight) != null ? _a : 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) {
+      var _a, _b;
+      const name = (_a = options == null ? void 0 : options.name) != null ? _a : "G";
+      const showWeight = (_b = options == null ? void 0 : options.showWeight) != null ? _b : 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
@@ -2288,6 +2911,9 @@ var graphTyped = (() => {
       __publicField(this, "_outEdgeMap", /* @__PURE__ */ new Map());
       __publicField(this, "_inEdgeMap", /* @__PURE__ */ new Map());
     }
+    get _edgeConnector() {
+      return "->";
+    }
     get outEdgeMap() {
       return this._outEdgeMap;
     }
@@ -2350,12 +2976,28 @@ var graphTyped = (() => {
       return new DirectedEdge(src, dest, (_a = weight != null ? weight : this.options.defaultEdgeWeight) != null ? _a : 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)
-     */
+      * 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) {
@@ -2395,12 +3037,48 @@ var graphTyped = (() => {
       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)
-     */
+      * 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;
@@ -2427,6 +3105,26 @@ var graphTyped = (() => {
       }
       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;
+      */
     deleteVertex(vertexOrKey) {
       let vertexKey;
       let vertex;
@@ -2458,11 +3156,28 @@ var graphTyped = (() => {
       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)
-     */
+      * 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) {
@@ -2471,11 +3186,28 @@ var graphTyped = (() => {
       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)
-     */
+      * 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) {
@@ -2534,11 +3266,44 @@ var graphTyped = (() => {
       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)
-     */
+      * 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 != null ? propertyName : "key";
       const statusMap = /* @__PURE__ */ new Map();
@@ -2570,6 +3335,24 @@ var graphTyped = (() => {
       if (propertyName === "key") sorted = sorted.map((vertex) => vertex instanceof DirectedVertex ? vertex.key : vertex);
       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;
+      */
     edgeSet() {
       let edgeMap = [];
       this._outEdgeMap.forEach((outEdges) => {
@@ -2577,6 +3360,28 @@ var graphTyped = (() => {
       });
       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'];
+      */
     getNeighbors(vertexOrKey) {
       const neighbors = [];
       const vertex = this._getVertex(vertexOrKey);
@@ -2634,10 +3439,31 @@ var graphTyped = (() => {
       return super.clone();
     }
     /**
-     * Tarjan's algorithm for strongly connected components.
-     * @returns `{ dfnMap, lowMap, SCCs }`.
-     * @remarks Time O(V + E), Space O(V + E)
-     */
+      * 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();
@@ -2695,10 +3521,29 @@ var graphTyped = (() => {
       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)
-     */
+      * 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;
     }
@@ -2814,12 +3659,27 @@ var graphTyped = (() => {
       return new UndirectedEdge(v1, v2, (_a = weight != null ? weight : this.options.defaultEdgeWeight) != null ? _a : 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)
-     */
+      * 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) {
       var _a;
       let edgeMap = [];
@@ -2857,12 +3717,50 @@ var graphTyped = (() => {
       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)
-     */
+      * 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)) {
@@ -2883,11 +3781,27 @@ var graphTyped = (() => {
       }
     }
     /**
-     * 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)
-     */
+      * 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;
@@ -2943,10 +3857,25 @@ var graphTyped = (() => {
       }
     }
     /**
-     * Unique set of undirected edges across endpoints.
-     * @returns Array of edges.
-     * @remarks Time O(E), Space O(E)
-     */
+      * 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) => {
@@ -2956,6 +3885,52 @@ var graphTyped = (() => {
       });
       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';
+      */
     getNeighbors(vertexOrKey) {
       const neighbors = [];
       const vertex = this._getVertex(vertexOrKey);
@@ -3012,10 +3987,28 @@ var graphTyped = (() => {
       return super.clone();
     }
     /**
-     * Tarjan-based bridge and articulation point detection.
-     * @returns `{ dfnMap, lowMap, bridges, cutVertices }`.
-     * @remarks Time O(V + E), Space O(V + E)
-     */
+      * 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();
@@ -3063,18 +4056,152 @@ var graphTyped = (() => {
       };
     }
     /**
-     * Get bridges discovered by `tarjan()`.
-     * @returns Array of edges that are bridges.
-     * @remarks Time O(B), Space O(1)
+     * Find biconnected components using edge-stack Tarjan variant.
+     * A biconnected component is a maximal biconnected subgraph.
+     * @returns Array of edge arrays, each representing a biconnected component.
+     * @remarks Time O(V + E), Space O(V + E)
      */
+    getBiconnectedComponents() {
+      const dfn = /* @__PURE__ */ new Map();
+      const low = /* @__PURE__ */ new Map();
+      const edgeStack = [];
+      const components = [];
+      let time = 0;
+      const dfs = (vertex, parent) => {
+        dfn.set(vertex, time);
+        low.set(vertex, time);
+        time++;
+        const neighbors = this.getNeighbors(vertex);
+        let childCount = 0;
+        for (const neighbor of neighbors) {
+          const edge = this.getEdge(vertex, neighbor);
+          if (!edge) continue;
+          if (!dfn.has(neighbor)) {
+            childCount++;
+            edgeStack.push(edge);
+            dfs(neighbor, vertex);
+            low.set(vertex, Math.min(low.get(vertex), low.get(neighbor)));
+            if (parent === void 0 && childCount > 1 || parent !== void 0 && low.get(neighbor) >= dfn.get(vertex)) {
+              const component = [];
+              let e;
+              do {
+                e = edgeStack.pop();
+                if (e) component.push(e);
+              } while (e && e !== edge);
+              if (component.length > 0) components.push(component);
+            }
+          } else if (neighbor !== parent && dfn.get(neighbor) < dfn.get(vertex)) {
+            edgeStack.push(edge);
+            low.set(vertex, Math.min(low.get(vertex), dfn.get(neighbor)));
+          }
+        }
+      };
+      for (const vertex of this.vertexMap.values()) {
+        if (!dfn.has(vertex)) {
+          dfs(vertex, void 0);
+          if (edgeStack.length > 0) {
+            components.push([...edgeStack]);
+            edgeStack.length = 0;
+          }
+        }
+      }
+      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;
+      */
+    hasCycle() {
+      const visited = /* @__PURE__ */ new Set();
+      const dfs = (vertex, parent) => {
+        visited.add(vertex);
+        for (const neighbor of this.getNeighbors(vertex)) {
+          if (!visited.has(neighbor)) {
+            if (dfs(neighbor, vertex)) return true;
+          } else if (neighbor !== parent) {
+            return true;
+          }
+        }
+        return false;
+      };
+      for (const vertex of this.vertexMap.values()) {
+        if (!visited.has(vertex)) {
+          if (dfs(vertex, void 0)) return true;
+        }
+      }
+      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;
+      */
     getBridges() {
       return this.tarjan().bridges;
     }
     /**
-     * Get articulation points discovered by `tarjan()`.
-     * @returns Array of cut vertices.
-     * @remarks Time O(C), Space O(1)
-     */
+      * 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;
     }
@@ -3205,27 +4332,6 @@ var graphTyped = (() => {
       return new _MapGraph(oc, br);
     }
   };
-
-  // src/common/index.ts
-  var DFSOperation = /* @__PURE__ */ ((DFSOperation2) => {
-    DFSOperation2[DFSOperation2["VISIT"] = 0] = "VISIT";
-    DFSOperation2[DFSOperation2["PROCESS"] = 1] = "PROCESS";
-    return DFSOperation2;
-  })(DFSOperation || {});
-  var Range = class {
-    constructor(low, high, includeLow = true, includeHigh = true) {
-      this.low = low;
-      this.high = high;
-      this.includeLow = includeLow;
-      this.includeHigh = includeHigh;
-    }
-    // Determine whether a key is within the range
-    isInRange(key, comparator) {
-      const lowCheck = this.includeLow ? comparator(key, this.low) >= 0 : comparator(key, this.low) > 0;
-      const highCheck = this.includeHigh ? comparator(key, this.high) <= 0 : comparator(key, this.high) < 0;
-      return lowCheck && highCheck;
-    }
-  };
   return __toCommonJS(src_exports);
 })();
 /**