stack-typed 2.1.1 → 2.1.2

package/dist/umd/stack-typed.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/index.ts","../../src/data-structures/base/iterable-element-base.ts","../../src/data-structures/stack/stack.ts","../../src/utils/utils.ts","../../src/common/index.ts"],"sourcesContent":["/**\n * data-structure-typed\n *\n * @author Pablo Zeng\n * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>\n * @license MIT License\n */\nexport * from './data-structures/stack';\nexport * from './types/data-structures/stack';\nexport * from './types/common';\nexport * from './types/utils';\nexport * from './common';","import type { ElementCallback, IterableElementBaseOptions, ReduceElementCallback } from '../../types';\n\n/**\n * Base class that makes a data structure iterable and provides common\n * element-wise utilities (e.g., map/filter/reduce/find).\n *\n * @template E The public element type yielded by the structure.\n * @template R The underlying \"raw\" element type used internally or by converters.\n *\n * @remarks\n * This class implements the JavaScript iteration protocol (via `Symbol.iterator`)\n * and offers array-like helpers with predictable time/space complexity.\n */\nexport abstract class IterableElementBase<E, R> implements Iterable<E> {\n  /**\n   * Create a new iterable base.\n   *\n   * @param options Optional behavior overrides. When provided, a `toElementFn`\n   * is used to convert a raw element (`R`) into a public element (`E`).\n   *\n   * @remarks\n   * Time O(1), Space O(1).\n   */\n  protected constructor(options?: IterableElementBaseOptions<E, R>) {\n    if (options) {\n      const { toElementFn } = options;\n      if (typeof toElementFn === 'function') this._toElementFn = toElementFn;\n      else if (toElementFn) throw new TypeError('toElementFn must be a function type');\n    }\n  }\n\n  /**\n   * The converter used to transform a raw element (`R`) into a public element (`E`).\n   *\n   * @remarks\n   * Time O(1), Space O(1).\n   */\n  protected _toElementFn?: (rawElement: R) => E;\n\n  /**\n   * Exposes the current `toElementFn`, if configured.\n   *\n   * @returns The converter function or `undefined` when not set.\n   * @remarks\n   * Time O(1), Space O(1).\n   */\n  get toElementFn(): ((rawElement: R) => E) | undefined {\n    return this._toElementFn;\n  }\n\n  /**\n   * Returns an iterator over the structure's elements.\n   *\n   * @param args Optional iterator arguments forwarded to the internal iterator.\n   * @returns An `IterableIterator<E>` that yields the elements in traversal order.\n   *\n   * @remarks\n   * Producing the iterator is O(1); consuming the entire iterator is Time O(n) with O(1) extra space.\n   */\n  *[Symbol.iterator](...args: unknown[]): IterableIterator<E> {\n    yield* this._getIterator(...args);\n  }\n\n  /**\n   * Returns an iterator over the values (alias of the default iterator).\n   *\n   * @returns An `IterableIterator<E>` over all elements.\n   * @remarks\n   * Creating the iterator is O(1); full iteration is Time O(n), Space O(1).\n   */\n  *values(): IterableIterator<E> {\n    for (const item of this) yield item;\n  }\n\n  /**\n   * Tests whether all elements satisfy the predicate.\n   *\n   * @template TReturn\n   * @param predicate Function invoked for each element with signature `(value, index, self)`.\n   * @param thisArg Optional `this` binding for the predicate.\n   * @returns `true` if every element passes; otherwise `false`.\n   *\n   * @remarks\n   * Time O(n) in the worst case; may exit early when the first failure is found. Space O(1).\n   */\n  every(predicate: ElementCallback<E, R, boolean>, thisArg?: unknown): boolean {\n    let index = 0;\n    for (const item of this) {\n      if (thisArg === undefined) {\n        if (!predicate(item, index++, this)) return false;\n      } else {\n        const fn = predicate as (this: unknown, v: E, i: number, self: this) => boolean;\n        if (!fn.call(thisArg, item, index++, this)) return false;\n      }\n    }\n    return true;\n  }\n\n  /**\n   * Tests whether at least one element satisfies the predicate.\n   *\n   * @param predicate Function invoked for each element with signature `(value, index, self)`.\n   * @param thisArg Optional `this` binding for the predicate.\n   * @returns `true` if any element passes; otherwise `false`.\n   *\n   * @remarks\n   * Time O(n) in the worst case; may exit early on first success. Space O(1).\n   */\n  some(predicate: ElementCallback<E, R, boolean>, thisArg?: unknown): boolean {\n    let index = 0;\n    for (const item of this) {\n      if (thisArg === undefined) {\n        if (predicate(item, index++, this)) return true;\n      } else {\n        const fn = predicate as (this: unknown, v: E, i: number, self: this) => boolean;\n        if (fn.call(thisArg, item, index++, this)) return true;\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Invokes a callback for each element in iteration order.\n   *\n   * @param callbackfn Function invoked per element with signature `(value, index, self)`.\n   * @param thisArg Optional `this` binding for the callback.\n   * @returns `void`.\n   *\n   * @remarks\n   * Time O(n), Space O(1).\n   */\n  forEach(callbackfn: ElementCallback<E, R, void>, thisArg?: unknown): void {\n    let index = 0;\n    for (const item of this) {\n      if (thisArg === undefined) {\n        callbackfn(item, index++, this);\n      } else {\n        const fn = callbackfn as (this: unknown, v: E, i: number, self: this) => void;\n        fn.call(thisArg, item, index++, this);\n      }\n    }\n  }\n\n  /**\n   * Finds the first element that satisfies the predicate and returns it.\n   *\n   * @overload\n   * Finds the first element of type `S` (a subtype of `E`) that satisfies the predicate and returns it.\n   * @template S\n   * @param predicate Type-guard predicate: `(value, index, self) => value is S`.\n   * @param thisArg Optional `this` binding for the predicate.\n   * @returns The matched element typed as `S`, or `undefined` if not found.\n   *\n   * @overload\n   * @param predicate Boolean predicate: `(value, index, self) => boolean`.\n   * @param thisArg Optional `this` binding for the predicate.\n   * @returns The first matching element as `E`, or `undefined` if not found.\n   *\n   * @remarks\n   * Time O(n) in the worst case; may exit early on the first match. Space O(1).\n   */\n  find<S extends E>(predicate: ElementCallback<E, R, S>, thisArg?: unknown): S | undefined;\n  find(predicate: ElementCallback<E, R, unknown>, thisArg?: unknown): E | undefined;\n\n  // Implementation signature\n  find(predicate: ElementCallback<E, R, boolean>, thisArg?: unknown): E | undefined {\n    let index = 0;\n    for (const item of this) {\n      if (thisArg === undefined) {\n        if (predicate(item, index++, this)) return item;\n      } else {\n        const fn = predicate as (this: unknown, v: E, i: number, self: this) => boolean;\n        if (fn.call(thisArg, item, index++, this)) return item;\n      }\n    }\n    return;\n  }\n\n  /**\n   * Checks whether a strictly-equal element exists in the structure.\n   *\n   * @param element The element to test with `===` equality.\n   * @returns `true` if an equal element is found; otherwise `false`.\n   *\n   * @remarks\n   * Time O(n) in the worst case. Space O(1).\n   */\n  has(element: E): boolean {\n    for (const ele of this) if (ele === element) return true;\n    return false;\n  }\n\n  reduce(callbackfn: ReduceElementCallback<E, R>): E;\n  reduce(callbackfn: ReduceElementCallback<E, R>, initialValue: E): E;\n  reduce<U>(callbackfn: ReduceElementCallback<E, R, U>, initialValue: U): U;\n\n  /**\n   * Reduces all elements to a single accumulated value.\n   *\n   * @overload\n   * @param callbackfn Reducer of signature `(acc, value, index, self) => nextAcc`. The first element is used as the initial accumulator.\n   * @returns The final accumulated value typed as `E`.\n   *\n   * @overload\n   * @param callbackfn Reducer of signature `(acc, value, index, self) => nextAcc`.\n   * @param initialValue The initial accumulator value of type `E`.\n   * @returns The final accumulated value typed as `E`.\n   *\n   * @overload\n   * @template U The accumulator type when it differs from `E`.\n   * @param callbackfn Reducer of signature `(acc: U, value, index, self) => U`.\n   * @param initialValue The initial accumulator value of type `U`.\n   * @returns The final accumulated value typed as `U`.\n   *\n   * @remarks\n   * Time O(n), Space O(1). Throws if called on an empty structure without `initialValue`.\n   */\n  reduce<U>(callbackfn: ReduceElementCallback<E, R, U>, initialValue?: U): U {\n    let index = 0;\n    const iter = this[Symbol.iterator]();\n    let acc: U;\n\n    if (arguments.length >= 2) {\n      acc = initialValue as U;\n    } else {\n      const first = iter.next();\n      if (first.done) throw new TypeError('Reduce of empty structure with no initial value');\n      acc = first.value as unknown as U;\n      index = 1;\n    }\n\n    for (const value of iter as unknown as Iterable<E>) {\n      acc = callbackfn(acc, value, index++, this);\n    }\n    return acc;\n  }\n\n  /**\n   * Materializes the elements into a new array.\n   *\n   * @returns A shallow array copy of the iteration order.\n   * @remarks\n   * Time O(n), Space O(n).\n   */\n  toArray(): E[] {\n    return [...this];\n  }\n\n  /**\n   * Returns a representation of the structure suitable for quick visualization.\n   * Defaults to an array of elements; subclasses may override to provide richer visuals.\n   *\n   * @returns A visual representation (array by default).\n   * @remarks\n   * Time O(n), Space O(n).\n   */\n  toVisual(): E[] {\n    return [...this];\n  }\n\n  /**\n   * Prints `toVisual()` to the console. Intended for quick debugging.\n   *\n   * @returns `void`.\n   * @remarks\n   * Time O(n) due to materialization, Space O(n) for the intermediate representation.\n   */\n  print(): void {\n    console.log(this.toVisual());\n  }\n\n  /**\n   * Indicates whether the structure currently contains no elements.\n   *\n   * @returns `true` if empty; otherwise `false`.\n   * @remarks\n   * Expected Time O(1), Space O(1) for most implementations.\n   */\n  abstract isEmpty(): boolean;\n\n  /**\n   * Removes all elements from the structure.\n   *\n   * @returns `void`.\n   * @remarks\n   * Expected Time O(1) or O(n) depending on the implementation; Space O(1).\n   */\n  abstract clear(): void;\n\n  /**\n   * Creates a structural copy with the same element values and configuration.\n   *\n   * @returns A clone of the current instance (same concrete type).\n   * @remarks\n   * Expected Time O(n) to copy elements; Space O(n).\n   */\n  abstract clone(): this;\n\n  /**\n   * Maps each element to a new element and returns a new iterable structure.\n   *\n   * @template EM The mapped element type.\n   * @template RM The mapped raw element type used internally by the target structure.\n   * @param callback Function with signature `(value, index, self) => mapped`.\n   * @param options Optional options for the returned structure, including its `toElementFn`.\n   * @param thisArg Optional `this` binding for the callback.\n   * @returns A new `IterableElementBase<EM, RM>` containing mapped elements.\n   *\n   * @remarks\n   * Time O(n), Space O(n).\n   */\n  abstract map<EM, RM>(\n    callback: ElementCallback<E, R, EM>,\n    options?: IterableElementBaseOptions<EM, RM>,\n    thisArg?: unknown\n  ): IterableElementBase<EM, RM>;\n\n  /**\n   * Maps each element to the same element type and returns the same concrete structure type.\n   *\n   * @param callback Function with signature `(value, index, self) => mappedValue`.\n   * @param thisArg Optional `this` binding for the callback.\n   * @returns A new instance of the same concrete type with mapped elements.\n   *\n   * @remarks\n   * Time O(n), Space O(n).\n   */\n  abstract mapSame(callback: ElementCallback<E, R, E>, thisArg?: unknown): this;\n\n  /**\n   * Filters elements using the provided predicate and returns the same concrete structure type.\n   *\n   * @param predicate Function with signature `(value, index, self) => boolean`.\n   * @param thisArg Optional `this` binding for the predicate.\n   * @returns A new instance of the same concrete type containing only elements that pass the predicate.\n   *\n   * @remarks\n   * Time O(n), Space O(k) where `k` is the number of kept elements.\n   */\n  abstract filter(predicate: ElementCallback<E, R, boolean>, thisArg?: unknown): this;\n\n  /**\n   * Internal iterator factory used by the default iterator.\n   *\n   * @param args Optional iterator arguments.\n   * @returns An iterator over elements.\n   *\n   * @remarks\n   * Implementations should yield in O(1) per element with O(1) extra space when possible.\n   */\n  protected abstract _getIterator(...args: unknown[]): IterableIterator<E>;\n}\n","/**\n * data-structure-typed\n *\n * @author Pablo Zeng\n * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>\n * @license MIT License\n */\n\nimport type { ElementCallback, IterableElementBaseOptions, StackOptions } from '../../types';\nimport { IterableElementBase } from '../base';\n\n/**\n * LIFO stack with array storage and optional record→element conversion.\n * @remarks Time O(1), Space O(1)\n * @template E\n * @template R\n * 1. Last In, First Out (LIFO): The core characteristic of a stack is its last in, first out nature, meaning the last element added to the stack will be the first to be removed.\n * 2. Uses: Stacks are commonly used for managing a series of tasks or elements that need to be processed in a last in, first out manner. They are widely used in various scenarios, such as in function calls in programming languages, evaluation of arithmetic expressions, and backtracking algorithms.\n * 3. Performance: Stack operations are typically O(1) in time complexity, meaning that regardless of the stack's size, adding, removing, and viewing the top element are very fast operations.\n * 4. Function Calls: In most modern programming languages, the records of function calls are managed through a stack. When a function is called, its record (including parameters, local variables, and return address) is 'pushed' into the stack. When the function returns, its record is 'popped' from the stack.\n * 5. Expression Evaluation: Used for the evaluation of arithmetic or logical expressions, especially when dealing with parenthesis matching and operator precedence.\n * 6. Backtracking Algorithms: In problems where multiple branches need to be explored but only one branch can be explored at a time, stacks can be used to save the state at each branching point.\n * @example\n * // Balanced Parentheses or Brackets\n *     type ValidCharacters = ')' | '(' | ']' | '[' | '}' | '{';\n *\n *     const stack = new Stack<string>();\n *     const input: ValidCharacters[] = '[({})]'.split('') as ValidCharacters[];\n *     const matches: { [key in ValidCharacters]?: ValidCharacters } = { ')': '(', ']': '[', '}': '{' };\n *     for (const char of input) {\n *       if ('([{'.includes(char)) {\n *         stack.push(char);\n *       } else if (')]}'.includes(char)) {\n *         if (stack.pop() !== matches[char]) {\n *           fail('Parentheses are not balanced');\n *         }\n *       }\n *     }\n *     console.log(stack.isEmpty()); // true\n * @example\n * // Expression Evaluation and Conversion\n *     const stack = new Stack<number>();\n *     const expression = [5, 3, '+']; // Equivalent to 5 + 3\n *     expression.forEach(token => {\n *       if (typeof token === 'number') {\n *         stack.push(token);\n *       } else {\n *         const b = stack.pop()!;\n *         const a = stack.pop()!;\n *         stack.push(token === '+' ? a + b : 0); // Only handling '+' here\n *       }\n *     });\n *     console.log(stack.pop()); // 8\n * @example\n * // Depth-First Search (DFS)\n *     const stack = new Stack<number>();\n *     const graph: { [key in number]: number[] } = { 1: [2, 3], 2: [4], 3: [5], 4: [], 5: [] };\n *     const visited: number[] = [];\n *     stack.push(1);\n *     while (!stack.isEmpty()) {\n *       const node = stack.pop()!;\n *       if (!visited.includes(node)) {\n *         visited.push(node);\n *         graph[node].forEach(neighbor => stack.push(neighbor));\n *       }\n *     }\n *     console.log(visited); // [1, 3, 5, 2, 4]\n * @example\n * // Backtracking Algorithms\n *     const stack = new Stack<[number, number]>();\n *     const maze = [\n *       ['S', ' ', 'X'],\n *       ['X', ' ', 'X'],\n *       [' ', ' ', 'E']\n *     ];\n *     const start: [number, number] = [0, 0];\n *     const end = [2, 2];\n *     const directions = [\n *       [0, 1], // To the right\n *       [1, 0], // down\n *       [0, -1], // left\n *       [-1, 0] // up\n *     ];\n *\n *     const visited = new Set<string>(); // Used to record visited nodes\n *     stack.push(start);\n *     const path: number[][] = [];\n *\n *     while (!stack.isEmpty()) {\n *       const [x, y] = stack.pop()!;\n *       if (visited.has(`${x},${y}`)) continue; // Skip already visited nodes\n *       visited.add(`${x},${y}`);\n *\n *       path.push([x, y]);\n *\n *       if (x === end[0] && y === end[1]) {\n *         break; // Find the end point and exit\n *       }\n *\n *       for (const [dx, dy] of directions) {\n *         const nx = x + dx;\n *         const ny = y + dy;\n *         if (\n *           maze[nx]?.[ny] === ' ' || // feasible path\n *           maze[nx]?.[ny] === 'E' // destination\n *         ) {\n *           stack.push([nx, ny]);\n *         }\n *       }\n *     }\n *\n *     expect(path).toContainEqual(end);\n * @example\n * // Function Call Stack\n *     const functionStack = new Stack<string>();\n *     functionStack.push('main');\n *     functionStack.push('foo');\n *     functionStack.push('bar');\n *     console.log(functionStack.pop()); // 'bar'\n *     console.log(functionStack.pop()); // 'foo'\n *     console.log(functionStack.pop()); // 'main'\n * @example\n * // Simplify File Paths\n *     const stack = new Stack<string>();\n *     const path = '/a/./b/../../c';\n *     path.split('/').forEach(segment => {\n *       if (segment === '..') stack.pop();\n *       else if (segment && segment !== '.') stack.push(segment);\n *     });\n *     console.log(stack.elements.join('/')); // 'c'\n * @example\n * // Stock Span Problem\n *     const stack = new Stack<number>();\n *     const prices = [100, 80, 60, 70, 60, 75, 85];\n *     const spans: number[] = [];\n *     prices.forEach((price, i) => {\n *       while (!stack.isEmpty() && prices[stack.peek()!] <= price) {\n *         stack.pop();\n *       }\n *       spans.push(stack.isEmpty() ? i + 1 : i - stack.peek()!);\n *       stack.push(i);\n *     });\n *     console.log(spans); // [1, 1, 1, 2, 1, 4, 6]\n */\nexport class Stack<E = any, R = any> extends IterableElementBase<E, R> {\n  protected _equals: (a: E, b: E) => boolean = Object.is as unknown as (a: E, b: E) => boolean;\n\n  /**\n   * Create a Stack and optionally bulk-push elements.\n   * @remarks Time O(N), Space O(N)\n   * @param [elements] - Iterable of elements (or raw records if toElementFn is set).\n   * @param [options] - Options such as toElementFn and equality function.\n   * @returns New Stack instance.\n   */\n\n  constructor(elements: Iterable<E> | Iterable<R> = [], options?: StackOptions<E, R>) {\n    super(options);\n    this.pushMany(elements);\n  }\n\n  protected _elements: E[] = [];\n\n  /**\n   * Get the backing array of elements.\n   * @remarks Time O(1), Space O(1)\n   * @returns Internal elements array.\n   */\n\n  get elements(): E[] {\n    return this._elements;\n  }\n\n  /**\n   * Get the number of stored elements.\n   * @remarks Time O(1), Space O(1)\n   * @returns Current size.\n   */\n\n  get size(): number {\n    return this.elements.length;\n  }\n\n  /**\n   * Create a stack from an array of elements.\n   * @remarks Time O(N), Space O(N)\n   * @template E\n   * @template R\n   * @param this - The constructor (subclass) to instantiate.\n   * @param elements - Array of elements to push in order.\n   * @param [options] - Options forwarded to the constructor.\n   * @returns A new Stack populated from the array.\n   */\n\n  static fromArray<E, R = any>(\n    this: new (elements?: Iterable<E> | Iterable<R>, options?: StackOptions<E, R>) => any,\n    elements: E[],\n    options?: StackOptions<E, R>\n  ) {\n    return new this(elements, options);\n  }\n\n  /**\n   * Check whether the stack is empty.\n   * @remarks Time O(1), Space O(1)\n   * @returns True if size is 0.\n   */\n\n  isEmpty(): boolean {\n    return this.elements.length === 0;\n  }\n\n  /**\n   * Get the top element without removing it.\n   * @remarks Time O(1), Space O(1)\n   * @returns Top element or undefined.\n   */\n\n  peek(): E | undefined {\n    return this.isEmpty() ? undefined : this.elements[this.elements.length - 1];\n  }\n\n  /**\n   * Push one element onto the top.\n   * @remarks Time O(1), Space O(1)\n   * @param element - Element to push.\n   * @returns True when pushed.\n   */\n\n  push(element: E): boolean {\n    this.elements.push(element);\n    return true;\n  }\n\n  /**\n   * Pop and return the top element.\n   * @remarks Time O(1), Space O(1)\n   * @returns Removed element or undefined.\n   */\n\n  pop(): E | undefined {\n    return this.isEmpty() ? undefined : this.elements.pop();\n  }\n\n  /**\n   * Push many elements from an iterable.\n   * @remarks Time O(N), Space O(1)\n   * @param elements - Iterable of elements (or raw records if toElementFn is set).\n   * @returns Array of per-element success flags.\n   */\n\n  pushMany(elements: Iterable<E> | Iterable<R>): boolean[] {\n    const ans: boolean[] = [];\n    for (const el of elements) {\n      if (this.toElementFn) ans.push(this.push(this.toElementFn(el as R)));\n      else ans.push(this.push(el as E));\n    }\n    return ans;\n  }\n\n  /**\n   * Delete the first occurrence of a specific element.\n   * @remarks Time O(N), Space O(1)\n   * @param element - Element to remove (using the configured equality).\n   * @returns True if an element was removed.\n   */\n\n  delete(element: E): boolean {\n    const idx = this._indexOfByEquals(element);\n    return this.deleteAt(idx);\n  }\n\n  /**\n   * Delete the element at an index.\n   * @remarks Time O(N), Space O(1)\n   * @param index - Zero-based index from the bottom.\n   * @returns True if removed.\n   */\n\n  deleteAt(index: number): boolean {\n    if (index < 0 || index >= this.elements.length) return false;\n    const spliced = this.elements.splice(index, 1);\n    return spliced.length === 1;\n  }\n\n  /**\n   * Delete the first element that satisfies a predicate.\n   * @remarks Time O(N), Space O(1)\n   * @param predicate - Function (value, index, stack) → boolean to decide deletion.\n   * @returns True if a match was removed.\n   */\n\n  deleteWhere(predicate: (value: E, index: number, stack: this) => boolean): boolean {\n    for (let i = 0; i < this.elements.length; i++) {\n      if (predicate(this.elements[i], i, this)) {\n        this.elements.splice(i, 1);\n        return true;\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Remove all elements and reset storage.\n   * @remarks Time O(1), Space O(1)\n   * @returns void\n   */\n\n  clear(): void {\n    this._elements = [];\n  }\n\n  /**\n   * Deep clone this stack.\n   * @remarks Time O(N), Space O(N)\n   * @returns A new stack with the same content.\n   */\n\n  clone(): this {\n    const out = this._createInstance({ toElementFn: this.toElementFn });\n    for (const v of this) out.push(v);\n    return out;\n  }\n\n  /**\n   * Filter elements into a new stack of the same class.\n   * @remarks Time O(N), Space O(N)\n   * @param predicate - Predicate (value, index, stack) → boolean to keep value.\n   * @param [thisArg] - Value for `this` inside the predicate.\n   * @returns A new stack with kept values.\n   */\n\n  filter(predicate: ElementCallback<E, R, boolean>, thisArg?: unknown): this {\n    const out = this._createInstance({ toElementFn: this.toElementFn });\n    let index = 0;\n    for (const v of this) {\n      if (predicate.call(thisArg, v, index, this)) out.push(v);\n      index++;\n    }\n    return out;\n  }\n\n  /**\n   * Map values into a new stack of the same element type.\n   * @remarks Time O(N), Space O(N)\n   * @param callback - Mapping function (value, index, stack) → newValue.\n   * @param [thisArg] - Value for `this` inside the callback.\n   * @returns A new stack with mapped values.\n   */\n\n  mapSame(callback: ElementCallback<E, R, E>, thisArg?: unknown): this {\n    const out = this._createInstance({ toElementFn: this.toElementFn });\n    let index = 0;\n    for (const v of this) {\n      const mv = thisArg === undefined ? callback(v, index++, this) : callback.call(thisArg, v, index++, this);\n      out.push(mv);\n    }\n    return out;\n  }\n\n  /**\n   * Map values into a new stack (possibly different element type).\n   * @remarks Time O(N), Space O(N)\n   * @template EM\n   * @template RM\n   * @param callback - Mapping function (value, index, stack) → newElement.\n   * @param [options] - Options for the output stack (e.g., toElementFn).\n   * @param [thisArg] - Value for `this` inside the callback.\n   * @returns A new Stack with mapped elements.\n   */\n\n  map<EM, RM>(\n    callback: ElementCallback<E, R, EM>,\n    options?: IterableElementBaseOptions<EM, RM>,\n    thisArg?: unknown\n  ): Stack<EM, RM> {\n    const out = this._createLike<EM, RM>([], { ...(options ?? {}) });\n    let index = 0;\n    for (const v of this) {\n      out.push(thisArg === undefined ? callback(v, index, this) : callback.call(thisArg, v, index, this));\n      index++;\n    }\n    return out;\n  }\n\n  /**\n   * Set the equality comparator used by delete/search operations.\n   * @remarks Time O(1), Space O(1)\n   * @param equals - Equality predicate (a, b) → boolean.\n   * @returns This stack.\n   */\n\n  setEquality(equals: (a: E, b: E) => boolean): this {\n    this._equals = equals;\n    return this;\n  }\n\n  /**\n   * (Protected) Find the index of a target element using the equality function.\n   * @remarks Time O(N), Space O(1)\n   * @param target - Element to search for.\n   * @returns Index or -1 if not found.\n   */\n\n  protected _indexOfByEquals(target: E): number {\n    for (let i = 0; i < this.elements.length; i++) if (this._equals(this.elements[i], target)) return i;\n    return -1;\n  }\n\n  /**\n   * (Protected) Create an empty instance of the same concrete class.\n   * @remarks Time O(1), Space O(1)\n   * @param [options] - Options forwarded to the constructor.\n   * @returns An empty like-kind stack instance.\n   */\n\n  protected _createInstance(options?: StackOptions<E, R>): this {\n    const Ctor = this.constructor as new (elements?: Iterable<E> | Iterable<R>, options?: StackOptions<E, R>) => this;\n    return new Ctor([], options);\n  }\n\n  /**\n   * (Protected) Create a like-kind stack and seed it from an iterable.\n   * @remarks Time O(N), Space O(N)\n   * @template T\n   * @template RR\n   * @param [elements] - Iterable used to seed the new stack.\n   * @param [options] - Options forwarded to the constructor.\n   * @returns A like-kind Stack instance.\n   */\n\n  protected _createLike<T = E, RR = R>(\n    elements: Iterable<T> | Iterable<RR> = [],\n    options?: StackOptions<T, RR>\n  ): Stack<T, RR> {\n    const Ctor = this.constructor as new (\n      elements?: Iterable<T> | Iterable<RR>,\n      options?: StackOptions<T, RR>\n    ) => Stack<T, RR>;\n    return new Ctor(elements, options);\n  }\n\n  /**\n   * (Protected) Iterate elements from bottom to top.\n   * @remarks Time O(N), Space O(1)\n   * @returns Iterator of elements.\n   */\n\n  protected *_getIterator(): IterableIterator<E> {\n    for (let i = 0; i < this.elements.length; i++) yield this.elements[i];\n  }\n}\n","/**\n * data-structure-typed\n *\n * @author Pablo Zeng\n * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>\n * @license MIT License\n */\nimport type { Comparable, ComparablePrimitive, Trampoline, TrampolineThunk } from '../types';\n\n/**\n * The function generates a random UUID (Universally Unique Identifier) in TypeScript.\n * @returns A randomly generated UUID (Universally Unique Identifier) in the format\n * 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx' where each 'x' is replaced with a random hexadecimal\n * character.\n */\nexport const uuidV4 = function () {\n  return 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'.replace(/[x]/g, function (c) {\n    const r = (Math.random() * 16) | 0,\n      v = c == 'x' ? r : (r & 0x3) | 0x8;\n    return v.toString(16);\n  });\n};\n\n/**\n * The `arrayRemove` function removes elements from an array based on a specified predicate function\n * and returns the removed elements.\n * @param {T[]} array - An array of elements that you want to filter based on the provided predicate\n * function.\n * @param predicate - The `predicate` parameter is a function that takes three arguments:\n * @returns The `arrayRemove` function returns an array containing the elements that satisfy the given\n * `predicate` function.\n */\nexport const arrayRemove = function <T>(array: T[], predicate: (item: T, index: number, array: T[]) => boolean): T[] {\n  let i = -1,\n    len = array ? array.length : 0;\n  const result = [];\n\n  while (++i < len) {\n    const value = array[i];\n    if (predicate(value, i, array)) {\n      result.push(value);\n      Array.prototype.splice.call(array, i--, 1);\n      len--;\n    }\n  }\n\n  return result;\n};\n\n/**\n * The function `getMSB` returns the most significant bit of a given number.\n * @param {number} value - The `value` parameter is a number for which we want to find the position of\n * the Most Significant Bit (MSB). The function `getMSB` takes this number as input and calculates the\n * position of the MSB in its binary representation.\n * @returns The function `getMSB` returns the most significant bit (MSB) of the input `value`. If the\n * input value is less than or equal to 0, it returns 0. Otherwise, it calculates the position of the\n * MSB using the `Math.clz32` function and bitwise left shifts 1 to that position.\n */\nexport const getMSB = (value: number): number => {\n  if (value <= 0) {\n    return 0;\n  }\n  return 1 << (31 - Math.clz32(value));\n};\n\n/**\n * The `rangeCheck` function in TypeScript is used to validate if an index is within a specified range\n * and throws a `RangeError` with a custom message if it is out of bounds.\n * @param {number} index - The `index` parameter represents the value that you want to check if it\n * falls within a specified range.\n * @param {number} min - The `min` parameter represents the minimum value that the `index` should be\n * compared against in the `rangeCheck` function.\n * @param {number} max - The `max` parameter in the `rangeCheck` function represents the maximum value\n * that the `index` parameter is allowed to have. If the `index` is greater than this `max` value, a\n * `RangeError` will be thrown.\n * @param [message=Index out of bounds.] - The `message` parameter is a string that represents the\n * error message to be thrown if the index is out of bounds. By default, if no message is provided when\n * calling the `rangeCheck` function, the message \"Index out of bounds.\" will be used.\n */\nexport const rangeCheck = (index: number, min: number, max: number, message = 'Index out of bounds.'): void => {\n  if (index < min || index > max) throw new RangeError(message);\n};\n\n/**\n * The function `throwRangeError` throws a RangeError with a custom message if called.\n * @param [message=The value is off-limits.] - The `message` parameter is a string that represents the\n * error message to be displayed when a `RangeError` is thrown. If no message is provided, the default\n * message is 'The value is off-limits.'.\n */\nexport const throwRangeError = (message = 'The value is off-limits.'): void => {\n  throw new RangeError(message);\n};\n\n/**\n * The function `isWeakKey` checks if the input is an object or a function in TypeScript.\n * @param {unknown} input - The `input` parameter in the `isWeakKey` function is of type `unknown`,\n * which means it can be any type. The function checks if the `input` is an object (excluding `null`)\n * or a function, and returns a boolean indicating whether the `input` is a weak\n * @returns The function `isWeakKey` returns a boolean value indicating whether the input is an object\n * or a function.\n */\nexport const isWeakKey = (input: unknown): input is object => {\n  const inputType = typeof input;\n  return (inputType === 'object' && input !== null) || inputType === 'function';\n};\n\n/**\n * The function `calcMinUnitsRequired` calculates the minimum number of units required to accommodate a\n * given total quantity based on a specified unit size.\n * @param {number} totalQuantity - The `totalQuantity` parameter represents the total quantity of items\n * that need to be processed or handled.\n * @param {number} unitSize - The `unitSize` parameter represents the size of each unit or package. It\n * is used in the `calcMinUnitsRequired` function to calculate the minimum number of units required to\n * accommodate a total quantity of items.\n */\nexport const calcMinUnitsRequired = (totalQuantity: number, unitSize: number) =>\n  Math.floor((totalQuantity + unitSize - 1) / unitSize);\n\n/**\n * The `roundFixed` function in TypeScript rounds a number to a specified number of decimal places.\n * @param {number} num - The `num` parameter is a number that you want to round to a certain number of\n * decimal places.\n * @param {number} [digit=10] - The `digit` parameter in the `roundFixed` function specifies the number\n * of decimal places to round the number to. By default, it is set to 10 if not provided explicitly.\n * @returns The function `roundFixed` returns a number that is rounded to the specified number of\n * decimal places (default is 10 decimal places).\n */\nexport const roundFixed = (num: number, digit: number = 10) => {\n  const multiplier = Math.pow(10, digit);\n  return Math.round(num * multiplier) / multiplier;\n};\n\n/**\n * The function `isPrimitiveComparable` checks if a value is a primitive type that can be compared.\n * @param {unknown} value - The `value` parameter in the `isPrimitiveComparable` function is of type\n * `unknown`, which means it can be any type. The function checks if the `value` is a primitive type\n * that can be compared, such as number, bigint, string, or boolean.\n * @returns The function `isPrimitiveComparable` returns a boolean value indicating whether the input\n * `value` is a primitive value that can be compared using standard comparison operators (<, >, <=,\n * >=).\n */\nfunction isPrimitiveComparable(value: unknown): value is ComparablePrimitive {\n  const valueType = typeof value;\n  if (valueType === 'number') return true;\n  // if (valueType === 'number') return !Number.isNaN(value);\n  return valueType === 'bigint' || valueType === 'string' || valueType === 'boolean';\n}\n\n/**\n * The function `tryObjectToPrimitive` attempts to convert an object to a comparable primitive value by\n * first checking the `valueOf` method and then the `toString` method.\n * @param {object} obj - The `obj` parameter in the `tryObjectToPrimitive` function is an object that\n * you want to convert to a primitive value. The function attempts to convert the object to a primitive\n * value by first checking if the object has a `valueOf` method. If the `valueOf` method exists, it\n * @returns The function `tryObjectToPrimitive` returns a value of type `ComparablePrimitive` if a\n * primitive comparable value is found within the object, or a string value if the object has a custom\n * `toString` method that does not return `'[object Object]'`. If neither condition is met, the\n * function returns `null`.\n */\nfunction tryObjectToPrimitive(obj: object): ComparablePrimitive | null {\n  if (typeof obj.valueOf === 'function') {\n    const valueOfResult = obj.valueOf();\n    if (valueOfResult !== obj) {\n      if (isPrimitiveComparable(valueOfResult)) return valueOfResult;\n      if (typeof valueOfResult === 'object' && valueOfResult !== null) return tryObjectToPrimitive(valueOfResult);\n    }\n  }\n  if (typeof obj.toString === 'function') {\n    const stringResult = obj.toString();\n    if (stringResult !== '[object Object]') return stringResult;\n  }\n  return null;\n}\n\n/**\n * The function `isComparable` in TypeScript checks if a value is comparable, handling primitive values\n * and objects with optional force comparison.\n * @param {unknown} value - The `value` parameter in the `isComparable` function represents the value\n * that you want to check if it is comparable. It can be of any type (`unknown`), and the function will\n * determine if it is comparable based on certain conditions.\n * @param [isForceObjectComparable=false] - The `isForceObjectComparable` parameter in the\n * `isComparable` function is a boolean flag that determines whether to treat non-primitive values as\n * comparable objects. When set to `true`, it forces the function to consider non-primitive values as\n * comparable objects, regardless of their type.\n * @returns The function `isComparable` returns a boolean value indicating whether the `value` is\n * considered comparable or not.\n */\nexport function isComparable(value: unknown, isForceObjectComparable = false): value is Comparable {\n  if (value === null || value === undefined) return false;\n  if (isPrimitiveComparable(value)) return true;\n\n  if (typeof value !== 'object') return false;\n  if (value instanceof Date) return true;\n  // if (value instanceof Date) return !Number.isNaN(value.getTime());\n  if (isForceObjectComparable) return true;\n  const comparableValue = tryObjectToPrimitive(value);\n  if (comparableValue === null || comparableValue === undefined) return false;\n  return isPrimitiveComparable(comparableValue);\n}\n\n/**\n * Creates a trampoline thunk object.\n *\n * A \"thunk\" is a deferred computation — instead of performing a recursive call immediately,\n * it wraps the next step of the computation in a function. This allows recursive processes\n * to be executed iteratively, preventing stack overflows.\n *\n * @template T - The type of the final computation result.\n * @param computation - A function that, when executed, returns the next trampoline step.\n * @returns A TrampolineThunk object containing the deferred computation.\n */\nexport const makeTrampolineThunk = <T>(computation: () => Trampoline<T>): TrampolineThunk<T> => ({\n  isThunk: true, // Marker indicating this is a thunk\n  fn: computation // The deferred computation function\n});\n\n/**\n * Type guard to check whether a given value is a TrampolineThunk.\n *\n * This function is used to distinguish between a final computation result (value)\n * and a deferred computation (thunk).\n *\n * @template T - The type of the value being checked.\n * @param value - The value to test.\n * @returns True if the value is a valid TrampolineThunk, false otherwise.\n */\nexport const isTrampolineThunk = <T>(value: Trampoline<T>): value is TrampolineThunk<T> =>\n  typeof value === 'object' && // Must be an object\n  value !== null && // Must not be null\n  'isThunk' in value && // Must have the 'isThunk' property\n  value.isThunk; // The flag must be true\n\n/**\n * Executes a trampoline computation until a final (non-thunk) result is obtained.\n *\n * The trampoline function repeatedly invokes the deferred computations (thunks)\n * in an iterative loop. This avoids deep recursive calls and prevents stack overflow,\n * which is particularly useful for implementing recursion in a stack-safe manner.\n *\n * @template T - The type of the final result.\n * @param initial - The initial Trampoline value or thunk to start execution from.\n * @returns The final result of the computation (a non-thunk value).\n */\nexport function trampoline<T>(initial: Trampoline<T>): T {\n  let current = initial; // Start with the initial trampoline value\n  while (isTrampolineThunk(current)) {\n    // Keep unwrapping while we have thunks\n    current = current.fn(); // Execute the deferred function to get the next step\n  }\n  return current; // Once no thunks remain, return the final result\n}\n\n/**\n * Wraps a recursive function inside a trampoline executor.\n *\n * This function transforms a potentially recursive function (that returns a Trampoline<Result>)\n * into a *stack-safe* function that executes iteratively using the `trampoline` runner.\n *\n * In other words, it allows you to write functions that look recursive,\n * but actually run in constant stack space.\n *\n * @template Args - The tuple type representing the argument list of the original function.\n * @template Result - The final return type after all trampoline steps are resolved.\n *\n * @param fn - A function that performs a single step of computation\n *             and returns a Trampoline (either a final value or a deferred thunk).\n *\n * @returns A new function with the same arguments, but which automatically\n *          runs the trampoline process and returns the *final result* instead\n *          of a Trampoline.\n *\n * @example\n * // Example: Computing factorial in a stack-safe way\n * const factorial = makeTrampoline(function fact(n: number, acc: number = 1): Trampoline<number> {\n *   return n === 0\n *     ? acc\n *     : makeTrampolineThunk(() => fact(n - 1, acc * n));\n * });\n *\n * console.log(factorial(100000)); // Works without stack overflow\n */\nexport function makeTrampoline<Args extends any[], Result>(\n  fn: (...args: Args) => Trampoline<Result> // A function that returns a trampoline step\n): (...args: Args) => Result {\n  // Return a wrapped function that automatically runs the trampoline execution loop\n  return (...args: Args) => trampoline(fn(...args));\n}\n\n/**\n * Executes an asynchronous trampoline computation until a final (non-thunk) result is obtained.\n *\n * This function repeatedly invokes asynchronous deferred computations (thunks)\n * in an iterative loop. Each thunk may return either a Trampoline<T> or a Promise<Trampoline<T>>.\n *\n * It ensures that asynchronous recursive functions can run without growing the call stack,\n * making it suitable for stack-safe async recursion.\n *\n * @template T - The type of the final result.\n * @param initial - The initial Trampoline or Promise of Trampoline to start execution from.\n * @returns A Promise that resolves to the final result (a non-thunk value).\n */\nexport async function asyncTrampoline<T>(initial: Trampoline<T> | Promise<Trampoline<T>>): Promise<T> {\n  let current = await initial; // Wait for the initial step to resolve if it's a Promise\n\n  // Keep executing thunks until we reach a non-thunk (final) value\n  while (isTrampolineThunk(current)) {\n    current = await current.fn(); // Execute the thunk function (may be async)\n  }\n\n  // Once the final value is reached, return it\n  return current;\n}\n\n/**\n * Wraps an asynchronous recursive function inside an async trampoline executor.\n *\n * This helper transforms a recursive async function that returns a Trampoline<Result>\n * (or Promise<Trampoline<Result>>) into a *stack-safe* async function that executes\n * iteratively via the `asyncTrampoline` runner.\n *\n * @template Args - The tuple type representing the argument list of the original function.\n * @template Result - The final return type after all async trampoline steps are resolved.\n *\n * @param fn - An async or sync function that performs a single step of computation\n *             and returns a Trampoline (either a final value or a deferred thunk).\n *\n * @returns An async function with the same arguments, but which automatically\n *          runs the trampoline process and resolves to the *final result*.\n *\n * @example\n * // Example: Async factorial using trampoline\n * const asyncFactorial = makeAsyncTrampoline(async function fact(\n *   n: number,\n *   acc: number = 1\n * ): Promise<Trampoline<number>> {\n *   return n === 0\n *     ? acc\n *     : makeTrampolineThunk(() => fact(n - 1, acc * n));\n * });\n *\n * asyncFactorial(100000).then(console.log); // Works without stack overflow\n */\nexport function makeAsyncTrampoline<Args extends any[], Result>(\n  fn: (...args: Args) => Trampoline<Result> | Promise<Trampoline<Result>>\n): (...args: Args) => Promise<Result> {\n  // Return a wrapped async function that runs through the async trampoline loop\n  return async (...args: Args): Promise<Result> => {\n    return asyncTrampoline(fn(...args));\n  };\n}\n","import { isComparable } from '../utils';\n\nexport enum DFSOperation {\n  VISIT = 0,\n  PROCESS = 1\n}\n\nexport class Range<K> {\n  constructor(\n    public low: K,\n    public high: K,\n    public includeLow: boolean = true,\n    public includeHigh: boolean = true\n  ) {\n    if (!(isComparable(low) && isComparable(high))) throw new RangeError('low or high is not comparable');\n    if (low > high) throw new RangeError('low must be less than or equal to high');\n  }\n\n  // Determine whether a key is within the range\n  isInRange(key: K, comparator: (a: K, b: K) => number): boolean {\n    const lowCheck = this.includeLow ? comparator(key, this.low) >= 0 : comparator(key, this.low) > 0;\n    const highCheck = this.includeHigh ? comparator(key, this.high) <= 0 : comparator(key, this.high) < 0;\n    return lowCheck && highCheck;\n  }\n}\n"],"mappings":"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","names":["DFSOperation"]}

package/dist/umd/stack-typed.min.js

@@ -0,0 +1,9 @@
+"use strict";var stackTyped=(()=>{var u=Object.defineProperty;var d=Object.getOwnPropertyDescriptor;var R=Object.getOwnPropertyNames;var x=Object.prototype.hasOwnProperty;var k=(o,t,e)=>t in o?u(o,t,{enumerable:!0,configurable:!0,writable:!0,value:e}):o[t]=e;var w=(o,t)=>{for(var e in t)u(o,e,{get:t[e],enumerable:!0})},T=(o,t,e,n)=>{if(t&&typeof t=="object"||typeof t=="function")for(let r of R(t))!x.call(o,r)&&r!==e&&u(o,r,{get:()=>t[r],enumerable:!(n=d(t,r))||n.enumerable});return o};var g=o=>T(u({},"__esModule",{value:!0}),o);var i=(o,t,e)=>k(o,typeof t!="symbol"?t+"":t,e);var y={};w(y,{DFSOperation:()=>b,Range:()=>E,Stack:()=>m});var c=class{constructor(t){i(this,"_toElementFn");if(t){let{toElementFn:e}=t;if(typeof e=="function")this._toElementFn=e;else if(e)throw new TypeError("toElementFn must be a function type")}}get toElementFn(){return this._toElementFn}*[Symbol.iterator](...t){yield*this._getIterator(...t)}*values(){for(let t of this)yield t}every(t,e){let n=0;for(let r of this)if(e===void 0){if(!t(r,n++,this))return!1}else if(!t.call(e,r,n++,this))return!1;return!0}some(t,e){let n=0;for(let r of this)if(e===void 0){if(t(r,n++,this))return!0}else if(t.call(e,r,n++,this))return!0;return!1}forEach(t,e){let n=0;for(let r of this)e===void 0?t(r,n++,this):t.call(e,r,n++,this)}find(t,e){let n=0;for(let r of this)if(e===void 0){if(t(r,n++,this))return r}else if(t.call(e,r,n++,this))return r}has(t){for(let e of this)if(e===t)return!0;return!1}reduce(t,e){let n=0,r=this[Symbol.iterator](),s;if(arguments.length>=2)s=e;else{let l=r.next();if(l.done)throw new TypeError("Reduce of empty structure with no initial value");s=l.value,n=1}for(let l of r)s=t(s,l,n++,this);return s}toArray(){return[...this]}toVisual(){return[...this]}print(){console.log(this.toVisual())}};var m=class extends c{constructor(e=[],n){super(n);i(this,"_equals",Object.is);i(this,"_elements",[]);this.pushMany(e)}get elements(){return this._elements}get size(){return this.elements.length}static fromArray(e,n){return new this(e,n)}isEmpty(){return this.elements.length===0}peek(){return this.isEmpty()?void 0:this.elements[this.elements.length-1]}push(e){return this.elements.push(e),!0}pop(){return this.isEmpty()?void 0:this.elements.pop()}pushMany(e){let n=[];for(let r of e)this.toElementFn?n.push(this.push(this.toElementFn(r))):n.push(this.push(r));return n}delete(e){let n=this._indexOfByEquals(e);return this.deleteAt(n)}deleteAt(e){return e<0||e>=this.elements.length?!1:this.elements.splice(e,1).length===1}deleteWhere(e){for(let n=0;n<this.elements.length;n++)if(e(this.elements[n],n,this))return this.elements.splice(n,1),!0;return!1}clear(){this._elements=[]}clone(){let e=this._createInstance({toElementFn:this.toElementFn});for(let n of this)e.push(n);return e}filter(e,n){let r=this._createInstance({toElementFn:this.toElementFn}),s=0;for(let l of this)e.call(n,l,s,this)&&r.push(l),s++;return r}mapSame(e,n){let r=this._createInstance({toElementFn:this.toElementFn}),s=0;for(let l of this){let a=n===void 0?e(l,s++,this):e.call(n,l,s++,this);r.push(a)}return r}map(e,n,r){let s=this._createLike([],{...n!=null?n:{}}),l=0;for(let a of this)s.push(r===void 0?e(a,l,this):e.call(r,a,l,this)),l++;return s}setEquality(e){return this._equals=e,this}_indexOfByEquals(e){for(let n=0;n<this.elements.length;n++)if(this._equals(this.elements[n],e))return n;return-1}_createInstance(e){let n=this.constructor;return new n([],e)}_createLike(e=[],n){let r=this.constructor;return new r(e,n)}*_getIterator(){for(let e=0;e<this.elements.length;e++)yield this.elements[e]}};function f(o){let t=typeof o;return t==="number"?!0:t==="bigint"||t==="string"||t==="boolean"}function p(o){if(typeof o.valueOf=="function"){let t=o.valueOf();if(t!==o){if(f(t))return t;if(typeof t=="object"&&t!==null)return p(t)}}if(typeof o.toString=="function"){let t=o.toString();if(t!=="[object Object]")return t}return null}function h(o,t=!1){if(o==null)return!1;if(f(o))return!0;if(typeof o!="object")return!1;if(o instanceof Date||t)return!0;let e=p(o);return e==null?!1:f(e)}var b=(e=>(e[e.VISIT=0]="VISIT",e[e.PROCESS=1]="PROCESS",e))(b||{}),E=class{constructor(t,e,n=!0,r=!0){this.low=t;this.high=e;this.includeLow=n;this.includeHigh=r;if(!(h(t)&&h(e)))throw new RangeError("low or high is not comparable");if(t>e)throw new RangeError("low must be less than or equal to high")}isInRange(t,e){let n=this.includeLow?e(t,this.low)>=0:e(t,this.low)>0,r=this.includeHigh?e(t,this.high)<=0:e(t,this.high)<0;return n&&r}};return g(y);})();
+/**
+ * data-structure-typed
+ *
+ * @author Pablo Zeng
+ * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+//# sourceMappingURL=stack-typed.min.js.map

package/dist/umd/stack-typed.min.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/index.ts","../../src/data-structures/base/iterable-element-base.ts","../../src/data-structures/stack/stack.ts","../../src/utils/utils.ts","../../src/common/index.ts"],"sourcesContent":["/**\n * data-structure-typed\n *\n * @author Pablo Zeng\n * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>\n * @license MIT License\n */\nexport * from './data-structures/stack';\nexport * from './types/data-structures/stack';\nexport * from './types/common';\nexport * from './types/utils';\nexport * from './common';","import type { ElementCallback, IterableElementBaseOptions, ReduceElementCallback } from '../../types';\n\n/**\n * Base class that makes a data structure iterable and provides common\n * element-wise utilities (e.g., map/filter/reduce/find).\n *\n * @template E The public element type yielded by the structure.\n * @template R The underlying \"raw\" element type used internally or by converters.\n *\n * @remarks\n * This class implements the JavaScript iteration protocol (via `Symbol.iterator`)\n * and offers array-like helpers with predictable time/space complexity.\n */\nexport abstract class IterableElementBase<E, R> implements Iterable<E> {\n  /**\n   * Create a new iterable base.\n   *\n   * @param options Optional behavior overrides. When provided, a `toElementFn`\n   * is used to convert a raw element (`R`) into a public element (`E`).\n   *\n   * @remarks\n   * Time O(1), Space O(1).\n   */\n  protected constructor(options?: IterableElementBaseOptions<E, R>) {\n    if (options) {\n      const { toElementFn } = options;\n      if (typeof toElementFn === 'function') this._toElementFn = toElementFn;\n      else if (toElementFn) throw new TypeError('toElementFn must be a function type');\n    }\n  }\n\n  /**\n   * The converter used to transform a raw element (`R`) into a public element (`E`).\n   *\n   * @remarks\n   * Time O(1), Space O(1).\n   */\n  protected _toElementFn?: (rawElement: R) => E;\n\n  /**\n   * Exposes the current `toElementFn`, if configured.\n   *\n   * @returns The converter function or `undefined` when not set.\n   * @remarks\n   * Time O(1), Space O(1).\n   */\n  get toElementFn(): ((rawElement: R) => E) | undefined {\n    return this._toElementFn;\n  }\n\n  /**\n   * Returns an iterator over the structure's elements.\n   *\n   * @param args Optional iterator arguments forwarded to the internal iterator.\n   * @returns An `IterableIterator<E>` that yields the elements in traversal order.\n   *\n   * @remarks\n   * Producing the iterator is O(1); consuming the entire iterator is Time O(n) with O(1) extra space.\n   */\n  *[Symbol.iterator](...args: unknown[]): IterableIterator<E> {\n    yield* this._getIterator(...args);\n  }\n\n  /**\n   * Returns an iterator over the values (alias of the default iterator).\n   *\n   * @returns An `IterableIterator<E>` over all elements.\n   * @remarks\n   * Creating the iterator is O(1); full iteration is Time O(n), Space O(1).\n   */\n  *values(): IterableIterator<E> {\n    for (const item of this) yield item;\n  }\n\n  /**\n   * Tests whether all elements satisfy the predicate.\n   *\n   * @template TReturn\n   * @param predicate Function invoked for each element with signature `(value, index, self)`.\n   * @param thisArg Optional `this` binding for the predicate.\n   * @returns `true` if every element passes; otherwise `false`.\n   *\n   * @remarks\n   * Time O(n) in the worst case; may exit early when the first failure is found. Space O(1).\n   */\n  every(predicate: ElementCallback<E, R, boolean>, thisArg?: unknown): boolean {\n    let index = 0;\n    for (const item of this) {\n      if (thisArg === undefined) {\n        if (!predicate(item, index++, this)) return false;\n      } else {\n        const fn = predicate as (this: unknown, v: E, i: number, self: this) => boolean;\n        if (!fn.call(thisArg, item, index++, this)) return false;\n      }\n    }\n    return true;\n  }\n\n  /**\n   * Tests whether at least one element satisfies the predicate.\n   *\n   * @param predicate Function invoked for each element with signature `(value, index, self)`.\n   * @param thisArg Optional `this` binding for the predicate.\n   * @returns `true` if any element passes; otherwise `false`.\n   *\n   * @remarks\n   * Time O(n) in the worst case; may exit early on first success. Space O(1).\n   */\n  some(predicate: ElementCallback<E, R, boolean>, thisArg?: unknown): boolean {\n    let index = 0;\n    for (const item of this) {\n      if (thisArg === undefined) {\n        if (predicate(item, index++, this)) return true;\n      } else {\n        const fn = predicate as (this: unknown, v: E, i: number, self: this) => boolean;\n        if (fn.call(thisArg, item, index++, this)) return true;\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Invokes a callback for each element in iteration order.\n   *\n   * @param callbackfn Function invoked per element with signature `(value, index, self)`.\n   * @param thisArg Optional `this` binding for the callback.\n   * @returns `void`.\n   *\n   * @remarks\n   * Time O(n), Space O(1).\n   */\n  forEach(callbackfn: ElementCallback<E, R, void>, thisArg?: unknown): void {\n    let index = 0;\n    for (const item of this) {\n      if (thisArg === undefined) {\n        callbackfn(item, index++, this);\n      } else {\n        const fn = callbackfn as (this: unknown, v: E, i: number, self: this) => void;\n        fn.call(thisArg, item, index++, this);\n      }\n    }\n  }\n\n  /**\n   * Finds the first element that satisfies the predicate and returns it.\n   *\n   * @overload\n   * Finds the first element of type `S` (a subtype of `E`) that satisfies the predicate and returns it.\n   * @template S\n   * @param predicate Type-guard predicate: `(value, index, self) => value is S`.\n   * @param thisArg Optional `this` binding for the predicate.\n   * @returns The matched element typed as `S`, or `undefined` if not found.\n   *\n   * @overload\n   * @param predicate Boolean predicate: `(value, index, self) => boolean`.\n   * @param thisArg Optional `this` binding for the predicate.\n   * @returns The first matching element as `E`, or `undefined` if not found.\n   *\n   * @remarks\n   * Time O(n) in the worst case; may exit early on the first match. Space O(1).\n   */\n  find<S extends E>(predicate: ElementCallback<E, R, S>, thisArg?: unknown): S | undefined;\n  find(predicate: ElementCallback<E, R, unknown>, thisArg?: unknown): E | undefined;\n\n  // Implementation signature\n  find(predicate: ElementCallback<E, R, boolean>, thisArg?: unknown): E | undefined {\n    let index = 0;\n    for (const item of this) {\n      if (thisArg === undefined) {\n        if (predicate(item, index++, this)) return item;\n      } else {\n        const fn = predicate as (this: unknown, v: E, i: number, self: this) => boolean;\n        if (fn.call(thisArg, item, index++, this)) return item;\n      }\n    }\n    return;\n  }\n\n  /**\n   * Checks whether a strictly-equal element exists in the structure.\n   *\n   * @param element The element to test with `===` equality.\n   * @returns `true` if an equal element is found; otherwise `false`.\n   *\n   * @remarks\n   * Time O(n) in the worst case. Space O(1).\n   */\n  has(element: E): boolean {\n    for (const ele of this) if (ele === element) return true;\n    return false;\n  }\n\n  reduce(callbackfn: ReduceElementCallback<E, R>): E;\n  reduce(callbackfn: ReduceElementCallback<E, R>, initialValue: E): E;\n  reduce<U>(callbackfn: ReduceElementCallback<E, R, U>, initialValue: U): U;\n\n  /**\n   * Reduces all elements to a single accumulated value.\n   *\n   * @overload\n   * @param callbackfn Reducer of signature `(acc, value, index, self) => nextAcc`. The first element is used as the initial accumulator.\n   * @returns The final accumulated value typed as `E`.\n   *\n   * @overload\n   * @param callbackfn Reducer of signature `(acc, value, index, self) => nextAcc`.\n   * @param initialValue The initial accumulator value of type `E`.\n   * @returns The final accumulated value typed as `E`.\n   *\n   * @overload\n   * @template U The accumulator type when it differs from `E`.\n   * @param callbackfn Reducer of signature `(acc: U, value, index, self) => U`.\n   * @param initialValue The initial accumulator value of type `U`.\n   * @returns The final accumulated value typed as `U`.\n   *\n   * @remarks\n   * Time O(n), Space O(1). Throws if called on an empty structure without `initialValue`.\n   */\n  reduce<U>(callbackfn: ReduceElementCallback<E, R, U>, initialValue?: U): U {\n    let index = 0;\n    const iter = this[Symbol.iterator]();\n    let acc: U;\n\n    if (arguments.length >= 2) {\n      acc = initialValue as U;\n    } else {\n      const first = iter.next();\n      if (first.done) throw new TypeError('Reduce of empty structure with no initial value');\n      acc = first.value as unknown as U;\n      index = 1;\n    }\n\n    for (const value of iter as unknown as Iterable<E>) {\n      acc = callbackfn(acc, value, index++, this);\n    }\n    return acc;\n  }\n\n  /**\n   * Materializes the elements into a new array.\n   *\n   * @returns A shallow array copy of the iteration order.\n   * @remarks\n   * Time O(n), Space O(n).\n   */\n  toArray(): E[] {\n    return [...this];\n  }\n\n  /**\n   * Returns a representation of the structure suitable for quick visualization.\n   * Defaults to an array of elements; subclasses may override to provide richer visuals.\n   *\n   * @returns A visual representation (array by default).\n   * @remarks\n   * Time O(n), Space O(n).\n   */\n  toVisual(): E[] {\n    return [...this];\n  }\n\n  /**\n   * Prints `toVisual()` to the console. Intended for quick debugging.\n   *\n   * @returns `void`.\n   * @remarks\n   * Time O(n) due to materialization, Space O(n) for the intermediate representation.\n   */\n  print(): void {\n    console.log(this.toVisual());\n  }\n\n  /**\n   * Indicates whether the structure currently contains no elements.\n   *\n   * @returns `true` if empty; otherwise `false`.\n   * @remarks\n   * Expected Time O(1), Space O(1) for most implementations.\n   */\n  abstract isEmpty(): boolean;\n\n  /**\n   * Removes all elements from the structure.\n   *\n   * @returns `void`.\n   * @remarks\n   * Expected Time O(1) or O(n) depending on the implementation; Space O(1).\n   */\n  abstract clear(): void;\n\n  /**\n   * Creates a structural copy with the same element values and configuration.\n   *\n   * @returns A clone of the current instance (same concrete type).\n   * @remarks\n   * Expected Time O(n) to copy elements; Space O(n).\n   */\n  abstract clone(): this;\n\n  /**\n   * Maps each element to a new element and returns a new iterable structure.\n   *\n   * @template EM The mapped element type.\n   * @template RM The mapped raw element type used internally by the target structure.\n   * @param callback Function with signature `(value, index, self) => mapped`.\n   * @param options Optional options for the returned structure, including its `toElementFn`.\n   * @param thisArg Optional `this` binding for the callback.\n   * @returns A new `IterableElementBase<EM, RM>` containing mapped elements.\n   *\n   * @remarks\n   * Time O(n), Space O(n).\n   */\n  abstract map<EM, RM>(\n    callback: ElementCallback<E, R, EM>,\n    options?: IterableElementBaseOptions<EM, RM>,\n    thisArg?: unknown\n  ): IterableElementBase<EM, RM>;\n\n  /**\n   * Maps each element to the same element type and returns the same concrete structure type.\n   *\n   * @param callback Function with signature `(value, index, self) => mappedValue`.\n   * @param thisArg Optional `this` binding for the callback.\n   * @returns A new instance of the same concrete type with mapped elements.\n   *\n   * @remarks\n   * Time O(n), Space O(n).\n   */\n  abstract mapSame(callback: ElementCallback<E, R, E>, thisArg?: unknown): this;\n\n  /**\n   * Filters elements using the provided predicate and returns the same concrete structure type.\n   *\n   * @param predicate Function with signature `(value, index, self) => boolean`.\n   * @param thisArg Optional `this` binding for the predicate.\n   * @returns A new instance of the same concrete type containing only elements that pass the predicate.\n   *\n   * @remarks\n   * Time O(n), Space O(k) where `k` is the number of kept elements.\n   */\n  abstract filter(predicate: ElementCallback<E, R, boolean>, thisArg?: unknown): this;\n\n  /**\n   * Internal iterator factory used by the default iterator.\n   *\n   * @param args Optional iterator arguments.\n   * @returns An iterator over elements.\n   *\n   * @remarks\n   * Implementations should yield in O(1) per element with O(1) extra space when possible.\n   */\n  protected abstract _getIterator(...args: unknown[]): IterableIterator<E>;\n}\n","/**\n * data-structure-typed\n *\n * @author Pablo Zeng\n * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>\n * @license MIT License\n */\n\nimport type { ElementCallback, IterableElementBaseOptions, StackOptions } from '../../types';\nimport { IterableElementBase } from '../base';\n\n/**\n * LIFO stack with array storage and optional record→element conversion.\n * @remarks Time O(1), Space O(1)\n * @template E\n * @template R\n * 1. Last In, First Out (LIFO): The core characteristic of a stack is its last in, first out nature, meaning the last element added to the stack will be the first to be removed.\n * 2. Uses: Stacks are commonly used for managing a series of tasks or elements that need to be processed in a last in, first out manner. They are widely used in various scenarios, such as in function calls in programming languages, evaluation of arithmetic expressions, and backtracking algorithms.\n * 3. Performance: Stack operations are typically O(1) in time complexity, meaning that regardless of the stack's size, adding, removing, and viewing the top element are very fast operations.\n * 4. Function Calls: In most modern programming languages, the records of function calls are managed through a stack. When a function is called, its record (including parameters, local variables, and return address) is 'pushed' into the stack. When the function returns, its record is 'popped' from the stack.\n * 5. Expression Evaluation: Used for the evaluation of arithmetic or logical expressions, especially when dealing with parenthesis matching and operator precedence.\n * 6. Backtracking Algorithms: In problems where multiple branches need to be explored but only one branch can be explored at a time, stacks can be used to save the state at each branching point.\n * @example\n * // Balanced Parentheses or Brackets\n *     type ValidCharacters = ')' | '(' | ']' | '[' | '}' | '{';\n *\n *     const stack = new Stack<string>();\n *     const input: ValidCharacters[] = '[({})]'.split('') as ValidCharacters[];\n *     const matches: { [key in ValidCharacters]?: ValidCharacters } = { ')': '(', ']': '[', '}': '{' };\n *     for (const char of input) {\n *       if ('([{'.includes(char)) {\n *         stack.push(char);\n *       } else if (')]}'.includes(char)) {\n *         if (stack.pop() !== matches[char]) {\n *           fail('Parentheses are not balanced');\n *         }\n *       }\n *     }\n *     console.log(stack.isEmpty()); // true\n * @example\n * // Expression Evaluation and Conversion\n *     const stack = new Stack<number>();\n *     const expression = [5, 3, '+']; // Equivalent to 5 + 3\n *     expression.forEach(token => {\n *       if (typeof token === 'number') {\n *         stack.push(token);\n *       } else {\n *         const b = stack.pop()!;\n *         const a = stack.pop()!;\n *         stack.push(token === '+' ? a + b : 0); // Only handling '+' here\n *       }\n *     });\n *     console.log(stack.pop()); // 8\n * @example\n * // Depth-First Search (DFS)\n *     const stack = new Stack<number>();\n *     const graph: { [key in number]: number[] } = { 1: [2, 3], 2: [4], 3: [5], 4: [], 5: [] };\n *     const visited: number[] = [];\n *     stack.push(1);\n *     while (!stack.isEmpty()) {\n *       const node = stack.pop()!;\n *       if (!visited.includes(node)) {\n *         visited.push(node);\n *         graph[node].forEach(neighbor => stack.push(neighbor));\n *       }\n *     }\n *     console.log(visited); // [1, 3, 5, 2, 4]\n * @example\n * // Backtracking Algorithms\n *     const stack = new Stack<[number, number]>();\n *     const maze = [\n *       ['S', ' ', 'X'],\n *       ['X', ' ', 'X'],\n *       [' ', ' ', 'E']\n *     ];\n *     const start: [number, number] = [0, 0];\n *     const end = [2, 2];\n *     const directions = [\n *       [0, 1], // To the right\n *       [1, 0], // down\n *       [0, -1], // left\n *       [-1, 0] // up\n *     ];\n *\n *     const visited = new Set<string>(); // Used to record visited nodes\n *     stack.push(start);\n *     const path: number[][] = [];\n *\n *     while (!stack.isEmpty()) {\n *       const [x, y] = stack.pop()!;\n *       if (visited.has(`${x},${y}`)) continue; // Skip already visited nodes\n *       visited.add(`${x},${y}`);\n *\n *       path.push([x, y]);\n *\n *       if (x === end[0] && y === end[1]) {\n *         break; // Find the end point and exit\n *       }\n *\n *       for (const [dx, dy] of directions) {\n *         const nx = x + dx;\n *         const ny = y + dy;\n *         if (\n *           maze[nx]?.[ny] === ' ' || // feasible path\n *           maze[nx]?.[ny] === 'E' // destination\n *         ) {\n *           stack.push([nx, ny]);\n *         }\n *       }\n *     }\n *\n *     expect(path).toContainEqual(end);\n * @example\n * // Function Call Stack\n *     const functionStack = new Stack<string>();\n *     functionStack.push('main');\n *     functionStack.push('foo');\n *     functionStack.push('bar');\n *     console.log(functionStack.pop()); // 'bar'\n *     console.log(functionStack.pop()); // 'foo'\n *     console.log(functionStack.pop()); // 'main'\n * @example\n * // Simplify File Paths\n *     const stack = new Stack<string>();\n *     const path = '/a/./b/../../c';\n *     path.split('/').forEach(segment => {\n *       if (segment === '..') stack.pop();\n *       else if (segment && segment !== '.') stack.push(segment);\n *     });\n *     console.log(stack.elements.join('/')); // 'c'\n * @example\n * // Stock Span Problem\n *     const stack = new Stack<number>();\n *     const prices = [100, 80, 60, 70, 60, 75, 85];\n *     const spans: number[] = [];\n *     prices.forEach((price, i) => {\n *       while (!stack.isEmpty() && prices[stack.peek()!] <= price) {\n *         stack.pop();\n *       }\n *       spans.push(stack.isEmpty() ? i + 1 : i - stack.peek()!);\n *       stack.push(i);\n *     });\n *     console.log(spans); // [1, 1, 1, 2, 1, 4, 6]\n */\nexport class Stack<E = any, R = any> extends IterableElementBase<E, R> {\n  protected _equals: (a: E, b: E) => boolean = Object.is as unknown as (a: E, b: E) => boolean;\n\n  /**\n   * Create a Stack and optionally bulk-push elements.\n   * @remarks Time O(N), Space O(N)\n   * @param [elements] - Iterable of elements (or raw records if toElementFn is set).\n   * @param [options] - Options such as toElementFn and equality function.\n   * @returns New Stack instance.\n   */\n\n  constructor(elements: Iterable<E> | Iterable<R> = [], options?: StackOptions<E, R>) {\n    super(options);\n    this.pushMany(elements);\n  }\n\n  protected _elements: E[] = [];\n\n  /**\n   * Get the backing array of elements.\n   * @remarks Time O(1), Space O(1)\n   * @returns Internal elements array.\n   */\n\n  get elements(): E[] {\n    return this._elements;\n  }\n\n  /**\n   * Get the number of stored elements.\n   * @remarks Time O(1), Space O(1)\n   * @returns Current size.\n   */\n\n  get size(): number {\n    return this.elements.length;\n  }\n\n  /**\n   * Create a stack from an array of elements.\n   * @remarks Time O(N), Space O(N)\n   * @template E\n   * @template R\n   * @param this - The constructor (subclass) to instantiate.\n   * @param elements - Array of elements to push in order.\n   * @param [options] - Options forwarded to the constructor.\n   * @returns A new Stack populated from the array.\n   */\n\n  static fromArray<E, R = any>(\n    this: new (elements?: Iterable<E> | Iterable<R>, options?: StackOptions<E, R>) => any,\n    elements: E[],\n    options?: StackOptions<E, R>\n  ) {\n    return new this(elements, options);\n  }\n\n  /**\n   * Check whether the stack is empty.\n   * @remarks Time O(1), Space O(1)\n   * @returns True if size is 0.\n   */\n\n  isEmpty(): boolean {\n    return this.elements.length === 0;\n  }\n\n  /**\n   * Get the top element without removing it.\n   * @remarks Time O(1), Space O(1)\n   * @returns Top element or undefined.\n   */\n\n  peek(): E | undefined {\n    return this.isEmpty() ? undefined : this.elements[this.elements.length - 1];\n  }\n\n  /**\n   * Push one element onto the top.\n   * @remarks Time O(1), Space O(1)\n   * @param element - Element to push.\n   * @returns True when pushed.\n   */\n\n  push(element: E): boolean {\n    this.elements.push(element);\n    return true;\n  }\n\n  /**\n   * Pop and return the top element.\n   * @remarks Time O(1), Space O(1)\n   * @returns Removed element or undefined.\n   */\n\n  pop(): E | undefined {\n    return this.isEmpty() ? undefined : this.elements.pop();\n  }\n\n  /**\n   * Push many elements from an iterable.\n   * @remarks Time O(N), Space O(1)\n   * @param elements - Iterable of elements (or raw records if toElementFn is set).\n   * @returns Array of per-element success flags.\n   */\n\n  pushMany(elements: Iterable<E> | Iterable<R>): boolean[] {\n    const ans: boolean[] = [];\n    for (const el of elements) {\n      if (this.toElementFn) ans.push(this.push(this.toElementFn(el as R)));\n      else ans.push(this.push(el as E));\n    }\n    return ans;\n  }\n\n  /**\n   * Delete the first occurrence of a specific element.\n   * @remarks Time O(N), Space O(1)\n   * @param element - Element to remove (using the configured equality).\n   * @returns True if an element was removed.\n   */\n\n  delete(element: E): boolean {\n    const idx = this._indexOfByEquals(element);\n    return this.deleteAt(idx);\n  }\n\n  /**\n   * Delete the element at an index.\n   * @remarks Time O(N), Space O(1)\n   * @param index - Zero-based index from the bottom.\n   * @returns True if removed.\n   */\n\n  deleteAt(index: number): boolean {\n    if (index < 0 || index >= this.elements.length) return false;\n    const spliced = this.elements.splice(index, 1);\n    return spliced.length === 1;\n  }\n\n  /**\n   * Delete the first element that satisfies a predicate.\n   * @remarks Time O(N), Space O(1)\n   * @param predicate - Function (value, index, stack) → boolean to decide deletion.\n   * @returns True if a match was removed.\n   */\n\n  deleteWhere(predicate: (value: E, index: number, stack: this) => boolean): boolean {\n    for (let i = 0; i < this.elements.length; i++) {\n      if (predicate(this.elements[i], i, this)) {\n        this.elements.splice(i, 1);\n        return true;\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Remove all elements and reset storage.\n   * @remarks Time O(1), Space O(1)\n   * @returns void\n   */\n\n  clear(): void {\n    this._elements = [];\n  }\n\n  /**\n   * Deep clone this stack.\n   * @remarks Time O(N), Space O(N)\n   * @returns A new stack with the same content.\n   */\n\n  clone(): this {\n    const out = this._createInstance({ toElementFn: this.toElementFn });\n    for (const v of this) out.push(v);\n    return out;\n  }\n\n  /**\n   * Filter elements into a new stack of the same class.\n   * @remarks Time O(N), Space O(N)\n   * @param predicate - Predicate (value, index, stack) → boolean to keep value.\n   * @param [thisArg] - Value for `this` inside the predicate.\n   * @returns A new stack with kept values.\n   */\n\n  filter(predicate: ElementCallback<E, R, boolean>, thisArg?: unknown): this {\n    const out = this._createInstance({ toElementFn: this.toElementFn });\n    let index = 0;\n    for (const v of this) {\n      if (predicate.call(thisArg, v, index, this)) out.push(v);\n      index++;\n    }\n    return out;\n  }\n\n  /**\n   * Map values into a new stack of the same element type.\n   * @remarks Time O(N), Space O(N)\n   * @param callback - Mapping function (value, index, stack) → newValue.\n   * @param [thisArg] - Value for `this` inside the callback.\n   * @returns A new stack with mapped values.\n   */\n\n  mapSame(callback: ElementCallback<E, R, E>, thisArg?: unknown): this {\n    const out = this._createInstance({ toElementFn: this.toElementFn });\n    let index = 0;\n    for (const v of this) {\n      const mv = thisArg === undefined ? callback(v, index++, this) : callback.call(thisArg, v, index++, this);\n      out.push(mv);\n    }\n    return out;\n  }\n\n  /**\n   * Map values into a new stack (possibly different element type).\n   * @remarks Time O(N), Space O(N)\n   * @template EM\n   * @template RM\n   * @param callback - Mapping function (value, index, stack) → newElement.\n   * @param [options] - Options for the output stack (e.g., toElementFn).\n   * @param [thisArg] - Value for `this` inside the callback.\n   * @returns A new Stack with mapped elements.\n   */\n\n  map<EM, RM>(\n    callback: ElementCallback<E, R, EM>,\n    options?: IterableElementBaseOptions<EM, RM>,\n    thisArg?: unknown\n  ): Stack<EM, RM> {\n    const out = this._createLike<EM, RM>([], { ...(options ?? {}) });\n    let index = 0;\n    for (const v of this) {\n      out.push(thisArg === undefined ? callback(v, index, this) : callback.call(thisArg, v, index, this));\n      index++;\n    }\n    return out;\n  }\n\n  /**\n   * Set the equality comparator used by delete/search operations.\n   * @remarks Time O(1), Space O(1)\n   * @param equals - Equality predicate (a, b) → boolean.\n   * @returns This stack.\n   */\n\n  setEquality(equals: (a: E, b: E) => boolean): this {\n    this._equals = equals;\n    return this;\n  }\n\n  /**\n   * (Protected) Find the index of a target element using the equality function.\n   * @remarks Time O(N), Space O(1)\n   * @param target - Element to search for.\n   * @returns Index or -1 if not found.\n   */\n\n  protected _indexOfByEquals(target: E): number {\n    for (let i = 0; i < this.elements.length; i++) if (this._equals(this.elements[i], target)) return i;\n    return -1;\n  }\n\n  /**\n   * (Protected) Create an empty instance of the same concrete class.\n   * @remarks Time O(1), Space O(1)\n   * @param [options] - Options forwarded to the constructor.\n   * @returns An empty like-kind stack instance.\n   */\n\n  protected _createInstance(options?: StackOptions<E, R>): this {\n    const Ctor = this.constructor as new (elements?: Iterable<E> | Iterable<R>, options?: StackOptions<E, R>) => this;\n    return new Ctor([], options);\n  }\n\n  /**\n   * (Protected) Create a like-kind stack and seed it from an iterable.\n   * @remarks Time O(N), Space O(N)\n   * @template T\n   * @template RR\n   * @param [elements] - Iterable used to seed the new stack.\n   * @param [options] - Options forwarded to the constructor.\n   * @returns A like-kind Stack instance.\n   */\n\n  protected _createLike<T = E, RR = R>(\n    elements: Iterable<T> | Iterable<RR> = [],\n    options?: StackOptions<T, RR>\n  ): Stack<T, RR> {\n    const Ctor = this.constructor as new (\n      elements?: Iterable<T> | Iterable<RR>,\n      options?: StackOptions<T, RR>\n    ) => Stack<T, RR>;\n    return new Ctor(elements, options);\n  }\n\n  /**\n   * (Protected) Iterate elements from bottom to top.\n   * @remarks Time O(N), Space O(1)\n   * @returns Iterator of elements.\n   */\n\n  protected *_getIterator(): IterableIterator<E> {\n    for (let i = 0; i < this.elements.length; i++) yield this.elements[i];\n  }\n}\n","/**\n * data-structure-typed\n *\n * @author Pablo Zeng\n * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>\n * @license MIT License\n */\nimport type { Comparable, ComparablePrimitive, Trampoline, TrampolineThunk } from '../types';\n\n/**\n * The function generates a random UUID (Universally Unique Identifier) in TypeScript.\n * @returns A randomly generated UUID (Universally Unique Identifier) in the format\n * 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx' where each 'x' is replaced with a random hexadecimal\n * character.\n */\nexport const uuidV4 = function () {\n  return 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'.replace(/[x]/g, function (c) {\n    const r = (Math.random() * 16) | 0,\n      v = c == 'x' ? r : (r & 0x3) | 0x8;\n    return v.toString(16);\n  });\n};\n\n/**\n * The `arrayRemove` function removes elements from an array based on a specified predicate function\n * and returns the removed elements.\n * @param {T[]} array - An array of elements that you want to filter based on the provided predicate\n * function.\n * @param predicate - The `predicate` parameter is a function that takes three arguments:\n * @returns The `arrayRemove` function returns an array containing the elements that satisfy the given\n * `predicate` function.\n */\nexport const arrayRemove = function <T>(array: T[], predicate: (item: T, index: number, array: T[]) => boolean): T[] {\n  let i = -1,\n    len = array ? array.length : 0;\n  const result = [];\n\n  while (++i < len) {\n    const value = array[i];\n    if (predicate(value, i, array)) {\n      result.push(value);\n      Array.prototype.splice.call(array, i--, 1);\n      len--;\n    }\n  }\n\n  return result;\n};\n\n/**\n * The function `getMSB` returns the most significant bit of a given number.\n * @param {number} value - The `value` parameter is a number for which we want to find the position of\n * the Most Significant Bit (MSB). The function `getMSB` takes this number as input and calculates the\n * position of the MSB in its binary representation.\n * @returns The function `getMSB` returns the most significant bit (MSB) of the input `value`. If the\n * input value is less than or equal to 0, it returns 0. Otherwise, it calculates the position of the\n * MSB using the `Math.clz32` function and bitwise left shifts 1 to that position.\n */\nexport const getMSB = (value: number): number => {\n  if (value <= 0) {\n    return 0;\n  }\n  return 1 << (31 - Math.clz32(value));\n};\n\n/**\n * The `rangeCheck` function in TypeScript is used to validate if an index is within a specified range\n * and throws a `RangeError` with a custom message if it is out of bounds.\n * @param {number} index - The `index` parameter represents the value that you want to check if it\n * falls within a specified range.\n * @param {number} min - The `min` parameter represents the minimum value that the `index` should be\n * compared against in the `rangeCheck` function.\n * @param {number} max - The `max` parameter in the `rangeCheck` function represents the maximum value\n * that the `index` parameter is allowed to have. If the `index` is greater than this `max` value, a\n * `RangeError` will be thrown.\n * @param [message=Index out of bounds.] - The `message` parameter is a string that represents the\n * error message to be thrown if the index is out of bounds. By default, if no message is provided when\n * calling the `rangeCheck` function, the message \"Index out of bounds.\" will be used.\n */\nexport const rangeCheck = (index: number, min: number, max: number, message = 'Index out of bounds.'): void => {\n  if (index < min || index > max) throw new RangeError(message);\n};\n\n/**\n * The function `throwRangeError` throws a RangeError with a custom message if called.\n * @param [message=The value is off-limits.] - The `message` parameter is a string that represents the\n * error message to be displayed when a `RangeError` is thrown. If no message is provided, the default\n * message is 'The value is off-limits.'.\n */\nexport const throwRangeError = (message = 'The value is off-limits.'): void => {\n  throw new RangeError(message);\n};\n\n/**\n * The function `isWeakKey` checks if the input is an object or a function in TypeScript.\n * @param {unknown} input - The `input` parameter in the `isWeakKey` function is of type `unknown`,\n * which means it can be any type. The function checks if the `input` is an object (excluding `null`)\n * or a function, and returns a boolean indicating whether the `input` is a weak\n * @returns The function `isWeakKey` returns a boolean value indicating whether the input is an object\n * or a function.\n */\nexport const isWeakKey = (input: unknown): input is object => {\n  const inputType = typeof input;\n  return (inputType === 'object' && input !== null) || inputType === 'function';\n};\n\n/**\n * The function `calcMinUnitsRequired` calculates the minimum number of units required to accommodate a\n * given total quantity based on a specified unit size.\n * @param {number} totalQuantity - The `totalQuantity` parameter represents the total quantity of items\n * that need to be processed or handled.\n * @param {number} unitSize - The `unitSize` parameter represents the size of each unit or package. It\n * is used in the `calcMinUnitsRequired` function to calculate the minimum number of units required to\n * accommodate a total quantity of items.\n */\nexport const calcMinUnitsRequired = (totalQuantity: number, unitSize: number) =>\n  Math.floor((totalQuantity + unitSize - 1) / unitSize);\n\n/**\n * The `roundFixed` function in TypeScript rounds a number to a specified number of decimal places.\n * @param {number} num - The `num` parameter is a number that you want to round to a certain number of\n * decimal places.\n * @param {number} [digit=10] - The `digit` parameter in the `roundFixed` function specifies the number\n * of decimal places to round the number to. By default, it is set to 10 if not provided explicitly.\n * @returns The function `roundFixed` returns a number that is rounded to the specified number of\n * decimal places (default is 10 decimal places).\n */\nexport const roundFixed = (num: number, digit: number = 10) => {\n  const multiplier = Math.pow(10, digit);\n  return Math.round(num * multiplier) / multiplier;\n};\n\n/**\n * The function `isPrimitiveComparable` checks if a value is a primitive type that can be compared.\n * @param {unknown} value - The `value` parameter in the `isPrimitiveComparable` function is of type\n * `unknown`, which means it can be any type. The function checks if the `value` is a primitive type\n * that can be compared, such as number, bigint, string, or boolean.\n * @returns The function `isPrimitiveComparable` returns a boolean value indicating whether the input\n * `value` is a primitive value that can be compared using standard comparison operators (<, >, <=,\n * >=).\n */\nfunction isPrimitiveComparable(value: unknown): value is ComparablePrimitive {\n  const valueType = typeof value;\n  if (valueType === 'number') return true;\n  // if (valueType === 'number') return !Number.isNaN(value);\n  return valueType === 'bigint' || valueType === 'string' || valueType === 'boolean';\n}\n\n/**\n * The function `tryObjectToPrimitive` attempts to convert an object to a comparable primitive value by\n * first checking the `valueOf` method and then the `toString` method.\n * @param {object} obj - The `obj` parameter in the `tryObjectToPrimitive` function is an object that\n * you want to convert to a primitive value. The function attempts to convert the object to a primitive\n * value by first checking if the object has a `valueOf` method. If the `valueOf` method exists, it\n * @returns The function `tryObjectToPrimitive` returns a value of type `ComparablePrimitive` if a\n * primitive comparable value is found within the object, or a string value if the object has a custom\n * `toString` method that does not return `'[object Object]'`. If neither condition is met, the\n * function returns `null`.\n */\nfunction tryObjectToPrimitive(obj: object): ComparablePrimitive | null {\n  if (typeof obj.valueOf === 'function') {\n    const valueOfResult = obj.valueOf();\n    if (valueOfResult !== obj) {\n      if (isPrimitiveComparable(valueOfResult)) return valueOfResult;\n      if (typeof valueOfResult === 'object' && valueOfResult !== null) return tryObjectToPrimitive(valueOfResult);\n    }\n  }\n  if (typeof obj.toString === 'function') {\n    const stringResult = obj.toString();\n    if (stringResult !== '[object Object]') return stringResult;\n  }\n  return null;\n}\n\n/**\n * The function `isComparable` in TypeScript checks if a value is comparable, handling primitive values\n * and objects with optional force comparison.\n * @param {unknown} value - The `value` parameter in the `isComparable` function represents the value\n * that you want to check if it is comparable. It can be of any type (`unknown`), and the function will\n * determine if it is comparable based on certain conditions.\n * @param [isForceObjectComparable=false] - The `isForceObjectComparable` parameter in the\n * `isComparable` function is a boolean flag that determines whether to treat non-primitive values as\n * comparable objects. When set to `true`, it forces the function to consider non-primitive values as\n * comparable objects, regardless of their type.\n * @returns The function `isComparable` returns a boolean value indicating whether the `value` is\n * considered comparable or not.\n */\nexport function isComparable(value: unknown, isForceObjectComparable = false): value is Comparable {\n  if (value === null || value === undefined) return false;\n  if (isPrimitiveComparable(value)) return true;\n\n  if (typeof value !== 'object') return false;\n  if (value instanceof Date) return true;\n  // if (value instanceof Date) return !Number.isNaN(value.getTime());\n  if (isForceObjectComparable) return true;\n  const comparableValue = tryObjectToPrimitive(value);\n  if (comparableValue === null || comparableValue === undefined) return false;\n  return isPrimitiveComparable(comparableValue);\n}\n\n/**\n * Creates a trampoline thunk object.\n *\n * A \"thunk\" is a deferred computation — instead of performing a recursive call immediately,\n * it wraps the next step of the computation in a function. This allows recursive processes\n * to be executed iteratively, preventing stack overflows.\n *\n * @template T - The type of the final computation result.\n * @param computation - A function that, when executed, returns the next trampoline step.\n * @returns A TrampolineThunk object containing the deferred computation.\n */\nexport const makeTrampolineThunk = <T>(computation: () => Trampoline<T>): TrampolineThunk<T> => ({\n  isThunk: true, // Marker indicating this is a thunk\n  fn: computation // The deferred computation function\n});\n\n/**\n * Type guard to check whether a given value is a TrampolineThunk.\n *\n * This function is used to distinguish between a final computation result (value)\n * and a deferred computation (thunk).\n *\n * @template T - The type of the value being checked.\n * @param value - The value to test.\n * @returns True if the value is a valid TrampolineThunk, false otherwise.\n */\nexport const isTrampolineThunk = <T>(value: Trampoline<T>): value is TrampolineThunk<T> =>\n  typeof value === 'object' && // Must be an object\n  value !== null && // Must not be null\n  'isThunk' in value && // Must have the 'isThunk' property\n  value.isThunk; // The flag must be true\n\n/**\n * Executes a trampoline computation until a final (non-thunk) result is obtained.\n *\n * The trampoline function repeatedly invokes the deferred computations (thunks)\n * in an iterative loop. This avoids deep recursive calls and prevents stack overflow,\n * which is particularly useful for implementing recursion in a stack-safe manner.\n *\n * @template T - The type of the final result.\n * @param initial - The initial Trampoline value or thunk to start execution from.\n * @returns The final result of the computation (a non-thunk value).\n */\nexport function trampoline<T>(initial: Trampoline<T>): T {\n  let current = initial; // Start with the initial trampoline value\n  while (isTrampolineThunk(current)) {\n    // Keep unwrapping while we have thunks\n    current = current.fn(); // Execute the deferred function to get the next step\n  }\n  return current; // Once no thunks remain, return the final result\n}\n\n/**\n * Wraps a recursive function inside a trampoline executor.\n *\n * This function transforms a potentially recursive function (that returns a Trampoline<Result>)\n * into a *stack-safe* function that executes iteratively using the `trampoline` runner.\n *\n * In other words, it allows you to write functions that look recursive,\n * but actually run in constant stack space.\n *\n * @template Args - The tuple type representing the argument list of the original function.\n * @template Result - The final return type after all trampoline steps are resolved.\n *\n * @param fn - A function that performs a single step of computation\n *             and returns a Trampoline (either a final value or a deferred thunk).\n *\n * @returns A new function with the same arguments, but which automatically\n *          runs the trampoline process and returns the *final result* instead\n *          of a Trampoline.\n *\n * @example\n * // Example: Computing factorial in a stack-safe way\n * const factorial = makeTrampoline(function fact(n: number, acc: number = 1): Trampoline<number> {\n *   return n === 0\n *     ? acc\n *     : makeTrampolineThunk(() => fact(n - 1, acc * n));\n * });\n *\n * console.log(factorial(100000)); // Works without stack overflow\n */\nexport function makeTrampoline<Args extends any[], Result>(\n  fn: (...args: Args) => Trampoline<Result> // A function that returns a trampoline step\n): (...args: Args) => Result {\n  // Return a wrapped function that automatically runs the trampoline execution loop\n  return (...args: Args) => trampoline(fn(...args));\n}\n\n/**\n * Executes an asynchronous trampoline computation until a final (non-thunk) result is obtained.\n *\n * This function repeatedly invokes asynchronous deferred computations (thunks)\n * in an iterative loop. Each thunk may return either a Trampoline<T> or a Promise<Trampoline<T>>.\n *\n * It ensures that asynchronous recursive functions can run without growing the call stack,\n * making it suitable for stack-safe async recursion.\n *\n * @template T - The type of the final result.\n * @param initial - The initial Trampoline or Promise of Trampoline to start execution from.\n * @returns A Promise that resolves to the final result (a non-thunk value).\n */\nexport async function asyncTrampoline<T>(initial: Trampoline<T> | Promise<Trampoline<T>>): Promise<T> {\n  let current = await initial; // Wait for the initial step to resolve if it's a Promise\n\n  // Keep executing thunks until we reach a non-thunk (final) value\n  while (isTrampolineThunk(current)) {\n    current = await current.fn(); // Execute the thunk function (may be async)\n  }\n\n  // Once the final value is reached, return it\n  return current;\n}\n\n/**\n * Wraps an asynchronous recursive function inside an async trampoline executor.\n *\n * This helper transforms a recursive async function that returns a Trampoline<Result>\n * (or Promise<Trampoline<Result>>) into a *stack-safe* async function that executes\n * iteratively via the `asyncTrampoline` runner.\n *\n * @template Args - The tuple type representing the argument list of the original function.\n * @template Result - The final return type after all async trampoline steps are resolved.\n *\n * @param fn - An async or sync function that performs a single step of computation\n *             and returns a Trampoline (either a final value or a deferred thunk).\n *\n * @returns An async function with the same arguments, but which automatically\n *          runs the trampoline process and resolves to the *final result*.\n *\n * @example\n * // Example: Async factorial using trampoline\n * const asyncFactorial = makeAsyncTrampoline(async function fact(\n *   n: number,\n *   acc: number = 1\n * ): Promise<Trampoline<number>> {\n *   return n === 0\n *     ? acc\n *     : makeTrampolineThunk(() => fact(n - 1, acc * n));\n * });\n *\n * asyncFactorial(100000).then(console.log); // Works without stack overflow\n */\nexport function makeAsyncTrampoline<Args extends any[], Result>(\n  fn: (...args: Args) => Trampoline<Result> | Promise<Trampoline<Result>>\n): (...args: Args) => Promise<Result> {\n  // Return a wrapped async function that runs through the async trampoline loop\n  return async (...args: Args): Promise<Result> => {\n    return asyncTrampoline(fn(...args));\n  };\n}\n","import { isComparable } from '../utils';\n\nexport enum DFSOperation {\n  VISIT = 0,\n  PROCESS = 1\n}\n\nexport class Range<K> {\n  constructor(\n    public low: K,\n    public high: K,\n    public includeLow: boolean = true,\n    public includeHigh: boolean = true\n  ) {\n    if (!(isComparable(low) && isComparable(high))) throw new RangeError('low or high is not comparable');\n    if (low > high) throw new RangeError('low must be less than or equal to high');\n  }\n\n  // Determine whether a key is within the range\n  isInRange(key: K, comparator: (a: K, b: K) => number): boolean {\n    const lowCheck = this.includeLow ? comparator(key, this.low) >= 0 : comparator(key, this.low) > 0;\n    const highCheck = this.includeHigh ? comparator(key, this.high) <= 0 : comparator(key, this.high) < 0;\n    return lowCheck && highCheck;\n  }\n}\n"],"mappings":"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","names":["src_exports","__export","DFSOperation","Range","Stack","IterableElementBase","options","__publicField","toElementFn","args","item","predicate","thisArg","index","callbackfn","element","ele","initialValue","iter","acc","first","value","Stack","IterableElementBase","elements","options","__publicField","element","ans","el","idx","index","predicate","i","out","v","thisArg","callback","mv","equals","target","Ctor","isPrimitiveComparable","value","valueType","tryObjectToPrimitive","obj","valueOfResult","stringResult","isComparable","isForceObjectComparable","comparableValue","DFSOperation","Range","low","high","includeLow","includeHigh","isComparable","key","comparator","lowCheck","highCheck"]}

package/package.json

@@ -1,10 +1,30 @@
 {
   "name": "stack-typed",
-  "version": "2.1.1",
+  "version": "2.1.2",
   "description": "Stack",
-  "main": "dist/index.js",
+  "browser": "dist/umd/stack-typed.min.js",
+  "umd:main": "dist/umd/stack-typed.min.js",
+  "main": "dist/cjs/index.cjs",
+  "module": "dist/esm/index.mjs",
+  "types": "dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/esm/index.mjs",
+      "require": "./dist/cjs/index.cjs"
+    }
+  },
+  "sideEffects": false,
+  "engines": {
+    "node": ">=12.20.0",
+    "npm": ">=6.14.0"
+  },
   "scripts": {
-    "build": "rm -rf dist && npx tsc",
+    "build": "npm run build:ecu",
+    "build:node": "tsup --config tsup.node.config.js",
+    "build:types": "rm -rf dist/types && tsc -p tsconfig.types.json",
+    "build:umd": "tsup",
+    "build:ecu": "npm run build:node && npm run build:types && npm run build:umd",
     "lint": "eslint --fix \"src/**/*.{js,ts}\"",
     "format": "prettier --write \"src/**/*.{js,ts}\"",
     "test": "jest",
@@ -47,7 +67,6 @@
     "url": "https://github.com/zrwusa/data-structure-typed/issues"
   },
   "homepage": "https://data-structure-typed-docs.vercel.app",
-  "types": "dist/index.d.ts",
   "devDependencies": {
     "@types/jest": "^29.5.3",
     "@types/node": "^20.4.9",
@@ -61,10 +80,11 @@
     "jest": "^29.6.2",
     "prettier": "^3.0.3",
     "ts-jest": "^29.1.1",
+    "tsup": "^8.5.1",
     "typedoc": "^0.25.1",
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^2.1.1"
+    "data-structure-typed": "^2.1.2"
   }
 }

package/src/data-structures/binary-tree/avl-tree-counter.ts

@@ -130,7 +130,7 @@ export class AVLTreeCounter<K = any, V = any, R = any> extends AVLTree<K, V, R>
     return sum;
   }
 
-  override _createNode(key: K, value?: V, count?: number): AVLTreeCounterNode<K, V> {
+  override createNode(key: K, value?: V, count?: number): AVLTreeCounterNode<K, V> {
     return new AVLTreeCounterNode(key, this._isMapMode ? undefined : value, count) as AVLTreeCounterNode<K, V>;
   }
 
@@ -391,10 +391,10 @@ export class AVLTreeCounter<K = any, V = any, R = any> extends AVLTree<K, V, R>
       const [key, entryValue] = keyNodeOrEntry;
       if (key === undefined || key === null) return [undefined, undefined];
       const finalValue = value ?? entryValue;
-      return [this._createNode(key, finalValue, count), finalValue];
+      return [this.createNode(key, finalValue, count), finalValue];
     }
 
-    return [this._createNode(keyNodeOrEntry, value, count), value];
+    return [this.createNode(keyNodeOrEntry, value, count), value];
   }
 
   /**
@@ -412,7 +412,7 @@ export class AVLTreeCounter<K = any, V = any, R = any> extends AVLTree<K, V, R>
     destNode = this.ensureNode(destNode);
     if (srcNode && destNode) {
       const { key, value, count, height } = destNode;
-      const tempNode = this._createNode(key, value, count);
+      const tempNode = this.createNode(key, value, count);
       if (tempNode) {
         tempNode.height = height;
 

package/src/data-structures/binary-tree/avl-tree-multi-map.ts

@@ -113,7 +113,7 @@ export class AVLTreeMultiMap<K = any, V = any, R = any> extends AVLTree<K, V[],
     }
   }
 
-  override _createNode(key: K, value: V[] = []): AVLTreeMultiMapNode<K, V> {
+  override createNode(key: K, value: V[] = []): AVLTreeMultiMapNode<K, V> {
     return new AVLTreeMultiMapNode<K, V>(key, this._isMapMode ? [] : value);
   }
 

package/src/data-structures/binary-tree/avl-tree.ts

@@ -196,7 +196,7 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
    * @param [value] - The value for the new node.
    * @returns The newly created AVLTreeNode.
    */
-  override _createNode(key: K, value?: V): AVLTreeNode<K, V> {
+  override createNode(key: K, value?: V): AVLTreeNode<K, V> {
     return new AVLTreeNode<K, V>(key, this._isMapMode ? undefined : value) as AVLTreeNode<K, V>;
   }
 
@@ -370,7 +370,7 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
 
     if (srcNodeEnsured && destNodeEnsured) {
       const { key, value, height } = destNodeEnsured;
-      const tempNode = this._createNode(key, value);
+      const tempNode = this.createNode(key, value);
 
       if (tempNode) {
         tempNode.height = height;

package/src/data-structures/binary-tree/binary-tree.ts

@@ -390,7 +390,7 @@ export class BinaryTree<K = any, V = any, R = any>
    * @param [value] - The value for the new node (used if not in Map mode).
    * @returns The newly created node.
    */
-  _createNode(key: K, value?: V): BinaryTreeNode<K, V> {
+  createNode(key: K, value?: V): BinaryTreeNode<K, V> {
     return new BinaryTreeNode<K, V>(key, this._isMapMode ? undefined : value);
   }
 
@@ -2019,10 +2019,10 @@ export class BinaryTree<K = any, V = any, R = any>
       if (key === undefined) return [undefined, undefined];
       else if (key === null) return [null, undefined];
       const finalValue = value ?? entryValue;
-      return [this._createNode(key, finalValue), finalValue];
+      return [this.createNode(key, finalValue), finalValue];
     }
 
-    return [this._createNode(keyNodeOrEntry, value), value];
+    return [this.createNode(keyNodeOrEntry, value), value];
   }
 
   /**
@@ -2147,7 +2147,7 @@ export class BinaryTree<K = any, V = any, R = any>
 
     if (srcNode && destNode) {
       const { key, value } = destNode;
-      const tempNode = this._createNode(key, value); // Use a temp node to hold dest properties
+      const tempNode = this.createNode(key, value); // Use a temp node to hold dest properties
 
       if (tempNode) {
         // Copy src to dest

package/src/data-structures/binary-tree/bst.ts

@@ -268,7 +268,7 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
    * @param [value] - The value for the new node (used if not in Map mode).
    * @returns The newly created BSTNode.
    */
-  override _createNode(key: K, value?: V): BSTNode<K, V> {
+  override createNode(key: K, value?: V): BSTNode<K, V> {
     return new BSTNode<K, V>(key, this._isMapMode ? undefined : value);
   }
 

package/src/data-structures/binary-tree/red-black-tree.ts

@@ -89,7 +89,7 @@ export class RedBlackTreeNode<K = any, V = any> extends BSTNode<K, V> {
 }
 
 /**
- * RRRRRRRRRRRRRRRRRRRed-Black Tree (self-balancing BST) supporting map-like mode and stable O(log n) updates.
+ * Represents a Red-Black Tree (self-balancing BST) supporting map-like mode and stable O(log n) updates.
  * @remarks Time O(1), Space O(1)
  * @template K
  * @template V
@@ -176,7 +176,7 @@ export class RedBlackTree<K = any, V = any, R = any> extends BST<K, V, R> implem
    * @param color - See parameter type for details.
    * @returns A new RedBlackTreeNode instance.
    */
-  override _createNode(key: K, value?: V, color: RBTNColor = 'BLACK'): RedBlackTreeNode<K, V> {
+  override createNode(key: K, value?: V, color: RBTNColor = 'BLACK'): RedBlackTreeNode<K, V> {
     return new RedBlackTreeNode<K, V>(key, this._isMapMode ? undefined : value, color);
   }
 

package/src/data-structures/binary-tree/tree-counter.ts

@@ -142,7 +142,7 @@ export class TreeCounter<K = any, V = any, R = any> extends RedBlackTree<K, V, R
     return sum;
   }
 
-  override _createNode(key: K, value?: V, color: RBTNColor = 'BLACK', count?: number): TreeCounterNode<K, V> {
+  override createNode(key: K, value?: V, color: RBTNColor = 'BLACK', count?: number): TreeCounterNode<K, V> {
     return new TreeCounterNode(key, this._isMapMode ? undefined : value, count, color) as TreeCounterNode<K, V>;
   }
 
@@ -427,10 +427,10 @@ export class TreeCounter<K = any, V = any, R = any> extends RedBlackTree<K, V, R
       const [key, entryValue] = keyNodeOrEntry;
       if (key === undefined || key === null) return [undefined, undefined];
       const finalValue = value ?? entryValue;
-      return [this._createNode(key, finalValue, 'BLACK', count), finalValue];
+      return [this.createNode(key, finalValue, 'BLACK', count), finalValue];
     }
 
-    return [this._createNode(keyNodeOrEntry, value, 'BLACK', count), value];
+    return [this.createNode(keyNodeOrEntry, value, 'BLACK', count), value];
   }
 
   /**
@@ -448,7 +448,7 @@ export class TreeCounter<K = any, V = any, R = any> extends RedBlackTree<K, V, R
     destNode = this.ensureNode(destNode);
     if (srcNode && destNode) {
       const { key, value, count, color } = destNode;
-      const tempNode = this._createNode(key, value, color, count);
+      const tempNode = this.createNode(key, value, color, count);
       if (tempNode) {
         tempNode.color = color;
 

package/src/data-structures/binary-tree/tree-multi-map.ts

@@ -270,7 +270,7 @@ export class TreeMultiMap<K = any, V = any, R = any> extends RedBlackTree<K, V[]
     }
   }
 
-  override _createNode(key: K, value: V[] = []): TreeMultiMapNode<K, V> {
+  override createNode(key: K, value: V[] = []): TreeMultiMapNode<K, V> {
     return new TreeMultiMapNode<K, V>(key, this._isMapMode ? [] : value);
   }
 

package/src/data-structures/heap/heap.ts

@@ -190,7 +190,7 @@ import { IterableElementBase } from '../base';
  *     ]);
  *     console.log(scheduleTasks(tasks, 2)); // expectedMap
  */
-export class Heap<E = unknown, R = never> extends IterableElementBase<E, R> {
+export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
   protected _equals: (a: E, b: E) => boolean = Object.is;
 
   /**
@@ -255,7 +255,7 @@ export class Heap<E = unknown, R = never> extends IterableElementBase<E, R> {
    * @returns A new heap instance of this class.
    */
 
-  static from<T, R = never, S extends Heap<T, R> = Heap<T, R>>(
+  static from<T, R = any, S extends Heap<T, R> = Heap<T, R>>(
     this: new (elements?: Iterable<T | R>, options?: HeapOptions<T, R>) => S,
     elements?: Iterable<T | R>,
     options?: HeapOptions<T, R>
@@ -273,7 +273,7 @@ export class Heap<E = unknown, R = never> extends IterableElementBase<E, R> {
    * @returns A new Heap built from elements.
    */
 
-  static heapify<EE = unknown, RR = never>(elements: Iterable<EE>, options: HeapOptions<EE, RR>): Heap<EE, RR> {
+  static heapify<EE = any, RR = any>(elements: Iterable<EE>, options: HeapOptions<EE, RR>): Heap<EE, RR> {
     return new Heap<EE, RR>(elements, options);
   }
 
@@ -788,7 +788,7 @@ export class FibonacciHeap<E> {
    */
 
   push(element: E): this {
-    const node = this._createNode(element);
+    const node = this.createNode(element);
     node.left = node;
     node.right = node;
     this.mergeWithRoot(node);
@@ -900,7 +900,7 @@ export class FibonacciHeap<E> {
     heapToMerge.clear();
   }
 
-  _createNode(element: E): FibonacciHeapNode<E> {
+  createNode(element: E): FibonacciHeapNode<E> {
     return new FibonacciHeapNode<E>(element);
   }
 

package/src/data-structures/linked-list/singly-linked-list.ts

@@ -781,7 +781,7 @@ export class SinglyLinkedList<E = any, R = any> extends LinearLinkedBase<E, R, S
    * @returns A new SinglyLinkedListNode instance.
    */
 
-  protected _createNode(value: E): SinglyLinkedListNode<E> {
+  protected createNode(value: E): SinglyLinkedListNode<E> {
     return new SinglyLinkedListNode<E>(value);
   }
 
@@ -807,7 +807,7 @@ export class SinglyLinkedList<E = any, R = any> extends LinearLinkedBase<E, R, S
 
   protected _ensureNode(elementOrNode: E | SinglyLinkedListNode<E>) {
     if (this.isNode(elementOrNode)) return elementOrNode;
-    return this._createNode(elementOrNode);
+    return this.createNode(elementOrNode);
   }
 
   /**

package/src/interfaces/binary-tree.ts

@@ -32,7 +32,7 @@ export interface IBinaryTree<K = any, V = any, R = any> {
   readonly isDuplicate: boolean;
 
   // ---- construction / mutation ----
-  _createNode(key: K, value?: BinaryTreeNode<K, V>['value']): BinaryTreeNode<K, V>;
+  createNode(key: K, value?: BinaryTreeNode<K, V>['value']): BinaryTreeNode<K, V>;
 
   createTree(options?: Partial<BinaryTreeOptions<K, V, R>>): IBinaryTree<K, V, R>;
 

package/tsconfig.base.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "allowJs": true,
+    "allowSyntheticDefaultImports": true,
+    "baseUrl": "./",
+    "declaration": true,
+    "esModuleInterop": true,
+    "inlineSourceMap": false,
+    "lib": ["esnext"],
+    "listEmittedFiles": false,
+    "listFiles": false,
+    "noFallthroughCasesInSwitch": true,
+    "pretty": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "traceResolution": false,
+    "noImplicitOverride": true,
+    "types": ["node"]
+  },
+  "compileOnSave": false,
+  "exclude": ["node_modules", "dist"]
+}