deque-typed 2.1.0 → 2.1.2

package/dist/cjs/index.cjs

@@ -0,0 +1,1223 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/utils/utils.ts
+var rangeCheck = /* @__PURE__ */ __name((index, min, max, message = "Index out of bounds.") => {
+  if (index < min || index > max) throw new RangeError(message);
+}, "rangeCheck");
+var calcMinUnitsRequired = /* @__PURE__ */ __name((totalQuantity, unitSize) => Math.floor((totalQuantity + unitSize - 1) / unitSize), "calcMinUnitsRequired");
+function isPrimitiveComparable(value) {
+  const valueType = typeof value;
+  if (valueType === "number") return true;
+  return valueType === "bigint" || valueType === "string" || valueType === "boolean";
+}
+__name(isPrimitiveComparable, "isPrimitiveComparable");
+function tryObjectToPrimitive(obj) {
+  if (typeof obj.valueOf === "function") {
+    const valueOfResult = obj.valueOf();
+    if (valueOfResult !== obj) {
+      if (isPrimitiveComparable(valueOfResult)) return valueOfResult;
+      if (typeof valueOfResult === "object" && valueOfResult !== null) return tryObjectToPrimitive(valueOfResult);
+    }
+  }
+  if (typeof obj.toString === "function") {
+    const stringResult = obj.toString();
+    if (stringResult !== "[object Object]") return stringResult;
+  }
+  return null;
+}
+__name(tryObjectToPrimitive, "tryObjectToPrimitive");
+function isComparable(value, isForceObjectComparable = false) {
+  if (value === null || value === void 0) return false;
+  if (isPrimitiveComparable(value)) return true;
+  if (typeof value !== "object") return false;
+  if (value instanceof Date) return true;
+  if (isForceObjectComparable) return true;
+  const comparableValue = tryObjectToPrimitive(value);
+  if (comparableValue === null || comparableValue === void 0) return false;
+  return isPrimitiveComparable(comparableValue);
+}
+__name(isComparable, "isComparable");
+
+// src/data-structures/base/iterable-element-base.ts
+var _IterableElementBase = class _IterableElementBase {
+  /**
+   * Create a new iterable base.
+   *
+   * @param options Optional behavior overrides. When provided, a `toElementFn`
+   * is used to convert a raw element (`R`) into a public element (`E`).
+   *
+   * @remarks
+   * Time O(1), Space O(1).
+   */
+  constructor(options) {
+    /**
+     * The converter used to transform a raw element (`R`) into a public element (`E`).
+     *
+     * @remarks
+     * Time O(1), Space O(1).
+     */
+    __publicField(this, "_toElementFn");
+    if (options) {
+      const { toElementFn } = options;
+      if (typeof toElementFn === "function") this._toElementFn = toElementFn;
+      else if (toElementFn) throw new TypeError("toElementFn must be a function type");
+    }
+  }
+  /**
+   * Exposes the current `toElementFn`, if configured.
+   *
+   * @returns The converter function or `undefined` when not set.
+   * @remarks
+   * Time O(1), Space O(1).
+   */
+  get toElementFn() {
+    return this._toElementFn;
+  }
+  /**
+   * Returns an iterator over the structure's elements.
+   *
+   * @param args Optional iterator arguments forwarded to the internal iterator.
+   * @returns An `IterableIterator<E>` that yields the elements in traversal order.
+   *
+   * @remarks
+   * Producing the iterator is O(1); consuming the entire iterator is Time O(n) with O(1) extra space.
+   */
+  *[Symbol.iterator](...args) {
+    yield* this._getIterator(...args);
+  }
+  /**
+   * Returns an iterator over the values (alias of the default iterator).
+   *
+   * @returns An `IterableIterator<E>` over all elements.
+   * @remarks
+   * Creating the iterator is O(1); full iteration is Time O(n), Space O(1).
+   */
+  *values() {
+    for (const item of this) yield item;
+  }
+  /**
+   * Tests whether all elements satisfy the predicate.
+   *
+   * @template TReturn
+   * @param predicate Function invoked for each element with signature `(value, index, self)`.
+   * @param thisArg Optional `this` binding for the predicate.
+   * @returns `true` if every element passes; otherwise `false`.
+   *
+   * @remarks
+   * Time O(n) in the worst case; may exit early when the first failure is found. Space O(1).
+   */
+  every(predicate, thisArg) {
+    let index = 0;
+    for (const item of this) {
+      if (thisArg === void 0) {
+        if (!predicate(item, index++, this)) return false;
+      } else {
+        const fn = predicate;
+        if (!fn.call(thisArg, item, index++, this)) return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Tests whether at least one element satisfies the predicate.
+   *
+   * @param predicate Function invoked for each element with signature `(value, index, self)`.
+   * @param thisArg Optional `this` binding for the predicate.
+   * @returns `true` if any element passes; otherwise `false`.
+   *
+   * @remarks
+   * Time O(n) in the worst case; may exit early on first success. Space O(1).
+   */
+  some(predicate, thisArg) {
+    let index = 0;
+    for (const item of this) {
+      if (thisArg === void 0) {
+        if (predicate(item, index++, this)) return true;
+      } else {
+        const fn = predicate;
+        if (fn.call(thisArg, item, index++, this)) return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Invokes a callback for each element in iteration order.
+   *
+   * @param callbackfn Function invoked per element with signature `(value, index, self)`.
+   * @param thisArg Optional `this` binding for the callback.
+   * @returns `void`.
+   *
+   * @remarks
+   * Time O(n), Space O(1).
+   */
+  forEach(callbackfn, thisArg) {
+    let index = 0;
+    for (const item of this) {
+      if (thisArg === void 0) {
+        callbackfn(item, index++, this);
+      } else {
+        const fn = callbackfn;
+        fn.call(thisArg, item, index++, this);
+      }
+    }
+  }
+  // Implementation signature
+  find(predicate, thisArg) {
+    let index = 0;
+    for (const item of this) {
+      if (thisArg === void 0) {
+        if (predicate(item, index++, this)) return item;
+      } else {
+        const fn = predicate;
+        if (fn.call(thisArg, item, index++, this)) return item;
+      }
+    }
+    return;
+  }
+  /**
+   * Checks whether a strictly-equal element exists in the structure.
+   *
+   * @param element The element to test with `===` equality.
+   * @returns `true` if an equal element is found; otherwise `false`.
+   *
+   * @remarks
+   * Time O(n) in the worst case. Space O(1).
+   */
+  has(element) {
+    for (const ele of this) if (ele === element) return true;
+    return false;
+  }
+  /**
+   * Reduces all elements to a single accumulated value.
+   *
+   * @overload
+   * @param callbackfn Reducer of signature `(acc, value, index, self) => nextAcc`. The first element is used as the initial accumulator.
+   * @returns The final accumulated value typed as `E`.
+   *
+   * @overload
+   * @param callbackfn Reducer of signature `(acc, value, index, self) => nextAcc`.
+   * @param initialValue The initial accumulator value of type `E`.
+   * @returns The final accumulated value typed as `E`.
+   *
+   * @overload
+   * @template U The accumulator type when it differs from `E`.
+   * @param callbackfn Reducer of signature `(acc: U, value, index, self) => U`.
+   * @param initialValue The initial accumulator value of type `U`.
+   * @returns The final accumulated value typed as `U`.
+   *
+   * @remarks
+   * Time O(n), Space O(1). Throws if called on an empty structure without `initialValue`.
+   */
+  reduce(callbackfn, initialValue) {
+    let index = 0;
+    const iter = this[Symbol.iterator]();
+    let acc;
+    if (arguments.length >= 2) {
+      acc = initialValue;
+    } else {
+      const first = iter.next();
+      if (first.done) throw new TypeError("Reduce of empty structure with no initial value");
+      acc = first.value;
+      index = 1;
+    }
+    for (const value of iter) {
+      acc = callbackfn(acc, value, index++, this);
+    }
+    return acc;
+  }
+  /**
+   * Materializes the elements into a new array.
+   *
+   * @returns A shallow array copy of the iteration order.
+   * @remarks
+   * Time O(n), Space O(n).
+   */
+  toArray() {
+    return [...this];
+  }
+  /**
+   * Returns a representation of the structure suitable for quick visualization.
+   * Defaults to an array of elements; subclasses may override to provide richer visuals.
+   *
+   * @returns A visual representation (array by default).
+   * @remarks
+   * Time O(n), Space O(n).
+   */
+  toVisual() {
+    return [...this];
+  }
+  /**
+   * Prints `toVisual()` to the console. Intended for quick debugging.
+   *
+   * @returns `void`.
+   * @remarks
+   * Time O(n) due to materialization, Space O(n) for the intermediate representation.
+   */
+  print() {
+    console.log(this.toVisual());
+  }
+};
+__name(_IterableElementBase, "IterableElementBase");
+var IterableElementBase = _IterableElementBase;
+
+// src/data-structures/base/linear-base.ts
+var _LinearBase = class _LinearBase extends IterableElementBase {
+  /**
+   * Construct a linear container with runtime options.
+   * @param options - `{ maxLen?, ... }` bounds/behavior options.
+   * @remarks Time O(1), Space O(1)
+   */
+  constructor(options) {
+    super(options);
+    __publicField(this, "_maxLen", -1);
+    if (options) {
+      const { maxLen } = options;
+      if (typeof maxLen === "number" && maxLen > 0 && maxLen % 1 === 0) this._maxLen = maxLen;
+    }
+  }
+  /**
+   * Upper bound for length (if positive), or `-1` when unbounded.
+   * @returns Maximum allowed length.
+   * @remarks Time O(1), Space O(1)
+   */
+  get maxLen() {
+    return this._maxLen;
+  }
+  /**
+   * First index of a value from the left.
+   * @param searchElement - Value to match.
+   * @param fromIndex - Start position (supports negative index).
+   * @returns Index or `-1` if not found.
+   * @remarks Time O(n), Space O(1)
+   */
+  indexOf(searchElement, fromIndex = 0) {
+    if (this.length === 0) return -1;
+    if (fromIndex < 0) fromIndex = this.length + fromIndex;
+    if (fromIndex < 0) fromIndex = 0;
+    for (let i = fromIndex; i < this.length; i++) {
+      const element = this.at(i);
+      if (element === searchElement) return i;
+    }
+    return -1;
+  }
+  /**
+   * Last index of a value from the right.
+   * @param searchElement - Value to match.
+   * @param fromIndex - Start position (supports negative index).
+   * @returns Index or `-1` if not found.
+   * @remarks Time O(n), Space O(1)
+   */
+  lastIndexOf(searchElement, fromIndex = this.length - 1) {
+    if (this.length === 0) return -1;
+    if (fromIndex >= this.length) fromIndex = this.length - 1;
+    if (fromIndex < 0) fromIndex = this.length + fromIndex;
+    for (let i = fromIndex; i >= 0; i--) {
+      const element = this.at(i);
+      if (element === searchElement) return i;
+    }
+    return -1;
+  }
+  /**
+   * Find the first index matching a predicate.
+   * @param predicate - `(element, index, self) => boolean`.
+   * @param thisArg - Optional `this` for callback.
+   * @returns Index or `-1`.
+   * @remarks Time O(n), Space O(1)
+   */
+  findIndex(predicate, thisArg) {
+    for (let i = 0; i < this.length; i++) {
+      const item = this.at(i);
+      if (item !== void 0 && predicate.call(thisArg, item, i, this)) return i;
+    }
+    return -1;
+  }
+  /**
+   * Concatenate elements and/or containers.
+   * @param items - Elements or other containers.
+   * @returns New container with combined elements (`this` type).
+   * @remarks Time O(sum(length)), Space O(sum(length))
+   */
+  concat(...items) {
+    const newList = this.clone();
+    for (const item of items) {
+      if (item instanceof _LinearBase) {
+        newList.pushMany(item);
+      } else {
+        newList.push(item);
+      }
+    }
+    return newList;
+  }
+  /**
+   * In-place stable order via array sort semantics.
+   * @param compareFn - Comparator `(a, b) => number`.
+   * @returns This container.
+   * @remarks Time O(n log n), Space O(n) (materializes to array temporarily)
+   */
+  sort(compareFn) {
+    const arr = this.toArray();
+    arr.sort(compareFn);
+    this.clear();
+    for (const item of arr) this.push(item);
+    return this;
+  }
+  /**
+   * Remove and/or insert elements at a position (array-compatible).
+   * @param start - Start index (supports negative index).
+   * @param deleteCount - How many to remove.
+   * @param items - Elements to insert.
+   * @returns Removed elements as a new list (`this` type).
+   * @remarks Time O(n + m), Space O(min(n, m)) where `m = items.length`
+   */
+  splice(start, deleteCount = 0, ...items) {
+    const removedList = this._createInstance();
+    start = start < 0 ? this.length + start : start;
+    start = Math.max(0, Math.min(start, this.length));
+    deleteCount = Math.max(0, Math.min(deleteCount, this.length - start));
+    for (let i = 0; i < deleteCount; i++) {
+      const removed = this.deleteAt(start);
+      if (removed !== void 0) {
+        removedList.push(removed);
+      }
+    }
+    for (let i = 0; i < items.length; i++) {
+      this.addAt(start + i, items[i]);
+    }
+    return removedList;
+  }
+  /**
+   * Join all elements into a string.
+   * @param separator - Separator string.
+   * @returns Concatenated string.
+   * @remarks Time O(n), Space O(n)
+   */
+  join(separator = ",") {
+    return this.toArray().join(separator);
+  }
+  /**
+   * Snapshot elements into a reversed array.
+   * @returns New reversed array.
+   * @remarks Time O(n), Space O(n)
+   */
+  toReversedArray() {
+    const array = [];
+    for (let i = this.length - 1; i >= 0; i--) {
+      array.push(this.at(i));
+    }
+    return array;
+  }
+  reduceRight(callbackfn, initialValue) {
+    let accumulator = initialValue != null ? initialValue : 0;
+    for (let i = this.length - 1; i >= 0; i--) {
+      accumulator = callbackfn(accumulator, this.at(i), i, this);
+    }
+    return accumulator;
+  }
+  /**
+   * Create a shallow copy of a subrange.
+   * @param start - Inclusive start (supports negative index).
+   * @param end - Exclusive end (supports negative index).
+   * @returns New list with the range (`this` type).
+   * @remarks Time O(n), Space O(n)
+   */
+  slice(start = 0, end = this.length) {
+    start = start < 0 ? this.length + start : start;
+    end = end < 0 ? this.length + end : end;
+    const newList = this._createInstance();
+    for (let i = start; i < end; i++) {
+      newList.push(this.at(i));
+    }
+    return newList;
+  }
+  /**
+   * Fill a range with a value.
+   * @param value - Value to set.
+   * @param start - Inclusive start.
+   * @param end - Exclusive end.
+   * @returns This list.
+   * @remarks Time O(n), Space O(1)
+   */
+  fill(value, start = 0, end = this.length) {
+    start = start < 0 ? this.length + start : start;
+    end = end < 0 ? this.length + end : end;
+    if (start < 0) start = 0;
+    if (end > this.length) end = this.length;
+    if (start >= end) return this;
+    for (let i = start; i < end; i++) {
+      this.setAt(i, value);
+    }
+    return this;
+  }
+};
+__name(_LinearBase, "LinearBase");
+var LinearBase = _LinearBase;
+
+// src/data-structures/queue/deque.ts
+var _Deque = class _Deque extends LinearBase {
+  /**
+   * Create a Deque and optionally bulk-insert elements.
+   * @remarks Time O(N), Space O(N)
+   * @param [elements] - Iterable (or iterable-like) of elements/records to insert.
+   * @param [options] - Options such as bucketSize, toElementFn, and maxLen.
+   * @returns New Deque instance.
+   */
+  constructor(elements = [], options) {
+    super(options);
+    __publicField(this, "_equals", Object.is);
+    __publicField(this, "_bucketSize", 1 << 12);
+    __publicField(this, "_bucketFirst", 0);
+    __publicField(this, "_firstInBucket", 0);
+    __publicField(this, "_bucketLast", 0);
+    __publicField(this, "_lastInBucket", 0);
+    __publicField(this, "_bucketCount", 0);
+    __publicField(this, "_buckets", []);
+    __publicField(this, "_length", 0);
+    if (options) {
+      const { bucketSize } = options;
+      if (typeof bucketSize === "number") this._bucketSize = bucketSize;
+    }
+    let _size;
+    if ("length" in elements) {
+      _size = typeof elements.length === "function" ? elements.length() : elements.length;
+    } else {
+      _size = typeof elements.size === "function" ? elements.size() : elements.size;
+    }
+    this._bucketCount = calcMinUnitsRequired(_size, this._bucketSize) || 1;
+    for (let i = 0; i < this._bucketCount; ++i) {
+      this._buckets.push(new Array(this._bucketSize));
+    }
+    const needBucketNum = calcMinUnitsRequired(_size, this._bucketSize);
+    this._bucketFirst = this._bucketLast = (this._bucketCount >> 1) - (needBucketNum >> 1);
+    this._firstInBucket = this._lastInBucket = this._bucketSize - _size % this._bucketSize >> 1;
+    this.pushMany(elements);
+  }
+  /**
+   * Get the current bucket size.
+   * @remarks Time O(1), Space O(1)
+   * @returns Bucket capacity per bucket.
+   */
+  get bucketSize() {
+    return this._bucketSize;
+  }
+  /**
+   * Get the index of the first bucket in use.
+   * @remarks Time O(1), Space O(1)
+   * @returns Zero-based bucket index.
+   */
+  get bucketFirst() {
+    return this._bucketFirst;
+  }
+  /**
+   * Get the index inside the first bucket.
+   * @remarks Time O(1), Space O(1)
+   * @returns Zero-based index within the first bucket.
+   */
+  get firstInBucket() {
+    return this._firstInBucket;
+  }
+  /**
+   * Get the index of the last bucket in use.
+   * @remarks Time O(1), Space O(1)
+   * @returns Zero-based bucket index.
+   */
+  get bucketLast() {
+    return this._bucketLast;
+  }
+  /**
+   * Get the index inside the last bucket.
+   * @remarks Time O(1), Space O(1)
+   * @returns Zero-based index within the last bucket.
+   */
+  get lastInBucket() {
+    return this._lastInBucket;
+  }
+  /**
+   * Get the number of buckets allocated.
+   * @remarks Time O(1), Space O(1)
+   * @returns Bucket count.
+   */
+  get bucketCount() {
+    return this._bucketCount;
+  }
+  /**
+   * Get the internal buckets array.
+   * @remarks Time O(1), Space O(1)
+   * @returns Array of buckets storing values.
+   */
+  get buckets() {
+    return this._buckets;
+  }
+  /**
+   * Get the number of elements in the deque.
+   * @remarks Time O(1), Space O(1)
+   * @returns Current length.
+   */
+  get length() {
+    return this._length;
+  }
+  /**
+   * Get the first element without removing it.
+   * @remarks Time O(1), Space O(1)
+   * @returns First element or undefined.
+   */
+  get first() {
+    if (this._length === 0) return;
+    return this._buckets[this._bucketFirst][this._firstInBucket];
+  }
+  /**
+   * Get the last element without removing it.
+   * @remarks Time O(1), Space O(1)
+   * @returns Last element or undefined.
+   */
+  get last() {
+    if (this._length === 0) return;
+    return this._buckets[this._bucketLast][this._lastInBucket];
+  }
+  /**
+   * Create a Deque from an array of elements.
+   * @remarks Time O(N), Space O(N)
+   * @template E
+   * @template R
+   * @param this - Constructor (subclass) to instantiate.
+   * @param data - Array of elements to insert in order.
+   * @param [options] - Options forwarded to the constructor.
+   * @returns A new Deque populated from the array.
+   */
+  static fromArray(data, options) {
+    return new this(data, options);
+  }
+  /**
+   * Append one element at the back.
+   * @remarks Time O(1) amortized, Space O(1)
+   * @param element - Element to append.
+   * @returns True when appended.
+   */
+  push(element) {
+    if (this._length) {
+      if (this._lastInBucket < this._bucketSize - 1) {
+        this._lastInBucket += 1;
+      } else if (this._bucketLast < this._bucketCount - 1) {
+        this._bucketLast += 1;
+        this._lastInBucket = 0;
+      } else {
+        this._bucketLast = 0;
+        this._lastInBucket = 0;
+      }
+      if (this._bucketLast === this._bucketFirst && this._lastInBucket === this._firstInBucket) this._reallocate();
+    }
+    this._length += 1;
+    this._buckets[this._bucketLast][this._lastInBucket] = element;
+    if (this._maxLen > 0 && this._length > this._maxLen) this.shift();
+    return true;
+  }
+  /**
+   * Remove and return the last element.
+   * @remarks Time O(1), Space O(1)
+   * @returns Removed element or undefined.
+   */
+  pop() {
+    if (this._length === 0) return;
+    const element = this._buckets[this._bucketLast][this._lastInBucket];
+    if (this._length !== 1) {
+      if (this._lastInBucket > 0) {
+        this._lastInBucket -= 1;
+      } else if (this._bucketLast > 0) {
+        this._bucketLast -= 1;
+        this._lastInBucket = this._bucketSize - 1;
+      } else {
+        this._bucketLast = this._bucketCount - 1;
+        this._lastInBucket = this._bucketSize - 1;
+      }
+    }
+    this._length -= 1;
+    return element;
+  }
+  /**
+   * Remove and return the first element.
+   * @remarks Time O(1) amortized, Space O(1)
+   * @returns Removed element or undefined.
+   */
+  shift() {
+    if (this._length === 0) return;
+    const element = this._buckets[this._bucketFirst][this._firstInBucket];
+    if (this._length !== 1) {
+      if (this._firstInBucket < this._bucketSize - 1) {
+        this._firstInBucket += 1;
+      } else if (this._bucketFirst < this._bucketCount - 1) {
+        this._bucketFirst += 1;
+        this._firstInBucket = 0;
+      } else {
+        this._bucketFirst = 0;
+        this._firstInBucket = 0;
+      }
+    }
+    this._length -= 1;
+    return element;
+  }
+  /**
+   * Prepend one element at the front.
+   * @remarks Time O(1) amortized, Space O(1)
+   * @param element - Element to prepend.
+   * @returns True when prepended.
+   */
+  unshift(element) {
+    if (this._length) {
+      if (this._firstInBucket > 0) {
+        this._firstInBucket -= 1;
+      } else if (this._bucketFirst > 0) {
+        this._bucketFirst -= 1;
+        this._firstInBucket = this._bucketSize - 1;
+      } else {
+        this._bucketFirst = this._bucketCount - 1;
+        this._firstInBucket = this._bucketSize - 1;
+      }
+      if (this._bucketFirst === this._bucketLast && this._firstInBucket === this._lastInBucket) this._reallocate();
+    }
+    this._length += 1;
+    this._buckets[this._bucketFirst][this._firstInBucket] = element;
+    if (this._maxLen > 0 && this._length > this._maxLen) this.pop();
+    return true;
+  }
+  /**
+   * Append a sequence of elements.
+   * @remarks Time O(N), Space O(1)
+   * @param elements - Iterable (or iterable-like) of elements/records.
+   * @returns Array of per-element success flags.
+   */
+  pushMany(elements) {
+    const ans = [];
+    for (const el of elements) {
+      if (this.toElementFn) {
+        ans.push(this.push(this.toElementFn(el)));
+      } else {
+        ans.push(this.push(el));
+      }
+    }
+    return ans;
+  }
+  /**
+   * Prepend a sequence of elements.
+   * @remarks Time O(N), Space O(1)
+   * @param [elements] - Iterable (or iterable-like) of elements/records.
+   * @returns Array of per-element success flags.
+   */
+  unshiftMany(elements = []) {
+    const ans = [];
+    for (const el of elements) {
+      if (this.toElementFn) {
+        ans.push(this.unshift(this.toElementFn(el)));
+      } else {
+        ans.push(this.unshift(el));
+      }
+    }
+    return ans;
+  }
+  /**
+   * Check whether the deque is empty.
+   * @remarks Time O(1), Space O(1)
+   * @returns True if length is 0.
+   */
+  isEmpty() {
+    return this._length === 0;
+  }
+  /**
+   * Remove all elements and reset structure.
+   * @remarks Time O(1), Space O(1)
+   * @returns void
+   */
+  clear() {
+    this._buckets = [new Array(this._bucketSize)];
+    this._bucketCount = 1;
+    this._bucketFirst = this._bucketLast = this._length = 0;
+    this._firstInBucket = this._lastInBucket = this._bucketSize >> 1;
+  }
+  /**
+   * Get the element at a given position.
+   * @remarks Time O(1), Space O(1)
+   * @param pos - Zero-based position from the front.
+   * @returns Element or undefined.
+   */
+  at(pos) {
+    if (pos < 0 || pos >= this._length) return void 0;
+    const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
+    return this._buckets[bucketIndex][indexInBucket];
+  }
+  /**
+   * Replace the element at a given position.
+   * @remarks Time O(1), Space O(1)
+   * @param pos - Zero-based position from the front.
+   * @param element - New element value.
+   * @returns True if updated.
+   */
+  setAt(pos, element) {
+    rangeCheck(pos, 0, this._length - 1);
+    const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
+    this._buckets[bucketIndex][indexInBucket] = element;
+    return true;
+  }
+  /**
+   * Insert repeated copies of an element at a position.
+   * @remarks Time O(N), Space O(1)
+   * @param pos - Zero-based position from the front.
+   * @param element - Element to insert.
+   * @param [num] - Number of times to insert (default 1).
+   * @returns True if inserted.
+   */
+  addAt(pos, element, num = 1) {
+    const length = this._length;
+    rangeCheck(pos, 0, length);
+    if (pos === 0) {
+      while (num--) this.unshift(element);
+    } else if (pos === this._length) {
+      while (num--) this.push(element);
+    } else {
+      const arr = [];
+      for (let i = pos; i < this._length; ++i) {
+        const v = this.at(i);
+        if (v !== void 0) arr.push(v);
+      }
+      this.cut(pos - 1, true);
+      for (let i = 0; i < num; ++i) this.push(element);
+      for (let i = 0; i < arr.length; ++i) this.push(arr[i]);
+    }
+    return true;
+  }
+  /**
+   * Cut the deque to keep items up to index; optionally mutate in-place.
+   * @remarks Time O(N), Space O(1)
+   * @param pos - Last index to keep.
+   * @param [isCutSelf] - When true, mutate this deque; otherwise return a new deque.
+   * @returns This deque if in-place; otherwise a new deque of the prefix.
+   */
+  cut(pos, isCutSelf = false) {
+    if (isCutSelf) {
+      if (pos < 0) {
+        this.clear();
+        return this;
+      }
+      const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
+      this._bucketLast = bucketIndex;
+      this._lastInBucket = indexInBucket;
+      this._length = pos + 1;
+      return this;
+    } else {
+      const newDeque = this._createInstance({ toElementFn: this._toElementFn, maxLen: this._maxLen });
+      newDeque._setBucketSize(this._bucketSize);
+      for (let i = 0; i <= pos; i++) {
+        const v = this.at(i);
+        if (v !== void 0) newDeque.push(v);
+      }
+      return newDeque;
+    }
+  }
+  /**
+   * Remove and/or insert elements at a position (array-like behavior).
+   * @remarks Time O(N + M), Space O(M)
+   * @param start - Start index (clamped to [0, length]).
+   * @param [deleteCount] - Number of elements to remove (default: length - start).
+   * @param [items] - Elements to insert after `start`.
+   * @returns A new deque containing the removed elements (typed as `this`).
+   */
+  splice(start, deleteCount = this._length - start, ...items) {
+    rangeCheck(start, 0, this._length);
+    if (deleteCount < 0) deleteCount = 0;
+    if (start + deleteCount > this._length) deleteCount = this._length - start;
+    const removed = this._createInstance({ toElementFn: this._toElementFn, maxLen: this._maxLen });
+    removed._setBucketSize(this._bucketSize);
+    for (let i = 0; i < deleteCount; i++) {
+      const v = this.at(start + i);
+      if (v !== void 0) removed.push(v);
+    }
+    const tail = [];
+    for (let i = start + deleteCount; i < this._length; i++) {
+      const v = this.at(i);
+      if (v !== void 0) tail.push(v);
+    }
+    this.cut(start - 1, true);
+    for (const it of items) this.push(it);
+    for (const v of tail) this.push(v);
+    return removed;
+  }
+  /**
+   * Cut the deque to keep items from index onward; optionally mutate in-place.
+   * @remarks Time O(N), Space O(1)
+   * @param pos - First index to keep.
+   * @param [isCutSelf] - When true, mutate this deque; otherwise return a new deque.
+   * @returns This deque if in-place; otherwise a new deque of the suffix.
+   */
+  cutRest(pos, isCutSelf = false) {
+    if (isCutSelf) {
+      if (pos < 0) {
+        return this;
+      }
+      const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
+      this._bucketFirst = bucketIndex;
+      this._firstInBucket = indexInBucket;
+      this._length = this._length - pos;
+      return this;
+    } else {
+      const newDeque = this._createInstance({ toElementFn: this._toElementFn, maxLen: this._maxLen });
+      newDeque._setBucketSize(this._bucketSize);
+      if (pos < 0) pos = 0;
+      for (let i = pos; i < this._length; i++) {
+        const v = this.at(i);
+        if (v !== void 0) newDeque.push(v);
+      }
+      return newDeque;
+    }
+  }
+  /**
+   * Delete the element at a given position.
+   * @remarks Time O(N), Space O(1)
+   * @param pos - Zero-based position from the front.
+   * @returns Removed element or undefined.
+   */
+  deleteAt(pos) {
+    rangeCheck(pos, 0, this._length - 1);
+    let deleted;
+    if (pos === 0) {
+      return this.shift();
+    } else if (pos === this._length - 1) {
+      deleted = this.last;
+      this.pop();
+      return deleted;
+    } else {
+      const length = this._length - 1;
+      const { bucketIndex: targetBucket, indexInBucket: targetPointer } = this._getBucketAndPosition(pos);
+      deleted = this._buckets[targetBucket][targetPointer];
+      for (let i = pos; i < length; i++) {
+        const { bucketIndex: curBucket, indexInBucket: curPointer } = this._getBucketAndPosition(i);
+        const { bucketIndex: nextBucket, indexInBucket: nextPointer } = this._getBucketAndPosition(i + 1);
+        this._buckets[curBucket][curPointer] = this._buckets[nextBucket][nextPointer];
+      }
+      this.pop();
+      return deleted;
+    }
+  }
+  /**
+   * Delete the first occurrence of a value.
+   * @remarks Time O(N), Space O(1)
+   * @param element - Element to remove (using the configured equality).
+   * @returns True if an element was removed.
+   */
+  delete(element) {
+    const size = this._length;
+    if (size === 0) return false;
+    let i = 0;
+    let index = 0;
+    while (i < size) {
+      const oldElement = this.at(i);
+      if (!this._equals(oldElement, element)) {
+        this.setAt(index, oldElement);
+        index += 1;
+      }
+      i += 1;
+    }
+    this.cut(index - 1, true);
+    return true;
+  }
+  /**
+   * Delete the first element matching a predicate.
+   * @remarks Time O(N), Space O(1)
+   * @param predicate - Function (value, index, deque) → boolean.
+   * @returns True if a match was removed.
+   */
+  deleteWhere(predicate) {
+    for (let i = 0; i < this._length; i++) {
+      const v = this.at(i);
+      if (predicate(v, i, this)) {
+        this.deleteAt(i);
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Set the equality comparator used by delete operations.
+   * @remarks Time O(1), Space O(1)
+   * @param equals - Equality predicate (a, b) → boolean.
+   * @returns This deque.
+   */
+  setEquality(equals) {
+    this._equals = equals;
+    return this;
+  }
+  /**
+   * Reverse the deque by reversing buckets and pointers.
+   * @remarks Time O(N), Space O(N)
+   * @returns This deque.
+   */
+  reverse() {
+    this._buckets.reverse().forEach(function(bucket) {
+      bucket.reverse();
+    });
+    const { _bucketFirst, _bucketLast, _firstInBucket, _lastInBucket } = this;
+    this._bucketFirst = this._bucketCount - _bucketLast - 1;
+    this._bucketLast = this._bucketCount - _bucketFirst - 1;
+    this._firstInBucket = this._bucketSize - _lastInBucket - 1;
+    this._lastInBucket = this._bucketSize - _firstInBucket - 1;
+    return this;
+  }
+  /**
+   * Deduplicate consecutive equal elements in-place.
+   * @remarks Time O(N), Space O(1)
+   * @returns This deque.
+   */
+  unique() {
+    if (this._length <= 1) {
+      return this;
+    }
+    let index = 1;
+    let prev = this.at(0);
+    for (let i = 1; i < this._length; ++i) {
+      const cur = this.at(i);
+      if (!this._equals(cur, prev)) {
+        prev = cur;
+        this.setAt(index++, cur);
+      }
+    }
+    this.cut(index - 1, true);
+    return this;
+  }
+  /**
+   * Trim unused buckets to fit exactly the active range.
+   * @remarks Time O(N), Space O(1)
+   * @returns void
+   */
+  shrinkToFit() {
+    if (this._length === 0) return;
+    const newBuckets = [];
+    if (this._bucketFirst === this._bucketLast) return;
+    else if (this._bucketFirst < this._bucketLast) {
+      for (let i = this._bucketFirst; i <= this._bucketLast; ++i) {
+        newBuckets.push(this._buckets[i]);
+      }
+    } else {
+      for (let i = this._bucketFirst; i < this._bucketCount; ++i) {
+        newBuckets.push(this._buckets[i]);
+      }
+      for (let i = 0; i <= this._bucketLast; ++i) {
+        newBuckets.push(this._buckets[i]);
+      }
+    }
+    this._bucketFirst = 0;
+    this._bucketLast = newBuckets.length - 1;
+    this._buckets = newBuckets;
+  }
+  /**
+   * Deep clone this deque, preserving options.
+   * @remarks Time O(N), Space O(N)
+   * @returns A new deque with the same content and options.
+   */
+  clone() {
+    return this._createLike(this, {
+      bucketSize: this.bucketSize,
+      toElementFn: this.toElementFn,
+      maxLen: this._maxLen
+    });
+  }
+  /**
+   * Filter elements into a new deque of the same class.
+   * @remarks Time O(N), Space O(N)
+   * @param predicate - Predicate (value, index, deque) → boolean to keep element.
+   * @param [thisArg] - Value for `this` inside the predicate.
+   * @returns A new deque with kept elements.
+   */
+  filter(predicate, thisArg) {
+    const out = this._createInstance({ toElementFn: this.toElementFn, maxLen: this._maxLen });
+    out._setBucketSize(this._bucketSize);
+    let index = 0;
+    for (const el of this) {
+      if (predicate.call(thisArg, el, index, this)) out.push(el);
+      index++;
+    }
+    return out;
+  }
+  /**
+   * Map elements into a new deque of the same element type.
+   * @remarks Time O(N), Space O(N)
+   * @param callback - Mapping function (value, index, deque) → newValue.
+   * @param [thisArg] - Value for `this` inside the callback.
+   * @returns A new deque with mapped values.
+   */
+  mapSame(callback, thisArg) {
+    const out = this._createInstance({ toElementFn: this._toElementFn, maxLen: this._maxLen });
+    out._setBucketSize(this._bucketSize);
+    let index = 0;
+    for (const v of this) {
+      const mv = thisArg === void 0 ? callback(v, index++, this) : callback.call(thisArg, v, index++, this);
+      out.push(mv);
+    }
+    return out;
+  }
+  /**
+   * Map elements into a new deque (possibly different element type).
+   * @remarks Time O(N), Space O(N)
+   * @template EM
+   * @template RM
+   * @param callback - Mapping function (value, index, deque) → newElement.
+   * @param [options] - Options for the output deque (e.g., bucketSize, toElementFn, maxLen).
+   * @param [thisArg] - Value for `this` inside the callback.
+   * @returns A new Deque with mapped elements.
+   */
+  map(callback, options, thisArg) {
+    const out = this._createLike([], {
+      ...options != null ? options : {},
+      bucketSize: this._bucketSize,
+      maxLen: this._maxLen
+    });
+    let index = 0;
+    for (const el of this) {
+      const mv = thisArg === void 0 ? callback(el, index, this) : callback.call(thisArg, el, index, this);
+      out.push(mv);
+      index++;
+    }
+    return out;
+  }
+  /**
+   * (Protected) Set the internal bucket size.
+   * @remarks Time O(1), Space O(1)
+   * @param size - Bucket capacity to assign.
+   * @returns void
+   */
+  _setBucketSize(size) {
+    this._bucketSize = size;
+  }
+  /**
+   * (Protected) Iterate elements from front to back.
+   * @remarks Time O(N), Space O(1)
+   * @returns Iterator of elements.
+   */
+  *_getIterator() {
+    for (let i = 0; i < this._length; ++i) {
+      const v = this.at(i);
+      if (v !== void 0) yield v;
+    }
+  }
+  /**
+   * (Protected) Reallocate buckets to make room near the ends.
+   * @remarks Time O(N), Space O(N)
+   * @param [needBucketNum] - How many extra buckets to add; defaults to half of current.
+   * @returns void
+   */
+  _reallocate(needBucketNum) {
+    const newBuckets = [];
+    const addBucketNum = needBucketNum || this._bucketCount >> 1 || 1;
+    for (let i = 0; i < addBucketNum; ++i) {
+      newBuckets[i] = new Array(this._bucketSize);
+    }
+    for (let i = this._bucketFirst; i < this._bucketCount; ++i) {
+      newBuckets[newBuckets.length] = this._buckets[i];
+    }
+    for (let i = 0; i < this._bucketLast; ++i) {
+      newBuckets[newBuckets.length] = this._buckets[i];
+    }
+    newBuckets[newBuckets.length] = [...this._buckets[this._bucketLast]];
+    this._bucketFirst = addBucketNum;
+    this._bucketLast = newBuckets.length - 1;
+    for (let i = 0; i < addBucketNum; ++i) {
+      newBuckets[newBuckets.length] = new Array(this._bucketSize);
+    }
+    this._buckets = newBuckets;
+    this._bucketCount = newBuckets.length;
+  }
+  /**
+   * (Protected) Translate a logical position to bucket/offset.
+   * @remarks Time O(1), Space O(1)
+   * @param pos - Zero-based position.
+   * @returns An object containing bucketIndex and indexInBucket.
+   */
+  _getBucketAndPosition(pos) {
+    let bucketIndex;
+    let indexInBucket;
+    const overallIndex = this._firstInBucket + pos;
+    bucketIndex = this._bucketFirst + Math.floor(overallIndex / this._bucketSize);
+    if (bucketIndex >= this._bucketCount) {
+      bucketIndex -= this._bucketCount;
+    }
+    indexInBucket = (overallIndex + 1) % this._bucketSize - 1;
+    if (indexInBucket < 0) {
+      indexInBucket = this._bucketSize - 1;
+    }
+    return { bucketIndex, indexInBucket };
+  }
+  /**
+   * (Protected) Create an empty instance of the same concrete class.
+   * @remarks Time O(1), Space O(1)
+   * @param [options] - Options forwarded to the constructor.
+   * @returns An empty like-kind deque instance.
+   */
+  _createInstance(options) {
+    const Ctor = this.constructor;
+    return new Ctor([], options);
+  }
+  /**
+   * (Protected) Create a like-kind deque seeded by elements.
+   * @remarks Time O(N), Space O(N)
+   * @template T
+   * @template RR
+   * @param [elements] - Iterable used to seed the new deque.
+   * @param [options] - Options forwarded to the constructor.
+   * @returns A like-kind Deque instance.
+   */
+  _createLike(elements = [], options) {
+    const Ctor = this.constructor;
+    return new Ctor(elements, options);
+  }
+  /**
+   * (Protected) Iterate elements from back to front.
+   * @remarks Time O(N), Space O(1)
+   * @returns Iterator of elements.
+   */
+  *_getReverseIterator() {
+    for (let i = this._length - 1; i > -1; i--) {
+      const v = this.at(i);
+      if (v !== void 0) yield v;
+    }
+  }
+};
+__name(_Deque, "Deque");
+var Deque = _Deque;
+
+// src/common/index.ts
+var DFSOperation = /* @__PURE__ */ ((DFSOperation2) => {
+  DFSOperation2[DFSOperation2["VISIT"] = 0] = "VISIT";
+  DFSOperation2[DFSOperation2["PROCESS"] = 1] = "PROCESS";
+  return DFSOperation2;
+})(DFSOperation || {});
+var _Range = class _Range {
+  constructor(low, high, includeLow = true, includeHigh = true) {
+    this.low = low;
+    this.high = high;
+    this.includeLow = includeLow;
+    this.includeHigh = includeHigh;
+    if (!(isComparable(low) && isComparable(high))) throw new RangeError("low or high is not comparable");
+    if (low > high) throw new RangeError("low must be less than or equal to high");
+  }
+  // Determine whether a key is within the range
+  isInRange(key, comparator) {
+    const lowCheck = this.includeLow ? comparator(key, this.low) >= 0 : comparator(key, this.low) > 0;
+    const highCheck = this.includeHigh ? comparator(key, this.high) <= 0 : comparator(key, this.high) < 0;
+    return lowCheck && highCheck;
+  }
+};
+__name(_Range, "Range");
+var Range = _Range;
+/**
+ * data-structure-typed
+ *
+ * @author Pablo Zeng
+ * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+
+exports.DFSOperation = DFSOperation;
+exports.Deque = Deque;
+exports.Range = Range;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map