queue-typed 2.4.4 → 2.5.0

package/dist/umd/queue-typed.js

@@ -25,6 +25,7 @@ var queueTyped = (() => {
   __export(src_exports, {
     DFSOperation: () => DFSOperation,
     Deque: () => Deque,
+    ERR: () => ERR,
     LinkedListQueue: () => LinkedListQueue,
     Queue: () => Queue,
     Range: () => Range
@@ -736,11 +737,37 @@ var queueTyped = (() => {
       return list;
     }
     /**
-     * Append an element/node to the tail.
-     * @remarks Time O(1), Space O(1)
-     * @param elementOrNode - Element or node to append.
-     * @returns True when appended.
-     */
+      * Append an element/node to the tail.
+      * @remarks Time O(1), Space O(1)
+      * @param elementOrNode - Element or node to append.
+      * @returns True when appended.
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+       * @example
+    * // basic SinglyLinkedList creation and push operation
+    *  // Create a simple SinglyLinkedList with initial values
+    *     const list = new SinglyLinkedList([1, 2, 3, 4, 5]);
+    *
+    *     // Verify the list maintains insertion order
+    *     console.log([...list]); // [1, 2, 3, 4, 5];
+    *
+    *     // Check length
+    *     console.log(list.length); // 5;
+    *
+    *     // Push a new element to the end
+    *     list.push(6);
+    *     console.log(list.length); // 6;
+    *     console.log([...list]); // [1, 2, 3, 4, 5, 6];
+      */
     push(elementOrNode) {
       const newNode = this._ensureNode(elementOrNode);
       if (!this.head) {
@@ -754,10 +781,36 @@ var queueTyped = (() => {
       return true;
     }
     /**
-     * Remove and return the tail element.
-     * @remarks Time O(N), Space O(1)
-     * @returns Removed element or undefined.
-     */
+      * Remove and return the tail element.
+      * @remarks Time O(N), Space O(1)
+      * @returns Removed element or undefined.
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+       * @example
+    * // SinglyLinkedList pop and shift operations
+    *  const list = new SinglyLinkedList<number>([10, 20, 30, 40, 50]);
+    *
+    *     // Pop removes from the end
+    *     const last = list.pop();
+    *     console.log(last); // 50;
+    *
+    *     // Shift removes from the beginning
+    *     const first = list.shift();
+    *     console.log(first); // 10;
+    *
+    *     // Verify remaining elements
+    *     console.log([...list]); // [20, 30, 40];
+    *     console.log(list.length); // 3;
+      */
     pop() {
       var _a;
       if (!this.head) return void 0;
@@ -777,10 +830,26 @@ var queueTyped = (() => {
       return value;
     }
     /**
-     * Remove and return the head element.
-     * @remarks Time O(1), Space O(1)
-     * @returns Removed element or undefined.
-     */
+      * Remove and return the head element.
+      * @remarks Time O(1), Space O(1)
+      * @returns Removed element or undefined.
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+       * @example
+    * // Remove from the front
+    *  const list = new SinglyLinkedList<number>([10, 20, 30]);
+    *     console.log(list.shift()); // 10;
+    *     console.log(list.length); // 2;
+      */
     shift() {
       if (!this.head) return void 0;
       const removed = this.head;
@@ -790,11 +859,42 @@ var queueTyped = (() => {
       return removed.value;
     }
     /**
-     * Prepend an element/node to the head.
-     * @remarks Time O(1), Space O(1)
-     * @param elementOrNode - Element or node to prepend.
-     * @returns True when prepended.
-     */
+      * Prepend an element/node to the head.
+      * @remarks Time O(1), Space O(1)
+      * @param elementOrNode - Element or node to prepend.
+      * @returns True when prepended.
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+       * @example
+    * // SinglyLinkedList unshift and forward traversal
+    *  const list = new SinglyLinkedList<number>([20, 30, 40]);
+    *
+    *     // Unshift adds to the beginning
+    *     list.unshift(10);
+    *     console.log([...list]); // [10, 20, 30, 40];
+    *
+    *     // Access elements (forward traversal only for singly linked)
+    *     const second = list.at(1);
+    *     console.log(second); // 20;
+    *
+    *     // SinglyLinkedList allows forward iteration only
+    *     const elements: number[] = [];
+    *     for (const item of list) {
+    *       elements.push(item);
+    *     }
+    *     console.log(elements); // [10, 20, 30, 40];
+    *
+    *     console.log(list.length); // 4;
+      */
     unshift(elementOrNode) {
       const newNode = this._ensureNode(elementOrNode);
       if (!this.head) {
@@ -850,11 +950,28 @@ var queueTyped = (() => {
       return void 0;
     }
     /**
-     * Get the element at a given index.
-     * @remarks Time O(N), Space O(1)
-     * @param index - Zero-based index.
-     * @returns Element or undefined.
-     */
+      * Get the element at a given index.
+      * @remarks Time O(N), Space O(1)
+      * @param index - Zero-based index.
+      * @returns Element or undefined.
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+       * @example
+    * // Access element by index
+    *  const list = new SinglyLinkedList<string>(['a', 'b', 'c', 'd']);
+    *     console.log(list.at(0)); // 'a';
+    *     console.log(list.at(2)); // 'c';
+    *     console.log(list.at(3)); // 'd';
+      */
     at(index) {
       if (index < 0 || index >= this._length) return void 0;
       let current = this.head;
@@ -871,11 +988,23 @@ var queueTyped = (() => {
       return elementNodeOrPredicate instanceof SinglyLinkedListNode;
     }
     /**
-     * Get the node reference at a given index.
-     * @remarks Time O(N), Space O(1)
-     * @param index - Zero-based index.
-     * @returns Node or undefined.
-     */
+      * Get the node reference at a given index.
+      * @remarks Time O(N), Space O(1)
+      * @param index - Zero-based index.
+      * @returns Node or undefined.
+      
+      
+      
+      
+      
+      
+      
+      
+       * @example
+    * // Get node at index
+    *  const list = new SinglyLinkedList<string>(['a', 'b', 'c']);
+    *     console.log(list.getNodeAt(1)?.value); // 'b';
+      */
     getNodeAt(index) {
       if (index < 0 || index >= this._length) return void 0;
       let current = this.head;
@@ -883,11 +1012,24 @@ var queueTyped = (() => {
       return current;
     }
     /**
-     * Delete the element at an index.
-     * @remarks Time O(N), Space O(1)
-     * @param index - Zero-based index.
-     * @returns Removed element or undefined.
-     */
+      * Delete the element at an index.
+      * @remarks Time O(N), Space O(1)
+      * @param index - Zero-based index.
+      * @returns Removed element or undefined.
+      
+      
+      
+      
+      
+      
+      
+      
+       * @example
+    * // Remove by index
+    *  const list = new SinglyLinkedList<string>(['a', 'b', 'c']);
+    *     list.deleteAt(1);
+    *     console.log(list.toArray()); // ['a', 'c'];
+      */
     deleteAt(index) {
       if (index < 0 || index >= this._length) return void 0;
       if (index === 0) return this.shift();
@@ -900,11 +1042,24 @@ var queueTyped = (() => {
       return value;
     }
     /**
-     * Delete the first match by value/node.
-     * @remarks Time O(N), Space O(1)
-     * @param [elementOrNode] - Element or node to remove; if omitted/undefined, nothing happens.
-     * @returns True if removed.
-     */
+      * Delete the first match by value/node.
+      * @remarks Time O(N), Space O(1)
+      * @param [elementOrNode] - Element or node to remove; if omitted/undefined, nothing happens.
+      * @returns True if removed.
+      
+      
+      
+      
+      
+      
+      
+      
+       * @example
+    * // Remove first occurrence
+    *  const list = new SinglyLinkedList<number>([1, 2, 3, 2]);
+    *     list.delete(2);
+    *     console.log(list.toArray()); // [1, 3, 2];
+      */
     delete(elementOrNode) {
       if (elementOrNode === void 0 || !this.head) return false;
       const node = this.isNode(elementOrNode) ? elementOrNode : this.getNode(elementOrNode);
@@ -921,12 +1076,25 @@ var queueTyped = (() => {
       return true;
     }
     /**
-     * Insert a new element/node at an index, shifting following nodes.
-     * @remarks Time O(N), Space O(1)
-     * @param index - Zero-based index.
-     * @param newElementOrNode - Element or node to insert.
-     * @returns True if inserted.
-     */
+      * Insert a new element/node at an index, shifting following nodes.
+      * @remarks Time O(N), Space O(1)
+      * @param index - Zero-based index.
+      * @param newElementOrNode - Element or node to insert.
+      * @returns True if inserted.
+      
+      
+      
+      
+      
+      
+      
+      
+       * @example
+    * // Insert at index
+    *  const list = new SinglyLinkedList<number>([1, 3]);
+    *     list.addAt(1, 2);
+    *     console.log(list.toArray()); // [1, 2, 3];
+      */
     addAt(index, newElementOrNode) {
       if (index < 0 || index > this._length) return false;
       if (index === 0) return this.unshift(newElementOrNode);
@@ -952,28 +1120,70 @@ var queueTyped = (() => {
       return true;
     }
     /**
-     * Check whether the list is empty.
-     * @remarks Time O(1), Space O(1)
-     * @returns True if length is 0.
-     */
+      * Check whether the list is empty.
+      * @remarks Time O(1), Space O(1)
+      * @returns True if length is 0.
+      
+      
+      
+      
+      
+      
+      
+      
+      
+       * @example
+    * // Check empty
+    *  console.log(new SinglyLinkedList().isEmpty()); // true;
+      */
     isEmpty() {
       return this._length === 0;
     }
     /**
-     * Remove all nodes and reset length.
-     * @remarks Time O(N), Space O(1)
-     * @returns void
-     */
+      * Remove all nodes and reset length.
+      * @remarks Time O(N), Space O(1)
+      * @returns void
+      
+      
+      
+      
+      
+      
+      
+      
+      
+       * @example
+    * // Remove all
+    *  const list = new SinglyLinkedList<number>([1, 2, 3]);
+    *     list.clear();
+    *     console.log(list.isEmpty()); // true;
+      */
     clear() {
       this._head = void 0;
       this._tail = void 0;
       this._length = 0;
     }
     /**
-     * Reverse the list in place.
-     * @remarks Time O(N), Space O(1)
-     * @returns This list.
-     */
+      * Reverse the list in place.
+      * @remarks Time O(N), Space O(1)
+      * @returns This list.
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+       * @example
+    * // Reverse the list in-place
+    *  const list = new SinglyLinkedList<number>([1, 2, 3, 4]);
+    *     list.reverse();
+    *     console.log([...list]); // [4, 3, 2, 1];
+      */
     reverse() {
       if (!this.head || this.head === this.tail) return this;
       let prev;
@@ -1148,22 +1358,64 @@ var queueTyped = (() => {
       return false;
     }
     /**
-     * Deep clone this list (values are copied by reference).
-     * @remarks Time O(N), Space O(N)
-     * @returns A new list with the same element sequence.
-     */
+      * Deep clone this list (values are copied by reference).
+      * @remarks Time O(N), Space O(N)
+      * @returns A new list with the same element sequence.
+      
+      
+      
+      
+      
+      
+      
+      
+      
+       * @example
+    * // Deep copy
+    *  const list = new SinglyLinkedList<number>([1, 2, 3]);
+    *     const copy = list.clone();
+    *     copy.pop();
+    *     console.log(list.length); // 3;
+    *     console.log(copy.length); // 2;
+      */
     clone() {
       const out = this._createInstance();
       for (const v of this) out.push(v);
       return out;
     }
     /**
-     * Filter values into a new list of the same class.
-     * @remarks Time O(N), Space O(N)
-     * @param callback - Predicate (value, index, list) → boolean to keep value.
-     * @param [thisArg] - Value for `this` inside the callback.
-     * @returns A new list with kept values.
-     */
+      * Filter values into a new list of the same class.
+      * @remarks Time O(N), Space O(N)
+      * @param callback - Predicate (value, index, list) → boolean to keep value.
+      * @param [thisArg] - Value for `this` inside the callback.
+      * @returns A new list with kept values.
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+       * @example
+    * // SinglyLinkedList filter and map operations
+    *  const list = new SinglyLinkedList<number>([1, 2, 3, 4, 5]);
+    *
+    *     // Filter even numbers
+    *     const filtered = list.filter(value => value % 2 === 0);
+    *     console.log(filtered.length); // 2;
+    *
+    *     // Map to double values
+    *     const doubled = list.map(value => value * 2);
+    *     console.log(doubled.length); // 5;
+    *
+    *     // Use reduce to sum
+    *     const sum = list.reduce((acc, value) => acc + value, 0);
+    *     console.log(sum); // 15;
+      */
     filter(callback, thisArg) {
       const out = this._createInstance();
       let index = 0;
@@ -1187,15 +1439,31 @@ var queueTyped = (() => {
       return out;
     }
     /**
-     * Map values into a new list (possibly different element type).
-     * @remarks Time O(N), Space O(N)
-     * @template EM
-     * @template RM
-     * @param callback - Mapping function (value, index, list) → newElement.
-     * @param [options] - Options for the output list (e.g., maxLen, toElementFn).
-     * @param [thisArg] - Value for `this` inside the callback.
-     * @returns A new SinglyLinkedList with mapped values.
-     */
+      * Map values into a new list (possibly different element type).
+      * @remarks Time O(N), Space O(N)
+      * @template EM
+      * @template RM
+      * @param callback - Mapping function (value, index, list) → newElement.
+      * @param [options] - Options for the output list (e.g., maxLen, toElementFn).
+      * @param [thisArg] - Value for `this` inside the callback.
+      * @returns A new SinglyLinkedList with mapped values.
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+       * @example
+    * // Transform elements
+    *  const list = new SinglyLinkedList<number>([1, 2, 3]);
+    *     const doubled = list.map(n => n * 2);
+    *     console.log([...doubled]); // [2, 4, 6];
+      */
     map(callback, options, thisArg) {
       const out = this._createLike([], { ...options != null ? options : {}, maxLen: this._maxLen });
       let index = 0;
@@ -1329,6 +1597,52 @@ var queueTyped = (() => {
     return (node) => equals(node.value, value);
   }
 
+  // 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/queue/queue.ts
   var Queue = class _Queue extends LinearBase {
     /**
@@ -1383,18 +1697,52 @@ var queueTyped = (() => {
       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;
     }
@@ -1417,19 +1765,69 @@ var queueTyped = (() => {
       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();
@@ -1450,10 +1848,35 @@ var queueTyped = (() => {
       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;
@@ -1462,11 +1885,24 @@ var queueTyped = (() => {
       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)) {
@@ -1477,11 +1913,24 @@ var queueTyped = (() => {
       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];
@@ -1533,19 +1982,48 @@ var queueTyped = (() => {
       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;
@@ -1571,10 +2049,26 @@ var queueTyped = (() => {
       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);
@@ -1582,12 +2076,26 @@ var queueTyped = (() => {
       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);
@@ -1599,15 +2107,28 @@ var queueTyped = (() => {
       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([], {
@@ -1709,24 +2230,25 @@ var queueTyped = (() => {
   };
 
   // src/utils/utils.ts
-  var rangeCheck = (index, min, max, message = "Index out of bounds.") => {
-    if (index < min || index > max) throw new RangeError(message);
+  var rangeCheck = (index, min, max, message) => {
+    if (index < min || index > max) {
+      throw new RangeError(message != null ? message : `Index ${index} is out of range [${min}, ${max}].`);
+    }
   };
   var calcMinUnitsRequired = (totalQuantity, unitSize) => Math.floor((totalQuantity + unitSize - 1) / unitSize);
 
   // src/data-structures/queue/deque.ts
   var Deque = class extends LinearBase {
-    /**
-     * Create a Deque and optionally bulk-insert elements.
-     * @remarks Time O(N), Space O(N)
-     * @param [elements] - Iterable (or iterable-like) of elements/records to insert.
-     * @param [options] - Options such as bucketSize, toElementFn, and maxLen.
-     * @returns New Deque instance.
-     */
     constructor(elements = [], options) {
       super(options);
       __publicField(this, "_equals", (a, b) => Object.is(a, b));
       __publicField(this, "_bucketSize", 1 << 12);
+      __publicField(this, "_autoCompactRatio", 0.5);
+      /**
+       * Counter for shift/pop operations since last compaction check.
+       * Only checks ratio every `_bucketSize` operations to minimize overhead.
+       */
+      __publicField(this, "_compactCounter", 0);
       __publicField(this, "_bucketFirst", 0);
       __publicField(this, "_firstInBucket", 0);
       __publicField(this, "_bucketLast", 0);
@@ -1735,8 +2257,9 @@ var queueTyped = (() => {
       __publicField(this, "_buckets", []);
       __publicField(this, "_length", 0);
       if (options) {
-        const { bucketSize } = options;
+        const { bucketSize, autoCompactRatio } = options;
         if (typeof bucketSize === "number") this._bucketSize = bucketSize;
+        if (typeof autoCompactRatio === "number") this._autoCompactRatio = autoCompactRatio;
       }
       let _size;
       if ("length" in elements) {
@@ -1761,6 +2284,24 @@ var queueTyped = (() => {
     get bucketSize() {
       return this._bucketSize;
     }
+    /**
+     * Get the auto-compaction ratio.
+     * When `elements / (bucketCount * bucketSize)` drops below this ratio after
+     * enough shift/pop operations, the deque auto-compacts.
+     * @remarks Time O(1), Space O(1)
+     * @returns Current ratio threshold. 0 means auto-compact is disabled.
+     */
+    get autoCompactRatio() {
+      return this._autoCompactRatio;
+    }
+    /**
+     * Set the auto-compaction ratio.
+     * @remarks Time O(1), Space O(1)
+     * @param value - Ratio in [0,1]. 0 disables auto-compact.
+     */
+    set autoCompactRatio(value) {
+      this._autoCompactRatio = value;
+    }
     /**
      * Get the index of the first bucket in use.
      * @remarks Time O(1), Space O(1)
@@ -1818,19 +2359,60 @@ var queueTyped = (() => {
       return this._length;
     }
     /**
-     * Get the first element without removing it.
-     * @remarks Time O(1), Space O(1)
-     * @returns First element or undefined.
-     */
+      * Get the first element without removing it.
+      * @remarks Time O(1), Space O(1)
+      * @returns First element or undefined.
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+       * @example
+    * // Deque peek at both ends
+    *  const deque = new Deque<number>([10, 20, 30, 40, 50]);
+    *
+    *     // Get first element without removing
+    *     const first = deque.at(0);
+    *     console.log(first); // 10;
+    *
+    *     // Get last element without removing
+    *     const last = deque.at(deque.length - 1);
+    *     console.log(last); // 50;
+    *
+    *     // Length unchanged
+    *     console.log(deque.length); // 5;
+      */
     get first() {
       if (this._length === 0) return;
       return this._buckets[this._bucketFirst][this._firstInBucket];
     }
     /**
-     * Get the last element without removing it.
-     * @remarks Time O(1), Space O(1)
-     * @returns Last element or undefined.
-     */
+      * Get the last element without removing it.
+      * @remarks Time O(1), Space O(1)
+      * @returns Last element or undefined.
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+       * @example
+    * // Peek at the back element
+    *  const dq = new Deque<string>(['a', 'b', 'c']);
+    *     console.log(dq.last); // 'c';
+    *     console.log(dq.first); // 'a';
+      */
     get last() {
       if (this._length === 0) return;
       return this._buckets[this._bucketLast][this._lastInBucket];
@@ -1849,11 +2431,40 @@ var queueTyped = (() => {
       return new this(data, options);
     }
     /**
-     * Append one element at the back.
-     * @remarks Time O(1) amortized, Space O(1)
-     * @param element - Element to append.
-     * @returns True when appended.
-     */
+      * Append one element at the back.
+      * @remarks Time O(1) amortized, Space O(1)
+      * @param element - Element to append.
+      * @returns True when appended.
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+       * @example
+    * // basic Deque creation and push/pop operations
+    *  // Create a simple Deque with initial values
+    *     const deque = new Deque([1, 2, 3, 4, 5]);
+    *
+    *     // Verify the deque maintains insertion order
+    *     console.log([...deque]); // [1, 2, 3, 4, 5];
+    *
+    *     // Check length
+    *     console.log(deque.length); // 5;
+    *
+    *     // Push to the end
+    *     deque.push(6);
+    *     console.log(deque.length); // 6;
+    *
+    *     // Pop from the end
+    *     const last = deque.pop();
+    *     console.log(last); // 6;
+      */
     push(element) {
       if (this._length) {
         if (this._lastInBucket < this._bucketSize - 1) {
@@ -1873,10 +2484,26 @@ var queueTyped = (() => {
       return true;
     }
     /**
-     * Remove and return the last element.
-     * @remarks Time O(1), Space O(1)
-     * @returns Removed element or undefined.
-     */
+      * Remove and return the last element.
+      * @remarks Time O(1), Space O(1)
+      * @returns Removed element or undefined.
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+       * @example
+    * // Remove from the back
+    *  const dq = new Deque<number>([1, 2, 3]);
+    *     console.log(dq.pop()); // 3;
+    *     console.log(dq.length); // 2;
+      */
     pop() {
       if (this._length === 0) return;
       const element = this._buckets[this._bucketLast][this._lastInBucket];
@@ -1892,13 +2519,30 @@ var queueTyped = (() => {
         }
       }
       this._length -= 1;
+      this._autoCompact();
       return element;
     }
     /**
-     * Remove and return the first element.
-     * @remarks Time O(1) amortized, Space O(1)
-     * @returns Removed element or undefined.
-     */
+      * Remove and return the first element.
+      * @remarks Time O(1) amortized, Space O(1)
+      * @returns Removed element or undefined.
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+       * @example
+    * // Remove from the front
+    *  const dq = new Deque<number>([1, 2, 3]);
+    *     console.log(dq.shift()); // 1;
+    *     console.log(dq.length); // 2;
+      */
     shift() {
       if (this._length === 0) return;
       const element = this._buckets[this._bucketFirst][this._firstInBucket];
@@ -1914,14 +2558,41 @@ var queueTyped = (() => {
         }
       }
       this._length -= 1;
+      this._autoCompact();
       return element;
     }
     /**
-     * Prepend one element at the front.
-     * @remarks Time O(1) amortized, Space O(1)
-     * @param element - Element to prepend.
-     * @returns True when prepended.
-     */
+      * Prepend one element at the front.
+      * @remarks Time O(1) amortized, Space O(1)
+      * @param element - Element to prepend.
+      * @returns True when prepended.
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+       * @example
+    * // Deque shift and unshift operations
+    *  const deque = new Deque<number>([20, 30, 40]);
+    *
+    *     // Unshift adds to the front
+    *     deque.unshift(10);
+    *     console.log([...deque]); // [10, 20, 30, 40];
+    *
+    *     // Shift removes from the front (O(1) complexity!)
+    *     const first = deque.shift();
+    *     console.log(first); // 10;
+    *
+    *     // Verify remaining elements
+    *     console.log([...deque]); // [20, 30, 40];
+    *     console.log(deque.length); // 3;
+      */
     unshift(element) {
       if (this._length) {
         if (this._firstInBucket > 0) {
@@ -1975,18 +2646,45 @@ var queueTyped = (() => {
       return ans;
     }
     /**
-     * Check whether the deque is empty.
-     * @remarks Time O(1), Space O(1)
-     * @returns True if length is 0.
-     */
+      * Check whether the deque is empty.
+      * @remarks Time O(1), Space O(1)
+      * @returns True if length is 0.
+      
+      
+      
+      
+      
+      
+      
+      
+      
+       * @example
+    * // Check if empty
+    *  const dq = new Deque();
+    *     console.log(dq.isEmpty()); // true;
+      */
     isEmpty() {
       return this._length === 0;
     }
     /**
-     * Remove all elements and reset structure.
-     * @remarks Time O(1), Space O(1)
-     * @returns void
-     */
+      * Remove all elements and reset structure.
+      * @remarks Time O(1), Space O(1)
+      * @returns void
+      
+      
+      
+      
+      
+      
+      
+      
+      
+       * @example
+    * // Remove all elements
+    *  const dq = new Deque<number>([1, 2, 3]);
+    *     dq.clear();
+    *     console.log(dq.length); // 0;
+      */
     clear() {
       this._buckets = [new Array(this._bucketSize)];
       this._bucketCount = 1;
@@ -1994,11 +2692,24 @@ var queueTyped = (() => {
       this._firstInBucket = this._lastInBucket = this._bucketSize >> 1;
     }
     /**
-     * Get the element at a given position.
-     * @remarks Time O(1), Space O(1)
-     * @param pos - Zero-based position from the front.
-     * @returns Element or undefined.
-     */
+      * Get the element at a given position.
+      * @remarks Time O(1), Space O(1)
+      * @param pos - Zero-based position from the front.
+      * @returns Element or undefined.
+      
+      
+      
+      
+      
+      
+      
+      
+       * @example
+    * // Access by index
+    *  const dq = new Deque<string>(['a', 'b', 'c']);
+    *     console.log(dq.at(0)); // 'a';
+    *     console.log(dq.at(2)); // 'c';
+      */
     at(pos) {
       if (pos < 0 || pos >= this._length) return void 0;
       const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
@@ -2157,11 +2868,24 @@ var queueTyped = (() => {
       }
     }
     /**
-     * Delete the first occurrence of a value.
-     * @remarks Time O(N), Space O(1)
-     * @param element - Element to remove (using the configured equality).
-     * @returns True if an element was removed.
-     */
+      * Delete the first occurrence of a value.
+      * @remarks Time O(N), Space O(1)
+      * @param element - Element to remove (using the configured equality).
+      * @returns True if an element was removed.
+      
+      
+      
+      
+      
+      
+      
+      
+       * @example
+    * // Remove element
+    *  const dq = new Deque<number>([1, 2, 3]);
+    *     dq.delete(2);
+    *     console.log(dq.length); // 2;
+      */
     delete(element) {
       const size = this._length;
       if (size === 0) return false;
@@ -2205,10 +2929,39 @@ var queueTyped = (() => {
       return this;
     }
     /**
-     * Reverse the deque by reversing buckets and pointers.
-     * @remarks Time O(N), Space O(N)
-     * @returns This deque.
-     */
+      * Reverse the deque by reversing buckets and pointers.
+      * @remarks Time O(N), Space O(N)
+      * @returns This deque.
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+       * @example
+    * // Deque for...of iteration and reverse
+    *  const deque = new Deque<string>(['A', 'B', 'C', 'D']);
+    *
+    *     // Iterate forward
+    *     const forward: string[] = [];
+    *     for (const item of deque) {
+    *       forward.push(item);
+    *     }
+    *     console.log(forward); // ['A', 'B', 'C', 'D'];
+    *
+    *     // Reverse the deque
+    *     deque.reverse();
+    *     const backward: string[] = [];
+    *     for (const item of deque) {
+    *       backward.push(item);
+    *     }
+    *     console.log(backward); // ['D', 'C', 'B', 'A'];
+      */
     reverse() {
       this._buckets.reverse().forEach(function(bucket) {
         bucket.reverse();
@@ -2246,11 +2999,55 @@ var queueTyped = (() => {
      * @remarks Time O(N), Space O(1)
      * @returns void
      */
+    /**
+     * (Protected) Trigger auto-compaction if space utilization drops below threshold.
+     * Only checks every `_bucketSize` operations to minimize hot-path overhead.
+     * Uses element-based ratio: `elements / (bucketCount * bucketSize)`.
+     */
+    _autoCompact() {
+      if (this._autoCompactRatio <= 0 || this._bucketCount <= 1) return;
+      this._compactCounter++;
+      if (this._compactCounter < this._bucketSize) return;
+      this._compactCounter = 0;
+      const utilization = this._length / (this._bucketCount * this._bucketSize);
+      if (utilization < this._autoCompactRatio) {
+        this.shrinkToFit();
+      }
+    }
+    /**
+     * Compact the deque by removing unused buckets.
+     * @remarks Time O(N), Space O(1)
+     * @returns True if compaction was performed (bucket count reduced).
+     */
+    /**
+      * Compact the deque by removing unused buckets.
+      * @remarks Time O(N), Space O(1)
+      * @returns True if compaction was performed (bucket count reduced).
+      
+      
+      
+      
+      
+      
+      
+      
+       * @example
+    * // Reclaim memory
+    *  const dq = new Deque<number>([1, 2, 3, 4, 5]);
+    *     dq.shift();
+    *     dq.shift();
+    *     dq.compact();
+    *     console.log(dq.length); // 3;
+      */
+    compact() {
+      const before = this._bucketCount;
+      this.shrinkToFit();
+      return this._bucketCount < before;
+    }
     shrinkToFit() {
       if (this._length === 0) return;
       const newBuckets = [];
-      if (this._bucketFirst === this._bucketLast) return;
-      else if (this._bucketFirst < this._bucketLast) {
+      if (this._bucketFirst <= this._bucketLast) {
         for (let i = this._bucketFirst; i <= this._bucketLast; ++i) {
           newBuckets.push(this._buckets[i]);
         }
@@ -2265,12 +3062,30 @@ var queueTyped = (() => {
       this._bucketFirst = 0;
       this._bucketLast = newBuckets.length - 1;
       this._buckets = newBuckets;
-    }
-    /**
-     * Deep clone this deque, preserving options.
-     * @remarks Time O(N), Space O(N)
-     * @returns A new deque with the same content and options.
-     */
+      this._bucketCount = newBuckets.length;
+      this._compactCounter = 0;
+    }
+    /**
+      * Deep clone this deque, preserving options.
+      * @remarks Time O(N), Space O(N)
+      * @returns A new deque with the same content and options.
+      
+      
+      
+      
+      
+      
+      
+      
+      
+       * @example
+    * // Create independent copy
+    *  const dq = new Deque<number>([1, 2, 3]);
+    *     const copy = dq.clone();
+    *     copy.pop();
+    *     console.log(dq.length); // 3;
+    *     console.log(copy.length); // 2;
+      */
     clone() {
       return this._createLike(this, {
         bucketSize: this.bucketSize,
@@ -2279,12 +3094,26 @@ var queueTyped = (() => {
       });
     }
     /**
-     * Filter elements into a new deque of the same class.
-     * @remarks Time O(N), Space O(N)
-     * @param predicate - Predicate (value, index, deque) → boolean to keep element.
-     * @param [thisArg] - Value for `this` inside the predicate.
-     * @returns A new deque with kept elements.
-     */
+      * Filter elements into a new deque of the same class.
+      * @remarks Time O(N), Space O(N)
+      * @param predicate - Predicate (value, index, deque) → boolean to keep element.
+      * @param [thisArg] - Value for `this` inside the predicate.
+      * @returns A new deque with kept elements.
+      
+      
+      
+      
+      
+      
+      
+      
+      
+       * @example
+    * // Filter elements
+    *  const dq = new Deque<number>([1, 2, 3, 4]);
+    *     const result = dq.filter(x => x > 2);
+    *     console.log(result.length); // 2;
+      */
     filter(predicate, thisArg) {
       const out = this._createInstance({ toElementFn: this.toElementFn, maxLen: this._maxLen });
       out._setBucketSize(this._bucketSize);
@@ -2313,15 +3142,28 @@ var queueTyped = (() => {
       return out;
     }
     /**
-     * Map elements into a new deque (possibly different element type).
-     * @remarks Time O(N), Space O(N)
-     * @template EM
-     * @template RM
-     * @param callback - Mapping function (value, index, deque) → newElement.
-     * @param [options] - Options for the output deque (e.g., bucketSize, toElementFn, maxLen).
-     * @param [thisArg] - Value for `this` inside the callback.
-     * @returns A new Deque with mapped elements.
-     */
+      * Map elements into a new deque (possibly different element type).
+      * @remarks Time O(N), Space O(N)
+      * @template EM
+      * @template RM
+      * @param callback - Mapping function (value, index, deque) → newElement.
+      * @param [options] - Options for the output deque (e.g., bucketSize, toElementFn, maxLen).
+      * @param [thisArg] - Value for `this` inside the callback.
+      * @returns A new Deque with mapped elements.
+      
+      
+      
+      
+      
+      
+      
+      
+       * @example
+    * // Transform elements
+    *  const dq = new Deque<number>([1, 2, 3]);
+    *     const result = dq.map(x => x * 10);
+    *     console.log(result.toArray()); // [10, 20, 30];
+      */
     map(callback, options, thisArg) {
       const out = this._createLike([], {
         ...options != null ? options : {},
@@ -2444,27 +3286,6 @@ var queueTyped = (() => {
       }
     }
   };
-
-  // 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);
 })();
 /**