stack-typed 2.4.5 → 2.5.1

package/dist/esm/index.mjs

@@ -1,55 +1,6 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
-// 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";
-  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;
-  }
-  static {
-    __name(this, "Range");
-  }
-  // 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-element-base.ts
 var IterableElementBase = class {
   static {
@@ -68,7 +19,7 @@ var IterableElementBase = class {
     if (options) {
       const { toElementFn } = options;
       if (typeof toElementFn === "function") this._toElementFn = toElementFn;
-      else if (toElementFn) throw new TypeError(ERR.notAFunction("toElementFn"));
+      else if (toElementFn) throw new TypeError("toElementFn must be a function type");
     }
   }
   /**
@@ -231,7 +182,7 @@ var IterableElementBase = class {
       acc = initialValue;
     } else {
       const first = iter.next();
-      if (first.done) throw new TypeError(ERR.reduceEmpty());
+      if (first.done) throw new TypeError("Reduce of empty structure with no initial value");
       acc = first.value;
       index = 1;
     }
@@ -300,10 +251,44 @@ var Stack = class extends IterableElementBase {
     return this._elements;
   }
   /**
-   * Get the number of stored elements.
-   * @remarks Time O(1), Space O(1)
-   * @returns Current size.
-   */
+    * Get the number of stored elements.
+    * @remarks Time O(1), Space O(1)
+    * @returns Current size.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Get number of elements
+  *  const stack = new Stack<number>([1, 2, 3]);
+  *     console.log(stack.size); // 3;
+    */
   get size() {
     return this.elements.length;
   }
@@ -321,36 +306,207 @@ var Stack = class extends IterableElementBase {
     return new this(elements, options);
   }
   /**
-   * Check whether the stack is empty.
-   * @remarks Time O(1), Space O(1)
-   * @returns True if size is 0.
-   */
+    * Check whether the stack is empty.
+    * @remarks Time O(1), Space O(1)
+    * @returns True if size is 0.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Check if stack has elements
+  *  const stack = new Stack<number>();
+  *     console.log(stack.isEmpty()); // true;
+  *     stack.push(1);
+  *     console.log(stack.isEmpty()); // false;
+    */
   isEmpty() {
     return this.elements.length === 0;
   }
   /**
-   * Get the top element without removing it.
-   * @remarks Time O(1), Space O(1)
-   * @returns Top element or undefined.
-   */
+    * Get the top element without removing it.
+    * @remarks Time O(1), Space O(1)
+    * @returns Top element or undefined.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // View the top element without removing it
+  *  const stack = new Stack<string>(['a', 'b', 'c']);
+  *     console.log(stack.peek()); // 'c';
+  *     console.log(stack.size); // 3;
+    */
   peek() {
     return this.isEmpty() ? void 0 : this.elements[this.elements.length - 1];
   }
   /**
-   * Push one element onto the top.
-   * @remarks Time O(1), Space O(1)
-   * @param element - Element to push.
-   * @returns True when pushed.
-   */
+    * Push one element onto the top.
+    * @remarks Time O(1), Space O(1)
+    * @param element - Element to push.
+    * @returns True when pushed.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // basic Stack creation and push operation
+  *  // Create a simple Stack with initial values
+  *     const stack = new Stack([1, 2, 3, 4, 5]);
+  *
+  *     // Verify the stack maintains insertion order (LIFO will be shown in pop)
+  *     console.log([...stack]); // [1, 2, 3, 4, 5];
+  *
+  *     // Check length
+  *     console.log(stack.size); // 5;
+  *
+  *     // Push a new element to the top
+  *     stack.push(6);
+  *     console.log(stack.size); // 6;
+    */
   push(element) {
     this.elements.push(element);
     return true;
   }
   /**
-   * Pop and return the top element.
-   * @remarks Time O(1), Space O(1)
-   * @returns Removed element or undefined.
-   */
+    * Pop and return the top element.
+    * @remarks Time O(1), Space O(1)
+    * @returns Removed element or undefined.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Stack pop operation (LIFO - Last In First Out)
+  *  const stack = new Stack<number>([10, 20, 30, 40, 50]);
+  *
+  *     // Peek at the top element without removing
+  *     const top = stack.peek();
+  *     console.log(top); // 50;
+  *
+  *     // Pop removes from the top (LIFO order)
+  *     const popped = stack.pop();
+  *     console.log(popped); // 50;
+  *
+  *     // Next pop gets the previous element
+  *     const next = stack.pop();
+  *     console.log(next); // 40;
+  *
+  *     // Verify length decreased
+  *     console.log(stack.size); // 3;
+    */
   pop() {
     return this.isEmpty() ? void 0 : this.elements.pop();
   }
@@ -369,11 +525,45 @@ var Stack = class extends IterableElementBase {
     return ans;
   }
   /**
-   * Delete the first occurrence of a specific element.
-   * @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 specific element.
+    * @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 stack = new Stack<number>([1, 2, 3]);
+  *     stack.delete(2);
+  *     console.log(stack.toArray()); // [1, 3];
+    */
   delete(element) {
     const idx = this._indexOfByEquals(element);
     return this.deleteAt(idx);
@@ -405,30 +595,137 @@ var Stack = class extends IterableElementBase {
     return false;
   }
   /**
-   * Remove all elements and reset storage.
-   * @remarks Time O(1), Space O(1)
-   * @returns void
-   */
+    * Remove all elements and reset storage.
+    * @remarks Time O(1), Space O(1)
+    * @returns void
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Remove all elements
+  *  const stack = new Stack<number>([1, 2, 3]);
+  *     stack.clear();
+  *     console.log(stack.isEmpty()); // true;
+    */
   clear() {
     this._elements = [];
   }
   /**
-   * Deep clone this stack.
-   * @remarks Time O(N), Space O(N)
-   * @returns A new stack with the same content.
-   */
+    * Deep clone this stack.
+    * @remarks Time O(N), Space O(N)
+    * @returns A new stack with the same content.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Create independent copy
+  *  const stack = new Stack<number>([1, 2, 3]);
+  *     const copy = stack.clone();
+  *     copy.pop();
+  *     console.log(stack.size); // 3;
+  *     console.log(copy.size); // 2;
+    */
   clone() {
     const out = this._createInstance({ toElementFn: this.toElementFn });
     for (const v of this) out.push(v);
     return out;
   }
   /**
-   * Filter elements into a new stack of the same class.
-   * @remarks Time O(N), Space O(N)
-   * @param predicate - Predicate (value, index, stack) → boolean to keep value.
-   * @param [thisArg] - Value for `this` inside the predicate.
-   * @returns A new stack with kept values.
-   */
+    * Filter elements into a new stack of the same class.
+    * @remarks Time O(N), Space O(N)
+    * @param predicate - Predicate (value, index, stack) → boolean to keep value.
+    * @param [thisArg] - Value for `this` inside the predicate.
+    * @returns A new stack with kept values.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Filter elements
+  *  const stack = new Stack<number>([1, 2, 3, 4, 5]);
+  *     const evens = stack.filter(x => x % 2 === 0);
+  *     console.log(evens.toArray()); // [2, 4];
+    */
   filter(predicate, thisArg) {
     const out = this._createInstance({ toElementFn: this.toElementFn });
     let index = 0;
@@ -455,15 +752,49 @@ var Stack = class extends IterableElementBase {
     return out;
   }
   /**
-   * Map values into a new stack (possibly different element type).
-   * @remarks Time O(N), Space O(N)
-   * @template EM
-   * @template RM
-   * @param callback - Mapping function (value, index, stack) → newElement.
-   * @param [options] - Options for the output stack (e.g., toElementFn).
-   * @param [thisArg] - Value for `this` inside the callback.
-   * @returns A new Stack with mapped elements.
-   */
+    * Map values into a new stack (possibly different element type).
+    * @remarks Time O(N), Space O(N)
+    * @template EM
+    * @template RM
+    * @param callback - Mapping function (value, index, stack) → newElement.
+    * @param [options] - Options for the output stack (e.g., toElementFn).
+    * @param [thisArg] - Value for `this` inside the callback.
+    * @returns A new Stack with mapped elements.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Transform elements
+  *  const stack = new Stack<number>([1, 2, 3]);
+  *     const doubled = stack.map(x => x * 2);
+  *     console.log(doubled.toArray()); // [2, 4, 6];
+    */
   map(callback, options, thisArg) {
     const out = this._createLike([], { ...options ?? {} });
     let index = 0;
@@ -525,6 +856,55 @@ var Stack = class extends IterableElementBase {
     for (let i = 0; i < this.elements.length; i++) yield this.elements[i];
   }
 };
+
+// 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";
+  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;
+  }
+  static {
+    __name(this, "Range");
+  }
+  // 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;
+  }
+};
 /**
  * data-structure-typed
  *