npm - deque-typed - Versions diffs - 2.1.0 → 2.1.2 - Mend

deque-typed 2.1.0 → 2.1.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (281) hide show

package/dist/cjs/index.cjs.map ADDED Viewed

@@ -0,0 +1 @@

+ {"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(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(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 protected 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 multiple containers of the same species.\n * @param items - Other lists to append.\n * @returns New container with combined elements (`this` type).\n * @remarks Time O(sum(length)), Space O(sum(length))\n */\n concat(...items: this[]): this;\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(callbackfn: ReduceLinearCallback<E, U>, initialValue: U): U;\n\n reduceRight(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 protected 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: LinearBase<E, R>[]): this;\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(callbackfn: ReduceLinearCallback<E, U>, initialValue: U): U;\n\n override reduceRight(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 * // prize roulette\n * class PrizeRoulette {\n * private deque: Deque<string>;\n *\n * constructor(prizes: string[]) {\n * // Initialize the deque with prizes\n * this.deque = new Deque<string>(prizes);\n * }\n *\n * // Rotate clockwise to the right (forward)\n * rotateClockwise(steps: number): void {\n * const n = this.deque.length;\n * if (n === 0) return;\n *\n * for (let i = 0; i < steps; i++) {\n * const last = this.deque.pop(); // Remove the last element\n * this.deque.unshift(last!); // Add it to the front\n * }\n * }\n *\n * // Rotate counterclockwise to the left (backward)\n * rotateCounterClockwise(steps: number): void {\n * const n = this.deque.length;\n * if (n === 0) return;\n *\n * for (let i = 0; i < steps; i++) {\n * const first = this.deque.shift(); // Remove the first element\n * this.deque.push(first!); // Add it to the back\n * }\n * }\n *\n * // Display the current prize at the head\n * display() {\n * return this.deque.first;\n * }\n * }\n *\n * // Example usage\n * const prizes = ['Car', 'Bike', 'Laptop', 'Phone', 'Watch', 'Headphones']; // Initialize the prize list\n * const roulette = new PrizeRoulette(prizes);\n *\n * // Display the initial state\n * console.log(roulette.display()); // 'Car' // Car\n *\n * // Rotate clockwise by 3 steps\n * roulette.rotateClockwise(3);\n * console.log(roulette.display()); // 'Phone' // Phone\n *\n * // Rotate counterclockwise by 2 steps\n * roulette.rotateCounterClockwise(2);\n * console.log(roulette.display()); // 'Headphones'\n * @example\n * // sliding window\n * // Maximum function of sliding window\n * function maxSlidingWindow(nums: number[], k: number): number[] {\n * const n = nums.length;\n * if (n * k === 0) return [];\n *\n * const deq = new Deque<number>();\n * const result: number[] = [];\n *\n * for (let i = 0; i < n; i++) {\n * // Delete indexes in the queue that are not within the window range\n * if (deq.length > 0 && deq.first! === i - k) {\n * deq.shift();\n * }\n *\n * // Remove all indices less than the current value from the tail of the queue\n * while (deq.length > 0 && nums[deq.last!] < nums[i]) {\n * deq.pop();\n * }\n *\n * // Add the current index to the end of the queue\n * deq.push(i);\n *\n * // Add the maximum value of the window to the results\n * if (i >= k - 1) {\n * result.push(nums[deq.first!]);\n * }\n * }\n *\n * return result;\n * }\n *\n * const nums = [1, 3, -1, -3, 5, 3, 6, 7];\n * const k = 3;\n * console.log(maxSlidingWindow(nums, k)); // [3, 3, 5, 5, 6, 7]\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\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","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"]}