{"version":3,"sources":["../../src/utils/utils.ts","../../src/data-structures/base/iterable-element-base.ts","../../src/data-structures/base/linear-base.ts","../../src/data-structures/queue/deque.ts","../../src/common/index.ts"],"names":["DFSOperation"],"mappings":"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","file":"index.cjs","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 */\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 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","import type { ElementCallback, LinearBaseOptions, ReduceLinearCallback } from '../../types';\nimport { IterableElementBase } from './iterable-element-base';\n\n/**\n * Singly-linked list node.\n * @template E - Element type.\n * @remarks Time O(1), Space O(1)\n */\nexport class LinkedListNode<E = any> {\n  /**\n   * Initialize a node.\n   * @param value - Element value.\n   * @remarks Time O(1), Space O(1)\n   */\n  constructor(value: E) {\n    this._value = value;\n    this._next = undefined;\n  }\n\n  protected _value: E;\n\n  /**\n   * Element payload getter.\n   * @returns Element value.\n   * @remarks Time O(1), Space O(1)\n   */\n  get value(): E {\n    return this._value;\n  }\n\n  /**\n   * Element payload setter.\n   * @param value - New value.\n   * @remarks Time O(1), Space O(1)\n   */\n  set value(value: E) {\n    this._value = value;\n  }\n\n  protected _next: LinkedListNode<E> | undefined;\n\n  /**\n   * Next node getter.\n   * @returns Next node or `undefined`.\n   * @remarks Time O(1), Space O(1)\n   */\n  get next(): LinkedListNode<E> | undefined {\n    return this._next;\n  }\n\n  /**\n   * Next node setter.\n   * @param value - Next node or `undefined`.\n   * @remarks Time O(1), Space O(1)\n   */\n  set next(value: LinkedListNode<E> | undefined) {\n    this._next = value;\n  }\n}\n\n/**\n * Abstract linear container with array-like utilities.\n * @template E - Element type.\n * @template R - Return type for mapped/derived views.\n * @template NODE - Linked node type used by some implementations.\n * @remarks Time O(1), Space O(1)\n */\nexport abstract class LinearBase<\n  E,\n  R = any,\n  NODE extends LinkedListNode<E> = LinkedListNode<E>\n> extends IterableElementBase<E, R> {\n  /**\n   * Construct a linear container with runtime options.\n   * @param options - `{ maxLen?, ... }` bounds/behavior options.\n   * @remarks Time O(1), Space O(1)\n   */\n   constructor(options?: LinearBaseOptions<E, R>) {\n    super(options);\n    if (options) {\n      const { maxLen } = options;\n      if (typeof maxLen === 'number' && maxLen > 0 && maxLen % 1 === 0) this._maxLen = maxLen;\n    }\n  }\n\n  /**\n   * Element count.\n   * @returns Number of elements.\n   * @remarks Time O(1), Space O(1)\n   */\n  abstract get length(): number;\n\n  protected _maxLen: number = -1;\n\n  /**\n   * Upper bound for length (if positive), or `-1` when unbounded.\n   * @returns Maximum allowed length.\n   * @remarks Time O(1), Space O(1)\n   */\n  get maxLen() {\n    return this._maxLen;\n  }\n\n  /**\n   * First index of a value from the left.\n   * @param searchElement - Value to match.\n   * @param fromIndex - Start position (supports negative index).\n   * @returns Index or `-1` if not found.\n   * @remarks Time O(n), Space O(1)\n   */\n  indexOf(searchElement: E, fromIndex: number = 0): number {\n    if (this.length === 0) return -1;\n    if (fromIndex < 0) fromIndex = this.length + fromIndex;\n    if (fromIndex < 0) fromIndex = 0;\n\n    for (let i = fromIndex; i < this.length; i++) {\n      const element = this.at(i);\n      if (element === searchElement) return i;\n    }\n\n    return -1;\n  }\n\n  /**\n   * Last index of a value from the right.\n   * @param searchElement - Value to match.\n   * @param fromIndex - Start position (supports negative index).\n   * @returns Index or `-1` if not found.\n   * @remarks Time O(n), Space O(1)\n   */\n  lastIndexOf(searchElement: E, fromIndex: number = this.length - 1): number {\n    if (this.length === 0) return -1;\n    if (fromIndex >= this.length) fromIndex = this.length - 1;\n    if (fromIndex < 0) fromIndex = this.length + fromIndex;\n\n    for (let i = fromIndex; i >= 0; i--) {\n      const element = this.at(i);\n      if (element === searchElement) return i;\n    }\n\n    return -1;\n  }\n\n  /**\n   * Find the first index matching a predicate.\n   * @param predicate - `(element, index, self) => boolean`.\n   * @param thisArg - Optional `this` for callback.\n   * @returns Index or `-1`.\n   * @remarks Time O(n), Space O(1)\n   */\n  findIndex(predicate: ElementCallback<E, R, boolean>, thisArg?: any): number {\n    for (let i = 0; i < this.length; i++) {\n      const item = this.at(i);\n      if (item !== undefined && predicate.call(thisArg, item, i, this)) return i;\n    }\n    return -1;\n  }\n\n  /**\n   * Concatenate elements and/or containers.\n   * @param items - Elements or other containers.\n   * @returns New container with combined elements (`this` type).\n   * @remarks Time O(sum(length)), Space O(sum(length))\n   */\n  concat(...items: (E | this)[]): this {\n    const newList = this.clone();\n\n    for (const item of items) {\n      if (item instanceof LinearBase) {\n        newList.pushMany(item);\n      } else {\n        newList.push(item);\n      }\n    }\n\n    return newList;\n  }\n\n  /**\n   * In-place stable order via array sort semantics.\n   * @param compareFn - Comparator `(a, b) => number`.\n   * @returns This container.\n   * @remarks Time O(n log n), Space O(n) (materializes to array temporarily)\n   */\n  sort(compareFn?: (a: E, b: E) => number): this {\n    const arr = this.toArray();\n    arr.sort(compareFn);\n    this.clear();\n    for (const item of arr) this.push(item);\n    return this;\n  }\n\n  /**\n   * Remove and/or insert elements at a position (array-compatible).\n   * @param start - Start index (supports negative index).\n   * @param deleteCount - How many to remove.\n   * @param items - Elements to insert.\n   * @returns Removed elements as a new list (`this` type).\n   * @remarks Time O(n + m), Space O(min(n, m)) where `m = items.length`\n   */\n  splice(start: number, deleteCount: number = 0, ...items: E[]): this {\n    const removedList = this._createInstance();\n\n    start = start < 0 ? this.length + start : start;\n    start = Math.max(0, Math.min(start, this.length));\n    deleteCount = Math.max(0, Math.min(deleteCount, this.length - start));\n\n    for (let i = 0; i < deleteCount; i++) {\n      const removed = this.deleteAt(start);\n      if (removed !== undefined) {\n        removedList.push(removed);\n      }\n    }\n\n    for (let i = 0; i < items.length; i++) {\n      this.addAt(start + i, items[i]);\n    }\n\n    return removedList;\n  }\n\n  /**\n   * Join all elements into a string.\n   * @param separator - Separator string.\n   * @returns Concatenated string.\n   * @remarks Time O(n), Space O(n)\n   */\n  join(separator: string = ','): string {\n    return this.toArray().join(separator);\n  }\n\n  /**\n   * Snapshot elements into a reversed array.\n   * @returns New reversed array.\n   * @remarks Time O(n), Space O(n)\n   */\n  toReversedArray(): E[] {\n    const array: E[] = [];\n    for (let i = this.length - 1; i >= 0; i--) {\n      array.push(this.at(i)!);\n    }\n    return array;\n  }\n\n  reduceRight(callbackfn: ReduceLinearCallback<E>): E;\n\n  reduceRight(callbackfn: ReduceLinearCallback<E>, initialValue: E): E;\n\n  /**\n   * Right-to-left reduction over elements.\n   * @param callbackfn - `(acc, element, index, self) => acc`.\n   * @param initialValue - Initial accumulator (optional generic overloads supported).\n   * @returns Final accumulator.\n   * @remarks Time O(n), Space O(1)\n   */\n  reduceRight<U>(callbackfn: ReduceLinearCallback<E, U>, initialValue: U): U;\n\n  reduceRight<U>(callbackfn: ReduceLinearCallback<E, U>, initialValue?: U): U {\n    let accumulator = initialValue ?? (0 as U);\n    for (let i = this.length - 1; i >= 0; i--) {\n      accumulator = callbackfn(accumulator, this.at(i)!, i, this);\n    }\n    return accumulator;\n  }\n\n  /**\n   * Create a shallow copy of a subrange.\n   * @param start - Inclusive start (supports negative index).\n   * @param end - Exclusive end (supports negative index).\n   * @returns New list with the range (`this` type).\n   * @remarks Time O(n), Space O(n)\n   */\n  slice(start: number = 0, end: number = this.length): this {\n    start = start < 0 ? this.length + start : start;\n    end = end < 0 ? this.length + end : end;\n\n    const newList = this._createInstance();\n    for (let i = start; i < end; i++) {\n      newList.push(this.at(i)!);\n    }\n    return newList;\n  }\n\n  /**\n   * Fill a range with a value.\n   * @param value - Value to set.\n   * @param start - Inclusive start.\n   * @param end - Exclusive end.\n   * @returns This list.\n   * @remarks Time O(n), Space O(1)\n   */\n  fill(value: E, start = 0, end = this.length): this {\n    start = start < 0 ? this.length + start : start;\n    end = end < 0 ? this.length + end : end;\n\n    if (start < 0) start = 0;\n    if (end > this.length) end = this.length;\n    if (start >= end) return this;\n\n    for (let i = start; i < end; i++) {\n      this.setAt(i, value);\n    }\n\n    return this;\n  }\n\n  /**\n   * Set the value at an index.\n   * @param index - Position (0-based).\n   * @param value - New value.\n   * @returns `true` if updated.\n   * @remarks Time O(1) typical, Space O(1)\n   */\n  abstract setAt(index: number, value: E): boolean;\n\n  /**\n   * Deep clone while preserving concrete subtype.\n   * @returns New list of the same species (`this` type).\n   * @remarks Time O(n), Space O(n)\n   */\n  abstract override clone(): this;\n\n  /**\n   * Reverse the order of elements in-place (or equivalent).\n   * @returns This list.\n   * @remarks Time O(n), Space O(1)\n   */\n  abstract reverse(): this;\n\n  /**\n   * Append one element or node to the tail.\n   * @param elementOrNode - Element or node.\n   * @returns `true` if appended.\n   * @remarks Time O(1) amortized typical, Space O(1)\n   */\n  abstract push(elementOrNode: E | NODE): boolean;\n\n  /**\n   * Append many elements/nodes at once.\n   * @param elements - Iterable of elements or nodes.\n   * @returns Array of booleans indicating append success.\n   * @remarks Time O(n), Space O(1)\n   */\n  abstract pushMany(elements: Iterable<E> | Iterable<R> | Iterable<NODE>): boolean[];\n\n  /**\n   * Remove one element or node if present.\n   * @param elementOrNode - Element or node to delete.\n   * @returns `true` if removed.\n   * @remarks Time O(1)~O(n) depending on implementation, Space O(1)\n   */\n  abstract delete(elementOrNode: E | NODE | undefined): boolean;\n\n  /**\n   * Get element at an index.\n   * @param index - Position (0-based).\n   * @returns Element or `undefined`.\n   * @remarks Time O(1)~O(n) depending on implementation, Space O(1)\n   */\n  abstract at(index: number): E | undefined;\n\n  /**\n   * Remove element at a position.\n   * @param pos - Position (0-based).\n   * @returns Removed element or `undefined`.\n   * @remarks Time O(1)~O(n) depending on implementation, Space O(1)\n   */\n  abstract deleteAt(pos: number): E | undefined;\n\n  /**\n   * Insert an element/node at a position.\n   * @param index - Position (0-based).\n   * @param newElementOrNode - Element or node to insert.\n   * @returns `true` if inserted.\n   * @remarks Time O(1)~O(n) depending on implementation, Space O(1)\n   */\n  abstract addAt(index: number, newElementOrNode: E | NODE): boolean;\n\n  /**\n   * Create an empty list of the same species.\n   * @param options - Runtime options to carry.\n   * @returns Empty list (`this` type).\n   * @remarks Time O(1), Space O(1)\n   */\n  protected abstract _createInstance(options?: LinearBaseOptions<E, R>): this;\n\n  /**\n   * Reverse-direction iterator over elements.\n   * @returns Iterator of elements from tail to head.\n   * @remarks Time O(n), Space O(1)\n   */\n  protected abstract _getReverseIterator(...args: any[]): IterableIterator<E>;\n}\n\n/**\n * Linked-list specialized linear container.\n * @template E - Element type.\n * @template R - Return type for mapped/derived views.\n * @template NODE - Linked node type.\n * @remarks Time O(1), Space O(1)\n */\nexport abstract class LinearLinkedBase<\n  E,\n  R = any,\n  NODE extends LinkedListNode<E> = LinkedListNode<E>\n> extends LinearBase<E, R, NODE> {\n   constructor(options?: LinearBaseOptions<E, R>) {\n    super(options);\n    if (options) {\n      const { maxLen } = options;\n      if (typeof maxLen === 'number' && maxLen > 0 && maxLen % 1 === 0) this._maxLen = maxLen;\n    }\n  }\n\n  /**\n   * Linked-list optimized `indexOf` (forwards scan).\n   * @param searchElement - Value to match.\n   * @param fromIndex - Start position.\n   * @returns Index or `-1`.\n   * @remarks Time O(n), Space O(1)\n   */\n  override indexOf(searchElement: E, fromIndex: number = 0): number {\n    const iterator = this._getIterator();\n    let current = iterator.next();\n\n    let index = 0;\n    while (index < fromIndex) {\n      current = iterator.next();\n      index++;\n    }\n\n    while (!current.done) {\n      if (current.value === searchElement) return index;\n      current = iterator.next();\n      index++;\n    }\n\n    return -1;\n  }\n\n  /**\n   * Linked-list optimized `lastIndexOf` (reverse scan).\n   * @param searchElement - Value to match.\n   * @param fromIndex - Start position.\n   * @returns Index or `-1`.\n   * @remarks Time O(n), Space O(1)\n   */\n  override lastIndexOf(searchElement: E, fromIndex: number = this.length - 1): number {\n    const iterator = this._getReverseIterator();\n    let current = iterator.next();\n\n    let index = this.length - 1;\n    while (index > fromIndex) {\n      current = iterator.next();\n      index--;\n    }\n\n    while (!current.done) {\n      if (current.value === searchElement) return index;\n      current = iterator.next();\n      index--;\n    }\n\n    return -1;\n  }\n\n  /**\n   * Concatenate lists/elements preserving order.\n   * @param items - Elements or `LinearBase` instances.\n   * @returns New list with combined elements (`this` type).\n   * @remarks Time O(sum(length)), Space O(sum(length))\n   */\n  override concat(...items: (E | LinearBase<E, R>)[]): this {\n    const newList = this.clone();\n\n    for (const item of items) {\n      if (item instanceof LinearBase) {\n        newList.pushMany(item);\n      } else {\n        newList.push(item);\n      }\n    }\n\n    return newList;\n  }\n\n  /**\n   * Slice via forward iteration (no random access required).\n   * @param start - Inclusive start (supports negative index).\n   * @param end - Exclusive end (supports negative index).\n   * @returns New list (`this` type).\n   * @remarks Time O(n), Space O(n)\n   */\n  override slice(start: number = 0, end: number = this.length): this {\n    start = start < 0 ? this.length + start : start;\n    end = end < 0 ? this.length + end : end;\n\n    const newList = this._createInstance();\n    const iterator = this._getIterator();\n    let current = iterator.next();\n    let c = 0;\n    while (c < start) {\n      current = iterator.next();\n      c++;\n    }\n    for (let i = start; i < end; i++) {\n      newList.push(current.value);\n      current = iterator.next();\n    }\n\n    return newList;\n  }\n\n  /**\n   * Splice by walking node iterators from the start index.\n   * @param start - Start index.\n   * @param deleteCount - How many elements to remove.\n   * @param items - Elements to insert after the splice point.\n   * @returns Removed elements as a new list (`this` type).\n   * @remarks Time O(n + m), Space O(min(n, m)) where `m = items.length`\n   */\n  override splice(start: number, deleteCount: number = 0, ...items: E[]): this {\n    const removedList = this._createInstance();\n\n    start = start < 0 ? this.length + start : start;\n    start = Math.max(0, Math.min(start, this.length));\n    deleteCount = Math.max(0, deleteCount);\n\n    let currentIndex = 0;\n    let currentNode: NODE | undefined = undefined;\n    let previousNode: NODE | undefined = undefined;\n\n    const iterator = this._getNodeIterator();\n    for (const node of iterator) {\n      if (currentIndex === start) {\n        currentNode = node;\n        break;\n      }\n      previousNode = node;\n      currentIndex++;\n    }\n\n    for (let i = 0; i < deleteCount && currentNode; i++) {\n      removedList.push(currentNode.value);\n      const nextNode = currentNode.next;\n      this.delete(currentNode);\n      currentNode = nextNode as NODE;\n    }\n\n    for (let i = 0; i < items.length; i++) {\n      if (previousNode) {\n        this.addAfter(previousNode, items[i]);\n        previousNode = previousNode.next as NODE;\n      } else {\n        this.addAt(0, items[i]);\n        previousNode = this._getNodeIterator().next().value;\n      }\n    }\n\n    return removedList;\n  }\n\n  override reduceRight(callbackfn: ReduceLinearCallback<E>): E;\n\n  override reduceRight(callbackfn: ReduceLinearCallback<E>, initialValue: E): E;\n\n  /**\n   * Right-to-left reduction using reverse iterator.\n   * @param callbackfn - `(acc, element, index, self) => acc`.\n   * @param initialValue - Initial accumulator.\n   * @returns Final accumulator.\n   * @remarks Time O(n), Space O(1)\n   */\n  override reduceRight<U>(callbackfn: ReduceLinearCallback<E, U>, initialValue: U): U;\n\n  override reduceRight<U>(callbackfn: ReduceLinearCallback<E, U>, initialValue?: U): U {\n    let accumulator = initialValue ?? (0 as U);\n    let index = this.length - 1;\n    for (const item of this._getReverseIterator()) {\n      accumulator = callbackfn(accumulator, item, index--, this);\n    }\n    return accumulator;\n  }\n\n  /**\n   * Delete by element or node in a linked list.\n   * @param elementOrNode - Element or node.\n   * @returns `true` if removed.\n   * @remarks Time O(1)~O(n) depending on availability of links, Space O(1)\n   */\n  abstract override delete(elementOrNode: E | NODE | undefined): boolean;\n\n  /**\n   * Insert new element/node before an existing node.\n   * @param existingElementOrNode - Reference element/node.\n   * @param newElementOrNode - Element/node to insert.\n   * @returns `true` if inserted.\n   * @remarks Time O(1)~O(n) depending on reference access, Space O(1)\n   */\n  abstract addBefore(existingElementOrNode: E | NODE, newElementOrNode: E | NODE): boolean;\n\n  /**\n   * Insert new element/node after an existing node.\n   * @param existingElementOrNode - Reference element/node.\n   * @param newElementOrNode - Element/node to insert.\n   * @returns `true` if inserted.\n   * @remarks Time O(1)~O(n) depending on reference access, Space O(1)\n   */\n  abstract addAfter(existingElementOrNode: E | NODE, newElementOrNode: E | NODE): boolean;\n\n  /**\n   * Node at index (for random-access emulation).\n   * @param index - Position (0-based).\n   * @returns Node or `undefined`.\n   * @remarks Time O(n), Space O(1)\n   */\n  abstract getNodeAt(index: number): NODE | undefined;\n\n  /**\n   * Iterate linked nodes from head to tail.\n   * @returns Iterator over nodes.\n   * @remarks Time O(n), Space O(1)\n   */\n  protected abstract _getNodeIterator(...args: any[]): IterableIterator<NODE>;\n\n  /**\n   * Get previous node of a given node.\n   * @param node - Current node.\n   * @returns Previous node or `undefined`.\n   * @remarks Time O(1)~O(n) depending on list variant (singly vs doubly), Space O(1)\n   */\n  protected abstract _getPrevNode(node: NODE): NODE | undefined;\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 {\n  DequeOptions,\n  ElementCallback,\n  IterableElementBaseOptions,\n  IterableWithSizeOrLength,\n  LinearBaseOptions\n} from '../../types';\nimport { calcMinUnitsRequired, rangeCheck } from '../../utils';\nimport { LinearBase } from '../base/linear-base';\n\n/**\n * Deque implemented with circular buckets allowing O(1) amortized push/pop at both ends.\n * @remarks Time O(1), Space O(1)\n * @template E\n * @template R\n * 1. Operations at Both Ends: Supports adding and removing elements at both the front and back of the queue. This allows it to be used as a stack (last in, first out) and a queue (first in, first out).\n * 2. Efficient Random Access: Being based on an array, it offers fast random access capability, allowing constant time access to any element.\n * 3. Continuous Memory Allocation: Since it is based on an array, all elements are stored contiguously in memory, which can bring cache friendliness and efficient memory access.\n * 4. Efficiency: Adding and removing elements at both ends of a deque is usually very fast. However, when the dynamic array needs to expand, it may involve copying the entire array to a larger one, and this operation has a time complexity of O(n).\n * 5. Performance jitter: Deque may experience performance jitter, but DoublyLinkedList will not\n * @example\n * // basic Deque creation and push/pop operations\n *  // Create a simple Deque with initial values\n *     const deque = new Deque([1, 2, 3, 4, 5]);\n *\n *     // Verify the deque maintains insertion order\n *     console.log([...deque]); // [1, 2, 3, 4, 5];\n *\n *     // Check length\n *     console.log(deque.length); // 5;\n *\n *     // Push to the end\n *     deque.push(6);\n *     console.log(deque.length); // 6;\n *\n *     // Pop from the end\n *     const last = deque.pop();\n *     console.log(last); // 6;\n * @example\n * // Deque shift and unshift operations\n *  const deque = new Deque<number>([20, 30, 40]);\n *\n *     // Unshift adds to the front\n *     deque.unshift(10);\n *     console.log([...deque]); // [10, 20, 30, 40];\n *\n *     // Shift removes from the front (O(1) complexity!)\n *     const first = deque.shift();\n *     console.log(first); // 10;\n *\n *     // Verify remaining elements\n *     console.log([...deque]); // [20, 30, 40];\n *     console.log(deque.length); // 3;\n * @example\n * // Deque peek at both ends\n *  const deque = new Deque<number>([10, 20, 30, 40, 50]);\n *\n *     // Get first element without removing\n *     const first = deque.at(0);\n *     console.log(first); // 10;\n *\n *     // Get last element without removing\n *     const last = deque.at(deque.length - 1);\n *     console.log(last); // 50;\n *\n *     // Length unchanged\n *     console.log(deque.length); // 5;\n * @example\n * // Deque for...of iteration and reverse\n *  const deque = new Deque<string>(['A', 'B', 'C', 'D']);\n *\n *     // Iterate forward\n *     const forward: string[] = [];\n *     for (const item of deque) {\n *       forward.push(item);\n *     }\n *     console.log(forward); // ['A', 'B', 'C', 'D'];\n *\n *     // Reverse the deque\n *     deque.reverse();\n *     const backward: string[] = [];\n *     for (const item of deque) {\n *       backward.push(item);\n *     }\n *     console.log(backward); // ['D', 'C', 'B', 'A'];\n * @example\n * // Deque as sliding window for stream processing\n *  interface DataPoint {\n *       timestamp: number;\n *       value: number;\n *       sensor: string;\n *     }\n *\n *     // Create a deque-based sliding window for real-time data aggregation\n *     const windowSize = 3;\n *     const dataWindow = new Deque<DataPoint>();\n *\n *     // Simulate incoming sensor data stream\n *     const incomingData: DataPoint[] = [\n *       { timestamp: 1000, value: 25.5, sensor: 'temp-01' },\n *       { timestamp: 1100, value: 26.2, sensor: 'temp-01' },\n *       { timestamp: 1200, value: 25.8, sensor: 'temp-01' },\n *       { timestamp: 1300, value: 27.1, sensor: 'temp-01' },\n *       { timestamp: 1400, value: 26.9, sensor: 'temp-01' }\n *     ];\n *\n *     const windowResults: Array<{ avgValue: number; windowSize: number }> = [];\n *\n *     for (const dataPoint of incomingData) {\n *       // Add new data to the end\n *       dataWindow.push(dataPoint);\n *\n *       // Remove oldest data when window exceeds size (O(1) from front)\n *       if (dataWindow.length > windowSize) {\n *         dataWindow.shift();\n *       }\n *\n *       // Calculate average of current window\n *       let sum = 0;\n *       for (const point of dataWindow) {\n *         sum += point.value;\n *       }\n *       const avg = sum / dataWindow.length;\n *\n *       windowResults.push({\n *         avgValue: Math.round(avg * 10) / 10,\n *         windowSize: dataWindow.length\n *       });\n *     }\n *\n *     // Verify sliding window behavior\n *     console.log(windowResults.length); // 5;\n *     console.log(windowResults[0].windowSize); // 1; // First window has 1 element\n *     console.log(windowResults[2].windowSize); // 3; // Windows are at max size from 3rd onwards\n *     console.log(windowResults[4].windowSize); // 3; // Last window still has 3 elements\n *     console.log(dataWindow.length); // 3;\n */\nexport class Deque<E = any, R = any> extends LinearBase<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 Deque and optionally bulk-insert elements.\n   * @remarks Time O(N), Space O(N)\n   * @param [elements] - Iterable (or iterable-like) of elements/records to insert.\n   * @param [options] - Options such as bucketSize, toElementFn, and maxLen.\n   * @returns New Deque instance.\n   */\n\n  constructor(elements: IterableWithSizeOrLength<E> | IterableWithSizeOrLength<R> = [], options?: DequeOptions<E, R>) {\n    super(options);\n\n    if (options) {\n      const { bucketSize } = options;\n      if (typeof bucketSize === 'number') this._bucketSize = bucketSize;\n    }\n\n    let _size: number;\n    if ('length' in elements) {\n      _size = typeof elements.length === 'function' ? elements.length() : elements.length;\n    } else {\n      _size = typeof elements.size === 'function' ? elements.size() : elements.size;\n    }\n\n    this._bucketCount = calcMinUnitsRequired(_size, this._bucketSize) || 1;\n    for (let i = 0; i < this._bucketCount; ++i) {\n      this._buckets.push(new Array(this._bucketSize));\n    }\n    const needBucketNum = calcMinUnitsRequired(_size, this._bucketSize);\n    this._bucketFirst = this._bucketLast = (this._bucketCount >> 1) - (needBucketNum >> 1);\n    this._firstInBucket = this._lastInBucket = (this._bucketSize - (_size % this._bucketSize)) >> 1;\n    this.pushMany(elements);\n  }\n\n  protected _bucketSize: number = 1 << 12;\n\n  /**\n   * Get the current bucket size.\n   * @remarks Time O(1), Space O(1)\n   * @returns Bucket capacity per bucket.\n   */\n\n  get bucketSize() {\n    return this._bucketSize;\n  }\n\n  protected _bucketFirst = 0;\n\n  /**\n   * Get the index of the first bucket in use.\n   * @remarks Time O(1), Space O(1)\n   * @returns Zero-based bucket index.\n   */\n\n  get bucketFirst(): number {\n    return this._bucketFirst;\n  }\n\n  protected _firstInBucket = 0;\n\n  /**\n   * Get the index inside the first bucket.\n   * @remarks Time O(1), Space O(1)\n   * @returns Zero-based index within the first bucket.\n   */\n\n  get firstInBucket(): number {\n    return this._firstInBucket;\n  }\n\n  protected _bucketLast = 0;\n\n  /**\n   * Get the index of the last bucket in use.\n   * @remarks Time O(1), Space O(1)\n   * @returns Zero-based bucket index.\n   */\n\n  get bucketLast(): number {\n    return this._bucketLast;\n  }\n\n  protected _lastInBucket = 0;\n\n  /**\n   * Get the index inside the last bucket.\n   * @remarks Time O(1), Space O(1)\n   * @returns Zero-based index within the last bucket.\n   */\n\n  get lastInBucket(): number {\n    return this._lastInBucket;\n  }\n\n  protected _bucketCount = 0;\n\n  /**\n   * Get the number of buckets allocated.\n   * @remarks Time O(1), Space O(1)\n   * @returns Bucket count.\n   */\n\n  get bucketCount(): number {\n    return this._bucketCount;\n  }\n\n  protected _buckets: E[][] = [];\n\n  /**\n   * Get the internal buckets array.\n   * @remarks Time O(1), Space O(1)\n   * @returns Array of buckets storing values.\n   */\n\n  get buckets() {\n    return this._buckets;\n  }\n\n  protected _length = 0;\n\n  /**\n   * Get the number of elements in the deque.\n   * @remarks Time O(1), Space O(1)\n   * @returns Current length.\n   */\n\n  get length() {\n    return this._length;\n  }\n\n  /**\n   * Get the first element without removing it.\n   * @remarks Time O(1), Space O(1)\n   * @returns First element or undefined.\n   */\n\n  get first(): E | undefined {\n    if (this._length === 0) return;\n    return this._buckets[this._bucketFirst][this._firstInBucket];\n  }\n\n  /**\n   * Get the last element without removing it.\n   * @remarks Time O(1), Space O(1)\n   * @returns Last element or undefined.\n   */\n\n  get last(): E | undefined {\n    if (this._length === 0) return;\n    return this._buckets[this._bucketLast][this._lastInBucket];\n  }\n\n  /**\n   * Create a Deque from an array of elements.\n   * @remarks Time O(N), Space O(N)\n   * @template E\n   * @template R\n   * @param this - Constructor (subclass) to instantiate.\n   * @param data - Array of elements to insert in order.\n   * @param [options] - Options forwarded to the constructor.\n   * @returns A new Deque populated from the array.\n   */\n\n  static fromArray<E, R = any>(\n    this: new (\n      elements?: IterableWithSizeOrLength<E> | IterableWithSizeOrLength<R>,\n      options?: DequeOptions<E, R>\n    ) => any,\n    data: E[],\n    options?: DequeOptions<E, R>\n  ) {\n    return new this(data, options);\n  }\n\n  /**\n   * Append one element at the back.\n   * @remarks Time O(1) amortized, Space O(1)\n   * @param element - Element to append.\n   * @returns True when appended.\n   */\n\n  push(element: E): boolean {\n    if (this._length) {\n      if (this._lastInBucket < this._bucketSize - 1) {\n        this._lastInBucket += 1;\n      } else if (this._bucketLast < this._bucketCount - 1) {\n        this._bucketLast += 1;\n        this._lastInBucket = 0;\n      } else {\n        this._bucketLast = 0;\n        this._lastInBucket = 0;\n      }\n      if (this._bucketLast === this._bucketFirst && this._lastInBucket === this._firstInBucket) this._reallocate();\n    }\n    this._length += 1;\n    this._buckets[this._bucketLast][this._lastInBucket] = element;\n    if (this._maxLen > 0 && this._length > this._maxLen) this.shift();\n    return true;\n  }\n\n  /**\n   * Remove and return the last element.\n   * @remarks Time O(1), Space O(1)\n   * @returns Removed element or undefined.\n   */\n\n  pop(): E | undefined {\n    if (this._length === 0) return;\n    const element = this._buckets[this._bucketLast][this._lastInBucket];\n    if (this._length !== 1) {\n      if (this._lastInBucket > 0) {\n        this._lastInBucket -= 1;\n      } else if (this._bucketLast > 0) {\n        this._bucketLast -= 1;\n        this._lastInBucket = this._bucketSize - 1;\n      } else {\n        this._bucketLast = this._bucketCount - 1;\n        this._lastInBucket = this._bucketSize - 1;\n      }\n    }\n    this._length -= 1;\n    return element;\n  }\n\n  /**\n   * Remove and return the first element.\n   * @remarks Time O(1) amortized, Space O(1)\n   * @returns Removed element or undefined.\n   */\n\n  shift(): E | undefined {\n    if (this._length === 0) return;\n    const element = this._buckets[this._bucketFirst][this._firstInBucket];\n    if (this._length !== 1) {\n      if (this._firstInBucket < this._bucketSize - 1) {\n        this._firstInBucket += 1;\n      } else if (this._bucketFirst < this._bucketCount - 1) {\n        this._bucketFirst += 1;\n        this._firstInBucket = 0;\n      } else {\n        this._bucketFirst = 0;\n        this._firstInBucket = 0;\n      }\n    }\n    this._length -= 1;\n    return element;\n  }\n\n  /**\n   * Prepend one element at the front.\n   * @remarks Time O(1) amortized, Space O(1)\n   * @param element - Element to prepend.\n   * @returns True when prepended.\n   */\n\n  unshift(element: E): boolean {\n    if (this._length) {\n      if (this._firstInBucket > 0) {\n        this._firstInBucket -= 1;\n      } else if (this._bucketFirst > 0) {\n        this._bucketFirst -= 1;\n        this._firstInBucket = this._bucketSize - 1;\n      } else {\n        this._bucketFirst = this._bucketCount - 1;\n        this._firstInBucket = this._bucketSize - 1;\n      }\n      if (this._bucketFirst === this._bucketLast && this._firstInBucket === this._lastInBucket) this._reallocate();\n    }\n    this._length += 1;\n    this._buckets[this._bucketFirst][this._firstInBucket] = element;\n    if (this._maxLen > 0 && this._length > this._maxLen) this.pop();\n    return true;\n  }\n\n  /**\n   * Append a sequence of elements.\n   * @remarks Time O(N), Space O(1)\n   * @param elements - Iterable (or iterable-like) of elements/records.\n   * @returns Array of per-element success flags.\n   */\n\n  pushMany(elements: IterableWithSizeOrLength<E> | IterableWithSizeOrLength<R>) {\n    const ans: boolean[] = [];\n    for (const el of elements) {\n      if (this.toElementFn) {\n        ans.push(this.push(this.toElementFn(el as R)));\n      } else {\n        ans.push(this.push(el as E));\n      }\n    }\n    return ans;\n  }\n\n  /**\n   * Prepend a sequence of elements.\n   * @remarks Time O(N), Space O(1)\n   * @param [elements] - Iterable (or iterable-like) of elements/records.\n   * @returns Array of per-element success flags.\n   */\n\n  unshiftMany(elements: IterableWithSizeOrLength<E> | IterableWithSizeOrLength<R> = []) {\n    const ans: boolean[] = [];\n    for (const el of elements) {\n      if (this.toElementFn) {\n        ans.push(this.unshift(this.toElementFn(el as R)));\n      } else {\n        ans.push(this.unshift(el as E));\n      }\n    }\n    return ans;\n  }\n\n  /**\n   * Check whether the deque is empty.\n   * @remarks Time O(1), Space O(1)\n   * @returns True if length is 0.\n   */\n\n  isEmpty(): boolean {\n    return this._length === 0;\n  }\n\n  /**\n   * Remove all elements and reset structure.\n   * @remarks Time O(1), Space O(1)\n   * @returns void\n   */\n\n  clear(): void {\n    this._buckets = [new Array(this._bucketSize)];\n    this._bucketCount = 1;\n    this._bucketFirst = this._bucketLast = this._length = 0;\n    this._firstInBucket = this._lastInBucket = this._bucketSize >> 1;\n  }\n\n  /**\n   * Get the element at a given position.\n   * @remarks Time O(1), Space O(1)\n   * @param pos - Zero-based position from the front.\n   * @returns Element or undefined.\n   */\n\n  at(pos: number): E | undefined {\n    if (pos < 0 || pos >= this._length) return undefined;\n    const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);\n    return this._buckets[bucketIndex][indexInBucket];\n  }\n\n  /**\n   * Replace the element at a given position.\n   * @remarks Time O(1), Space O(1)\n   * @param pos - Zero-based position from the front.\n   * @param element - New element value.\n   * @returns True if updated.\n   */\n\n  setAt(pos: number, element: E): boolean {\n    rangeCheck(pos, 0, this._length - 1);\n    const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);\n    this._buckets[bucketIndex][indexInBucket] = element;\n    return true;\n  }\n\n  /**\n   * Insert repeated copies of an element at a position.\n   * @remarks Time O(N), Space O(1)\n   * @param pos - Zero-based position from the front.\n   * @param element - Element to insert.\n   * @param [num] - Number of times to insert (default 1).\n   * @returns True if inserted.\n   */\n\n  addAt(pos: number, element: E, num = 1): boolean {\n    const length = this._length;\n    rangeCheck(pos, 0, length);\n    if (pos === 0) {\n      while (num--) this.unshift(element);\n    } else if (pos === this._length) {\n      while (num--) this.push(element);\n    } else {\n      const arr: E[] = [];\n      for (let i = pos; i < this._length; ++i) {\n        const v = this.at(i);\n        if (v !== undefined) arr.push(v);\n      }\n      this.cut(pos - 1, true);\n      for (let i = 0; i < num; ++i) this.push(element);\n      for (let i = 0; i < arr.length; ++i) this.push(arr[i]);\n    }\n    return true;\n  }\n\n  /**\n   * Cut the deque to keep items up to index; optionally mutate in-place.\n   * @remarks Time O(N), Space O(1)\n   * @param pos - Last index to keep.\n   * @param [isCutSelf] - When true, mutate this deque; otherwise return a new deque.\n   * @returns This deque if in-place; otherwise a new deque of the prefix.\n   */\n\n  cut(pos: number, isCutSelf = false): Deque<E> {\n    if (isCutSelf) {\n      if (pos < 0) {\n        this.clear();\n        return this;\n      }\n      const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);\n      this._bucketLast = bucketIndex;\n      this._lastInBucket = indexInBucket;\n      this._length = pos + 1;\n      return this;\n    } else {\n      const newDeque = this._createInstance({ toElementFn: this._toElementFn, maxLen: this._maxLen });\n      newDeque._setBucketSize(this._bucketSize);\n      for (let i = 0; i <= pos; i++) {\n        const v = this.at(i);\n        if (v !== undefined) newDeque.push(v);\n      }\n\n      return newDeque;\n    }\n  }\n\n  /**\n   * Remove and/or insert elements at a position (array-like behavior).\n   * @remarks Time O(N + M), Space O(M)\n   * @param start - Start index (clamped to [0, length]).\n   * @param [deleteCount] - Number of elements to remove (default: length - start).\n   * @param [items] - Elements to insert after `start`.\n   * @returns A new deque containing the removed elements (typed as `this`).\n   */\n\n  override splice(start: number, deleteCount: number = this._length - start, ...items: E[]): this {\n    rangeCheck(start, 0, this._length);\n    if (deleteCount < 0) deleteCount = 0;\n    if (start + deleteCount > this._length) deleteCount = this._length - start;\n\n    const removed = this._createInstance({ toElementFn: this._toElementFn, maxLen: this._maxLen });\n    removed._setBucketSize(this._bucketSize);\n    for (let i = 0; i < deleteCount; i++) {\n      const v = this.at(start + i);\n      if (v !== undefined) removed.push(v);\n    }\n\n    const tail: E[] = [];\n    for (let i = start + deleteCount; i < this._length; i++) {\n      const v = this.at(i);\n      if (v !== undefined) tail.push(v);\n    }\n\n    this.cut(start - 1, true);\n\n    for (const it of items) this.push(it);\n\n    for (const v of tail) this.push(v);\n\n    return removed as unknown as this;\n  }\n\n  /**\n   * Cut the deque to keep items from index onward; optionally mutate in-place.\n   * @remarks Time O(N), Space O(1)\n   * @param pos - First index to keep.\n   * @param [isCutSelf] - When true, mutate this deque; otherwise return a new deque.\n   * @returns This deque if in-place; otherwise a new deque of the suffix.\n   */\n\n  cutRest(pos: number, isCutSelf = false): Deque<E> {\n    if (isCutSelf) {\n      if (pos < 0) {\n        return this;\n      }\n      const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);\n      this._bucketFirst = bucketIndex;\n      this._firstInBucket = indexInBucket;\n      this._length = this._length - pos;\n      return this;\n    } else {\n      const newDeque = this._createInstance({ toElementFn: this._toElementFn, maxLen: this._maxLen });\n      newDeque._setBucketSize(this._bucketSize);\n      if (pos < 0) pos = 0;\n      for (let i = pos; i < this._length; i++) {\n        const v = this.at(i);\n        if (v !== undefined) newDeque.push(v);\n      }\n      return newDeque;\n    }\n  }\n\n  /**\n   * Delete the element at a given position.\n   * @remarks Time O(N), Space O(1)\n   * @param pos - Zero-based position from the front.\n   * @returns Removed element or undefined.\n   */\n\n  deleteAt(pos: number): E | undefined {\n    rangeCheck(pos, 0, this._length - 1);\n\n    let deleted: E | undefined;\n    if (pos === 0) {\n      return this.shift();\n    } else if (pos === this._length - 1) {\n      deleted = this.last;\n      this.pop();\n      return deleted;\n    } else {\n      const length = this._length - 1;\n      const { bucketIndex: targetBucket, indexInBucket: targetPointer } = this._getBucketAndPosition(pos);\n      deleted = this._buckets[targetBucket][targetPointer];\n\n      for (let i = pos; i < length; i++) {\n        const { bucketIndex: curBucket, indexInBucket: curPointer } = this._getBucketAndPosition(i);\n        const { bucketIndex: nextBucket, indexInBucket: nextPointer } = this._getBucketAndPosition(i + 1);\n        this._buckets[curBucket][curPointer] = this._buckets[nextBucket][nextPointer];\n      }\n\n      this.pop();\n      return deleted;\n    }\n  }\n\n  /**\n   * Delete the first occurrence of a value.\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 size = this._length;\n    if (size === 0) return false;\n    let i = 0;\n    let index = 0;\n    while (i < size) {\n      const oldElement = this.at(i);\n      if (!this._equals(oldElement as E, element)) {\n        this.setAt(index, oldElement!);\n        index += 1;\n      }\n      i += 1;\n    }\n    this.cut(index - 1, true);\n    return true;\n  }\n\n  /**\n   * Delete the first element matching a predicate.\n   * @remarks Time O(N), Space O(1)\n   * @param predicate - Function (value, index, deque) → boolean.\n   * @returns True if a match was removed.\n   */\n\n  deleteWhere(predicate: (value: E, index: number, deque: this) => boolean): boolean {\n    for (let i = 0; i < this._length; i++) {\n      const v = this.at(i);\n      if (predicate(v as E, i, this)) {\n        this.deleteAt(i);\n        return true;\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Set the equality comparator used by delete operations.\n   * @remarks Time O(1), Space O(1)\n   * @param equals - Equality predicate (a, b) → boolean.\n   * @returns This deque.\n   */\n\n  setEquality(equals: (a: E, b: E) => boolean): this {\n    this._equals = equals;\n    return this;\n  }\n\n  /**\n   * Reverse the deque by reversing buckets and pointers.\n   * @remarks Time O(N), Space O(N)\n   * @returns This deque.\n   */\n\n  reverse(): this {\n    this._buckets.reverse().forEach(function (bucket) {\n      bucket.reverse();\n    });\n    const { _bucketFirst, _bucketLast, _firstInBucket, _lastInBucket } = this;\n    this._bucketFirst = this._bucketCount - _bucketLast - 1;\n    this._bucketLast = this._bucketCount - _bucketFirst - 1;\n    this._firstInBucket = this._bucketSize - _lastInBucket - 1;\n    this._lastInBucket = this._bucketSize - _firstInBucket - 1;\n    return this;\n  }\n\n  /**\n   * Deduplicate consecutive equal elements in-place.\n   * @remarks Time O(N), Space O(1)\n   * @returns This deque.\n   */\n\n  unique(): this {\n    if (this._length <= 1) {\n      return this;\n    }\n    let index = 1;\n    let prev = this.at(0);\n    for (let i = 1; i < this._length; ++i) {\n      const cur = this.at(i);\n      if (!this._equals(cur as E, prev as E)) {\n        prev = cur;\n        this.setAt(index++, cur as E);\n      }\n    }\n    this.cut(index - 1, true);\n    return this;\n  }\n\n  /**\n   * Trim unused buckets to fit exactly the active range.\n   * @remarks Time O(N), Space O(1)\n   * @returns void\n   */\n\n  shrinkToFit(): void {\n    if (this._length === 0) return;\n    const newBuckets = [] as E[][];\n    if (this._bucketFirst === this._bucketLast) return;\n    else if (this._bucketFirst < this._bucketLast) {\n      for (let i = this._bucketFirst; i <= this._bucketLast; ++i) {\n        newBuckets.push(this._buckets[i]);\n      }\n    } else {\n      for (let i = this._bucketFirst; i < this._bucketCount; ++i) {\n        newBuckets.push(this._buckets[i]);\n      }\n      for (let i = 0; i <= this._bucketLast; ++i) {\n        newBuckets.push(this._buckets[i]);\n      }\n    }\n    this._bucketFirst = 0;\n    this._bucketLast = newBuckets.length - 1;\n    this._buckets = newBuckets;\n  }\n\n  /**\n   * Deep clone this deque, preserving options.\n   * @remarks Time O(N), Space O(N)\n   * @returns A new deque with the same content and options.\n   */\n\n  clone(): this {\n    return this._createLike<E, R>(this, {\n      bucketSize: this.bucketSize,\n      toElementFn: this.toElementFn,\n      maxLen: this._maxLen\n    }) as this;\n  }\n\n  /**\n   * Filter elements into a new deque of the same class.\n   * @remarks Time O(N), Space O(N)\n   * @param predicate - Predicate (value, index, deque) → boolean to keep element.\n   * @param [thisArg] - Value for `this` inside the predicate.\n   * @returns A new deque with kept elements.\n   */\n\n  filter(predicate: ElementCallback<E, R, boolean>, thisArg?: any): this {\n    const out = this._createInstance({ toElementFn: this.toElementFn, maxLen: this._maxLen });\n    out._setBucketSize(this._bucketSize);\n    let index = 0;\n    for (const el of this) {\n      if (predicate.call(thisArg, el, index, this)) out.push(el);\n      index++;\n    }\n    return out;\n  }\n\n  /**\n   * Map elements into a new deque of the same element type.\n   * @remarks Time O(N), Space O(N)\n   * @param callback - Mapping function (value, index, deque) → newValue.\n   * @param [thisArg] - Value for `this` inside the callback.\n   * @returns A new deque with mapped values.\n   */\n\n  mapSame(callback: ElementCallback<E, R, E>, thisArg?: any): this {\n    const out = this._createInstance({ toElementFn: this._toElementFn, maxLen: this._maxLen });\n    out._setBucketSize(this._bucketSize);\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 elements into a new deque (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, deque) → newElement.\n   * @param [options] - Options for the output deque (e.g., bucketSize, toElementFn, maxLen).\n   * @param [thisArg] - Value for `this` inside the callback.\n   * @returns A new Deque with mapped elements.\n   */\n\n  map<EM, RM>(\n    callback: ElementCallback<E, R, EM>,\n    options?: IterableElementBaseOptions<EM, RM>,\n    thisArg?: any\n  ): Deque<EM, RM> {\n    const out = this._createLike<EM, RM>([], {\n      ...(options ?? {}),\n      bucketSize: this._bucketSize,\n      maxLen: this._maxLen\n    }) as Deque<EM, RM>;\n    let index = 0;\n    for (const el of this) {\n      const mv = thisArg === undefined ? callback(el, index, this) : callback.call(thisArg, el, index, this);\n      out.push(mv);\n      index++;\n    }\n    return out;\n  }\n\n  /**\n   * (Protected) Set the internal bucket size.\n   * @remarks Time O(1), Space O(1)\n   * @param size - Bucket capacity to assign.\n   * @returns void\n   */\n\n  protected _setBucketSize(size: number): void {\n    this._bucketSize = size;\n\n    // When adjusting bucketSize on a freshly created empty deque (common in helpers like cut/splice/clone),\n    // we must also realign internal pointers/buckets to avoid `_getBucketAndPosition` producing out-of-range\n    // indices based on the previous bucketSize.\n    if (this._length === 0) {\n      this._buckets = [new Array(this._bucketSize)];\n      this._bucketCount = 1;\n      this._bucketFirst = this._bucketLast = 0;\n      this._firstInBucket = this._lastInBucket = this._bucketSize >> 1;\n    }\n  }\n\n  /**\n   * (Protected) Iterate elements from front to back.\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._length; ++i) {\n      const v = this.at(i);\n      if (v !== undefined) yield v;\n    }\n  }\n\n  /**\n   * (Protected) Reallocate buckets to make room near the ends.\n   * @remarks Time O(N), Space O(N)\n   * @param [needBucketNum] - How many extra buckets to add; defaults to half of current.\n   * @returns void\n   */\n\n  protected _reallocate(needBucketNum?: number) {\n    const newBuckets = [] as E[][];\n    const addBucketNum = needBucketNum || this._bucketCount >> 1 || 1;\n    for (let i = 0; i < addBucketNum; ++i) {\n      newBuckets[i] = new Array(this._bucketSize);\n    }\n    for (let i = this._bucketFirst; i < this._bucketCount; ++i) {\n      newBuckets[newBuckets.length] = this._buckets[i];\n    }\n    for (let i = 0; i < this._bucketLast; ++i) {\n      newBuckets[newBuckets.length] = this._buckets[i];\n    }\n    newBuckets[newBuckets.length] = [...this._buckets[this._bucketLast]];\n    this._bucketFirst = addBucketNum;\n    this._bucketLast = newBuckets.length - 1;\n    for (let i = 0; i < addBucketNum; ++i) {\n      newBuckets[newBuckets.length] = new Array(this._bucketSize);\n    }\n    this._buckets = newBuckets;\n    this._bucketCount = newBuckets.length;\n  }\n\n  /**\n   * (Protected) Translate a logical position to bucket/offset.\n   * @remarks Time O(1), Space O(1)\n   * @param pos - Zero-based position.\n   * @returns An object containing bucketIndex and indexInBucket.\n   */\n\n  protected _getBucketAndPosition(pos: number) {\n    let bucketIndex: number;\n    let indexInBucket: number;\n\n    const overallIndex = this._firstInBucket + pos;\n    bucketIndex = this._bucketFirst + Math.floor(overallIndex / this._bucketSize);\n\n    if (bucketIndex >= this._bucketCount) {\n      bucketIndex -= this._bucketCount;\n    }\n\n    indexInBucket = ((overallIndex + 1) % this._bucketSize) - 1;\n    if (indexInBucket < 0) {\n      indexInBucket = this._bucketSize - 1;\n    }\n\n    return { bucketIndex, indexInBucket };\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 deque instance.\n   */\n\n  protected override _createInstance(options?: LinearBaseOptions<E, R>): this {\n    const Ctor = this.constructor as new (\n      elements?: IterableWithSizeOrLength<E> | IterableWithSizeOrLength<R>,\n      options?: DequeOptions<E, R>\n    ) => this;\n    return new Ctor([], options as DequeOptions<E, R> | undefined);\n  }\n\n  /**\n   * (Protected) Create a like-kind deque seeded by elements.\n   * @remarks Time O(N), Space O(N)\n   * @template T\n   * @template RR\n   * @param [elements] - Iterable used to seed the new deque.\n   * @param [options] - Options forwarded to the constructor.\n   * @returns A like-kind Deque instance.\n   */\n\n  protected _createLike<T = E, RR = R>(\n    elements: IterableWithSizeOrLength<T> | IterableWithSizeOrLength<RR> = [],\n    options?: DequeOptions<T, RR>\n  ): any {\n    const Ctor = this.constructor as new (\n      elements?: IterableWithSizeOrLength<T> | IterableWithSizeOrLength<RR>,\n      options?: DequeOptions<T, RR>\n    ) => any;\n    return new Ctor(elements, options);\n  }\n\n  /**\n   * (Protected) Iterate elements from back to front.\n   * @remarks Time O(N), Space O(1)\n   * @returns Iterator of elements.\n   */\n\n  protected *_getReverseIterator(): IterableIterator<E> {\n    for (let i = this._length - 1; i > -1; i--) {\n      const v = this.at(i);\n      if (v !== undefined) yield v;\n    }\n  }\n}\n","export 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"]}