deque-typed 2.4.4 → 2.5.0

package/dist/esm-legacy/index.mjs

@@ -4,8 +4,10 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
 // src/utils/utils.ts
-var rangeCheck = /* @__PURE__ */ __name((index, min, max, message = "Index out of bounds.") => {
-  if (index < min || index > max) throw new RangeError(message);
+var rangeCheck = /* @__PURE__ */ __name((index, min, max, message) => {
+  if (index < min || index > max) {
+    throw new RangeError(message != null ? message : `Index ${index} is out of range [${min}, ${max}].`);
+  }
 }, "rangeCheck");
 var calcMinUnitsRequired = /* @__PURE__ */ __name((totalQuantity, unitSize) => Math.floor((totalQuantity + unitSize - 1) / unitSize), "calcMinUnitsRequired");
 
@@ -425,17 +427,16 @@ var LinearBase = _LinearBase;
 
 // src/data-structures/queue/deque.ts
 var _Deque = class _Deque 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", /* @__PURE__ */ __name((a, b) => Object.is(a, b), "_equals"));
     __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);
@@ -444,8 +445,9 @@ var _Deque = class _Deque extends LinearBase {
     __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) {
@@ -470,6 +472,24 @@ var _Deque = class _Deque extends LinearBase {
   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)
@@ -527,19 +547,60 @@ var _Deque = class _Deque extends LinearBase {
     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];
@@ -558,11 +619,40 @@ var _Deque = class _Deque extends LinearBase {
     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) {
@@ -582,10 +672,26 @@ var _Deque = class _Deque extends LinearBase {
     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];
@@ -601,13 +707,30 @@ var _Deque = class _Deque extends LinearBase {
       }
     }
     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];
@@ -623,14 +746,41 @@ var _Deque = class _Deque extends LinearBase {
       }
     }
     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) {
@@ -684,18 +834,45 @@ var _Deque = class _Deque extends LinearBase {
     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;
@@ -703,11 +880,24 @@ var _Deque = class _Deque extends LinearBase {
     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);
@@ -866,11 +1056,24 @@ var _Deque = class _Deque extends LinearBase {
     }
   }
   /**
-   * 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;
@@ -914,10 +1117,39 @@ var _Deque = class _Deque extends LinearBase {
     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();
@@ -955,11 +1187,55 @@ var _Deque = class _Deque extends LinearBase {
    * @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]);
       }
@@ -974,12 +1250,30 @@ var _Deque = class _Deque extends LinearBase {
     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,
@@ -988,12 +1282,26 @@ var _Deque = class _Deque extends LinearBase {
     });
   }
   /**
-   * 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);
@@ -1022,15 +1330,28 @@ var _Deque = class _Deque extends LinearBase {
     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 : {},
@@ -1156,6 +1477,31 @@ var _Deque = class _Deque extends LinearBase {
 __name(_Deque, "Deque");
 var Deque = _Deque;
 
+// src/common/error.ts
+var ERR = {
+  // Range / index
+  indexOutOfRange: /* @__PURE__ */ __name((index, min, max, ctx) => `${ctx ? ctx + ": " : ""}Index ${index} is out of range [${min}, ${max}].`, "indexOutOfRange"),
+  invalidIndex: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Index must be an integer.`, "invalidIndex"),
+  // Type / argument
+  invalidArgument: /* @__PURE__ */ __name((reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`, "invalidArgument"),
+  comparatorRequired: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Comparator is required for non-number/non-string/non-Date keys.`, "comparatorRequired"),
+  invalidKey: /* @__PURE__ */ __name((reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`, "invalidKey"),
+  notAFunction: /* @__PURE__ */ __name((name, ctx) => `${ctx ? ctx + ": " : ""}${name} must be a function.`, "notAFunction"),
+  invalidEntry: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Each entry must be a [key, value] tuple.`, "invalidEntry"),
+  invalidNaN: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}NaN is not a valid key.`, "invalidNaN"),
+  invalidDate: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Invalid Date key.`, "invalidDate"),
+  reduceEmpty: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Reduce of empty structure with no initial value.`, "reduceEmpty"),
+  callbackReturnType: /* @__PURE__ */ __name((expected, got, ctx) => `${ctx ? ctx + ": " : ""}Callback must return ${expected}; got ${got}.`, "callbackReturnType"),
+  // State / operation
+  invalidOperation: /* @__PURE__ */ __name((reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`, "invalidOperation"),
+  // Matrix
+  matrixDimensionMismatch: /* @__PURE__ */ __name((op) => `Matrix: Dimensions must be compatible for ${op}.`, "matrixDimensionMismatch"),
+  matrixSingular: /* @__PURE__ */ __name(() => "Matrix: Singular matrix, inverse does not exist.", "matrixSingular"),
+  matrixNotSquare: /* @__PURE__ */ __name(() => "Matrix: Must be square for inversion.", "matrixNotSquare"),
+  matrixNotRectangular: /* @__PURE__ */ __name(() => "Matrix: Must be rectangular for transposition.", "matrixNotRectangular"),
+  matrixRowMismatch: /* @__PURE__ */ __name((expected, got) => `Matrix: Expected row length ${expected}, but got ${got}.`, "matrixRowMismatch")
+};
+
 // src/common/index.ts
 var DFSOperation = /* @__PURE__ */ ((DFSOperation2) => {
   DFSOperation2[DFSOperation2["VISIT"] = 0] = "VISIT";
@@ -1186,6 +1532,6 @@ var Range = _Range;
  * @license MIT License
  */
 
-export { DFSOperation, Deque, Range };
+export { DFSOperation, Deque, ERR, Range };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map