stack-typed 2.4.5 → 2.5.1

package/dist/umd/stack-typed.js

@@ -29,52 +29,6 @@ var stackTyped = (() => {
     Stack: () => Stack
   });
 
-  // 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-element-base.ts
   var IterableElementBase = class {
     /**
@@ -97,7 +51,7 @@ var stackTyped = (() => {
       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");
       }
     }
     /**
@@ -253,7 +207,7 @@ var stackTyped = (() => {
         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;
       }
@@ -319,10 +273,44 @@ var stackTyped = (() => {
       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;
     }
@@ -340,36 +328,207 @@ var stackTyped = (() => {
       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();
     }
@@ -388,11 +547,45 @@ var stackTyped = (() => {
       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);
@@ -424,30 +617,137 @@ var stackTyped = (() => {
       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;
@@ -474,15 +774,49 @@ var stackTyped = (() => {
       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 != null ? options : {} });
       let index = 0;
@@ -544,6 +878,52 @@ var stackTyped = (() => {
       for (let i = 0; i < this.elements.length; i++) yield this.elements[i];
     }
   };
+
+  // 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;
+    }
+  };
   return __toCommonJS(src_exports);
 })();
 /**