data-structure-typed 2.5.0 → 2.5.1

package/dist/cjs/linked-list.cjs

@@ -0,0 +1,4370 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/data-structures/base/iterable-element-base.ts
+var IterableElementBase = class {
+  static {
+    __name(this, "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) {
+    if (options) {
+      const { toElementFn } = options;
+      if (typeof toElementFn === "function") this._toElementFn = toElementFn;
+      else if (toElementFn) throw new TypeError("toElementFn must be a function type");
+    }
+  }
+  /**
+   * The converter used to transform a raw element (`R`) into a public element (`E`).
+   *
+   * @remarks
+   * Time O(1), Space O(1).
+   */
+  _toElementFn;
+  /**
+   * 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());
+  }
+};
+
+// src/data-structures/base/linear-base.ts
+var LinkedListNode = class {
+  static {
+    __name(this, "LinkedListNode");
+  }
+  /**
+   * Initialize a node.
+   * @param value - Element value.
+   * @remarks Time O(1), Space O(1)
+   */
+  constructor(value) {
+    this._value = value;
+    this._next = void 0;
+  }
+  _value;
+  /**
+   * Element payload getter.
+   * @returns Element value.
+   * @remarks Time O(1), Space O(1)
+   */
+  get value() {
+    return this._value;
+  }
+  /**
+   * Element payload setter.
+   * @param value - New value.
+   * @remarks Time O(1), Space O(1)
+   */
+  set value(value) {
+    this._value = value;
+  }
+  _next;
+  /**
+   * Next node getter.
+   * @returns Next node or `undefined`.
+   * @remarks Time O(1), Space O(1)
+   */
+  get next() {
+    return this._next;
+  }
+  /**
+   * Next node setter.
+   * @param value - Next node or `undefined`.
+   * @remarks Time O(1), Space O(1)
+   */
+  set next(value) {
+    this._next = value;
+  }
+};
+var LinearBase = class _LinearBase extends IterableElementBase {
+  static {
+    __name(this, "LinearBase");
+  }
+  /**
+   * Construct a linear container with runtime options.
+   * @param options - `{ maxLen?, ... }` bounds/behavior options.
+   * @remarks Time O(1), Space O(1)
+   */
+  constructor(options) {
+    super(options);
+    if (options) {
+      const { maxLen } = options;
+      if (typeof maxLen === "number" && maxLen > 0 && maxLen % 1 === 0) this._maxLen = maxLen;
+    }
+  }
+  _maxLen = -1;
+  /**
+   * 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 ?? 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;
+  }
+};
+var LinearLinkedBase = class extends LinearBase {
+  static {
+    __name(this, "LinearLinkedBase");
+  }
+  constructor(options) {
+    super(options);
+    if (options) {
+      const { maxLen } = options;
+      if (typeof maxLen === "number" && maxLen > 0 && maxLen % 1 === 0) this._maxLen = maxLen;
+    }
+  }
+  /**
+   * Linked-list optimized `indexOf` (forwards scan).
+   * @param searchElement - Value to match.
+   * @param fromIndex - Start position.
+   * @returns Index or `-1`.
+   * @remarks Time O(n), Space O(1)
+   */
+  indexOf(searchElement, fromIndex = 0) {
+    const iterator = this._getIterator();
+    let current = iterator.next();
+    let index = 0;
+    while (index < fromIndex) {
+      current = iterator.next();
+      index++;
+    }
+    while (!current.done) {
+      if (current.value === searchElement) return index;
+      current = iterator.next();
+      index++;
+    }
+    return -1;
+  }
+  /**
+   * Linked-list optimized `lastIndexOf` (reverse scan).
+   * @param searchElement - Value to match.
+   * @param fromIndex - Start position.
+   * @returns Index or `-1`.
+   * @remarks Time O(n), Space O(1)
+   */
+  lastIndexOf(searchElement, fromIndex = this.length - 1) {
+    const iterator = this._getReverseIterator();
+    let current = iterator.next();
+    let index = this.length - 1;
+    while (index > fromIndex) {
+      current = iterator.next();
+      index--;
+    }
+    while (!current.done) {
+      if (current.value === searchElement) return index;
+      current = iterator.next();
+      index--;
+    }
+    return -1;
+  }
+  /**
+   * Concatenate lists/elements preserving order.
+   * @param items - Elements or `LinearBase` instances.
+   * @returns New list 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;
+  }
+  /**
+   * Slice via forward iteration (no random access required).
+   * @param start - Inclusive start (supports negative index).
+   * @param end - Exclusive end (supports negative index).
+   * @returns New list (`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();
+    const iterator = this._getIterator();
+    let current = iterator.next();
+    let c = 0;
+    while (c < start) {
+      current = iterator.next();
+      c++;
+    }
+    for (let i = start; i < end; i++) {
+      newList.push(current.value);
+      current = iterator.next();
+    }
+    return newList;
+  }
+  /**
+   * Splice by walking node iterators from the start index.
+   * @param start - Start index.
+   * @param deleteCount - How many elements to remove.
+   * @param items - Elements to insert after the splice point.
+   * @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, deleteCount);
+    let currentIndex = 0;
+    let currentNode = void 0;
+    let previousNode = void 0;
+    const iterator = this._getNodeIterator();
+    for (const node of iterator) {
+      if (currentIndex === start) {
+        currentNode = node;
+        break;
+      }
+      previousNode = node;
+      currentIndex++;
+    }
+    for (let i = 0; i < deleteCount && currentNode; i++) {
+      removedList.push(currentNode.value);
+      const nextNode = currentNode.next;
+      this.delete(currentNode);
+      currentNode = nextNode;
+    }
+    for (let i = 0; i < items.length; i++) {
+      if (previousNode) {
+        this.addAfter(previousNode, items[i]);
+        previousNode = previousNode.next;
+      } else {
+        this.addAt(0, items[i]);
+        previousNode = this._getNodeIterator().next().value;
+      }
+    }
+    return removedList;
+  }
+  reduceRight(callbackfn, initialValue) {
+    let accumulator = initialValue ?? 0;
+    let index = this.length - 1;
+    for (const item of this._getReverseIterator()) {
+      accumulator = callbackfn(accumulator, item, index--, this);
+    }
+    return accumulator;
+  }
+};
+
+// src/data-structures/linked-list/singly-linked-list.ts
+var SinglyLinkedListNode = class extends LinkedListNode {
+  static {
+    __name(this, "SinglyLinkedListNode");
+  }
+  /**
+   * Create a list node.
+   * @remarks Time O(1), Space O(1)
+   * @param value - Element value to store.
+   * @returns New node instance.
+   */
+  constructor(value) {
+    super(value);
+    this._value = value;
+    this._next = void 0;
+  }
+  _next;
+  /**
+   * Get the next node.
+   * @remarks Time O(1), Space O(1)
+   * @returns Next node or undefined.
+   */
+  get next() {
+    return this._next;
+  }
+  /**
+   * Set the next node.
+   * @remarks Time O(1), Space O(1)
+   * @param value - Next node or undefined.
+   * @returns void
+   */
+  set next(value) {
+    this._next = value;
+  }
+};
+var SinglyLinkedList = class extends LinearLinkedBase {
+  static {
+    __name(this, "SinglyLinkedList");
+  }
+  _equals = /* @__PURE__ */ __name((a, b) => Object.is(a, b), "_equals");
+  /**
+   * Create a SinglyLinkedList and optionally bulk-insert elements.
+   * @remarks Time O(N), Space O(N)
+   * @param [elements] - Iterable of elements or nodes (or raw records if toElementFn is provided).
+   * @param [options] - Options such as maxLen and toElementFn.
+   * @returns New SinglyLinkedList instance.
+   */
+  constructor(elements = [], options) {
+    super(options);
+    this.pushMany(elements);
+  }
+  _head;
+  /**
+   * Get the head node.
+   * @remarks Time O(1), Space O(1)
+   * @returns Head node or undefined.
+   */
+  get head() {
+    return this._head;
+  }
+  _tail;
+  /**
+   * Get the tail node.
+   * @remarks Time O(1), Space O(1)
+   * @returns Tail node or undefined.
+   */
+  get tail() {
+    return this._tail;
+  }
+  _length = 0;
+  /**
+   * Get the number of elements.
+   * @remarks Time O(1), Space O(1)
+   * @returns Current length.
+   */
+  get length() {
+    return this._length;
+  }
+  /**
+   * Get the first element value.
+   * @remarks Time O(1), Space O(1)
+   * @returns First element or undefined.
+   */
+  get first() {
+    return this.head?.value;
+  }
+  /**
+   * Get the last element value.
+   * @remarks Time O(1), Space O(1)
+   * @returns Last element or undefined.
+   */
+  get last() {
+    return this.tail?.value;
+  }
+  /**
+   * Create a new list from an iterable of elements.
+   * @remarks Time O(N), Space O(N)
+   * @template E
+   * @template R
+   * @template S
+   * @param this - The constructor (subclass) to instantiate.
+   * @param data - Iterable of elements to insert.
+   * @param [options] - Options forwarded to the constructor.
+   * @returns A new list populated with the iterable's elements.
+   */
+  static from(data, options) {
+    const list = new this([], options);
+    for (const x of data) list.push(x);
+    return list;
+  }
+  /**
+    * Append an element/node to the tail.
+    * @remarks Time O(1), Space O(1)
+    * @param elementOrNode - Element or node to append.
+    * @returns True when appended.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // basic SinglyLinkedList creation and push operation
+  *  // Create a simple SinglyLinkedList with initial values
+  *     const list = new SinglyLinkedList([1, 2, 3, 4, 5]);
+  *
+  *     // Verify the list maintains insertion order
+  *     console.log([...list]); // [1, 2, 3, 4, 5];
+  *
+  *     // Check length
+  *     console.log(list.length); // 5;
+  *
+  *     // Push a new element to the end
+  *     list.push(6);
+  *     console.log(list.length); // 6;
+  *     console.log([...list]); // [1, 2, 3, 4, 5, 6];
+    */
+  push(elementOrNode) {
+    const newNode = this._ensureNode(elementOrNode);
+    if (!this.head) {
+      this._head = this._tail = newNode;
+    } else {
+      this.tail.next = newNode;
+      this._tail = newNode;
+    }
+    this._length++;
+    if (this._maxLen > 0 && this.length > this._maxLen) this.shift();
+    return true;
+  }
+  /**
+    * Remove and return the tail element.
+    * @remarks Time O(N), Space O(1)
+    * @returns Removed element or undefined.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // SinglyLinkedList pop and shift operations
+  *  const list = new SinglyLinkedList<number>([10, 20, 30, 40, 50]);
+  *
+  *     // Pop removes from the end
+  *     const last = list.pop();
+  *     console.log(last); // 50;
+  *
+  *     // Shift removes from the beginning
+  *     const first = list.shift();
+  *     console.log(first); // 10;
+  *
+  *     // Verify remaining elements
+  *     console.log([...list]); // [20, 30, 40];
+  *     console.log(list.length); // 3;
+    */
+  pop() {
+    if (!this.head) return void 0;
+    if (this.head === this.tail) {
+      const value2 = this.head.value;
+      this._head = void 0;
+      this._tail = void 0;
+      this._length--;
+      return value2;
+    }
+    let current = this.head;
+    while (current.next && current.next !== this.tail) current = current.next;
+    const value = this.tail?.value;
+    current.next = void 0;
+    this._tail = current;
+    this._length--;
+    return value;
+  }
+  /**
+    * Remove and return the head element.
+    * @remarks Time O(1), Space O(1)
+    * @returns Removed element or undefined.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Remove from the front
+  *  const list = new SinglyLinkedList<number>([10, 20, 30]);
+  *     console.log(list.shift()); // 10;
+  *     console.log(list.length); // 2;
+    */
+  shift() {
+    if (!this.head) return void 0;
+    const removed = this.head;
+    this._head = this.head.next;
+    if (!this._head) this._tail = void 0;
+    this._length--;
+    return removed.value;
+  }
+  /**
+    * Prepend an element/node to the head.
+    * @remarks Time O(1), Space O(1)
+    * @param elementOrNode - Element or node to prepend.
+    * @returns True when prepended.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // SinglyLinkedList unshift and forward traversal
+  *  const list = new SinglyLinkedList<number>([20, 30, 40]);
+  *
+  *     // Unshift adds to the beginning
+  *     list.unshift(10);
+  *     console.log([...list]); // [10, 20, 30, 40];
+  *
+  *     // Access elements (forward traversal only for singly linked)
+  *     const second = list.at(1);
+  *     console.log(second); // 20;
+  *
+  *     // SinglyLinkedList allows forward iteration only
+  *     const elements: number[] = [];
+  *     for (const item of list) {
+  *       elements.push(item);
+  *     }
+  *     console.log(elements); // [10, 20, 30, 40];
+  *
+  *     console.log(list.length); // 4;
+    */
+  unshift(elementOrNode) {
+    const newNode = this._ensureNode(elementOrNode);
+    if (!this.head) {
+      this._head = this._tail = newNode;
+    } else {
+      newNode.next = this.head;
+      this._head = newNode;
+    }
+    this._length++;
+    return true;
+  }
+  /**
+   * Append a sequence of elements/nodes.
+   * @remarks Time O(N), Space O(1)
+   * @param elements - Iterable of elements or nodes (or raw records if toElementFn is provided).
+   * @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/nodes.
+   * @remarks Time O(N), Space O(1)
+   * @param elements - Iterable of elements or nodes (or raw records if toElementFn is provided).
+   * @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;
+  }
+  /**
+   * Find the first value matching a predicate (by node).
+   * @remarks Time O(N), Space O(1)
+   * @param elementNodeOrPredicate - Element, node, or node predicate to match.
+   * @returns Matched value or undefined.
+   */
+  search(elementNodeOrPredicate) {
+    const predicate = this._ensurePredicate(elementNodeOrPredicate);
+    let current = this.head;
+    while (current) {
+      if (predicate(current)) return current.value;
+      current = current.next;
+    }
+    return void 0;
+  }
+  /**
+    * Get the element at a given index.
+    * @remarks Time O(N), Space O(1)
+    * @param index - Zero-based index.
+    * @returns Element or undefined.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Access element by index
+  *  const list = new SinglyLinkedList<string>(['a', 'b', 'c', 'd']);
+  *     console.log(list.at(0)); // 'a';
+  *     console.log(list.at(2)); // 'c';
+  *     console.log(list.at(3)); // 'd';
+    */
+  at(index) {
+    if (index < 0 || index >= this._length) return void 0;
+    let current = this.head;
+    for (let i = 0; i < index && current; i++) current = current.next;
+    return current?.value;
+  }
+  /**
+   * Type guard: check whether the input is a SinglyLinkedListNode.
+   * @remarks Time O(1), Space O(1)
+   * @param elementNodeOrPredicate - Element, node, or predicate.
+   * @returns True if the value is a SinglyLinkedListNode.
+   */
+  isNode(elementNodeOrPredicate) {
+    return elementNodeOrPredicate instanceof SinglyLinkedListNode;
+  }
+  /**
+    * Get the node reference at a given index.
+    * @remarks Time O(N), Space O(1)
+    * @param index - Zero-based index.
+    * @returns Node or undefined.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Get node at index
+  *  const list = new SinglyLinkedList<string>(['a', 'b', 'c']);
+  *     console.log(list.getNodeAt(1)?.value); // 'b';
+    */
+  getNodeAt(index) {
+    if (index < 0 || index >= this._length) return void 0;
+    let current = this.head;
+    for (let i = 0; i < index && current; i++) current = current.next;
+    return current;
+  }
+  /**
+    * Delete the element at an index.
+    * @remarks Time O(N), Space O(1)
+    * @param index - Zero-based index.
+    * @returns Removed element or undefined.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Remove by index
+  *  const list = new SinglyLinkedList<string>(['a', 'b', 'c']);
+  *     list.deleteAt(1);
+  *     console.log(list.toArray()); // ['a', 'c'];
+    */
+  deleteAt(index) {
+    if (index < 0 || index >= this._length) return void 0;
+    if (index === 0) return this.shift();
+    const targetNode = this.getNodeAt(index);
+    const prevNode = this._getPrevNode(targetNode);
+    const value = targetNode.value;
+    prevNode.next = targetNode.next;
+    if (targetNode === this.tail) this._tail = prevNode;
+    this._length--;
+    return value;
+  }
+  /**
+    * Delete the first match by value/node.
+    * @remarks Time O(N), Space O(1)
+    * @param [elementOrNode] - Element or node to remove; if omitted/undefined, nothing happens.
+    * @returns True if removed.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Remove first occurrence
+  *  const list = new SinglyLinkedList<number>([1, 2, 3, 2]);
+  *     list.delete(2);
+  *     console.log(list.toArray()); // [1, 3, 2];
+    */
+  delete(elementOrNode) {
+    if (elementOrNode === void 0 || !this.head) return false;
+    const node = this.isNode(elementOrNode) ? elementOrNode : this.getNode(elementOrNode);
+    if (!node) return false;
+    const prevNode = this._getPrevNode(node);
+    if (!prevNode) {
+      this._head = node.next;
+      if (node === this.tail) this._tail = void 0;
+    } else {
+      prevNode.next = node.next;
+      if (node === this.tail) this._tail = prevNode;
+    }
+    this._length--;
+    return true;
+  }
+  /**
+    * Insert a new element/node at an index, shifting following nodes.
+    * @remarks Time O(N), Space O(1)
+    * @param index - Zero-based index.
+    * @param newElementOrNode - Element or node to insert.
+    * @returns True if inserted.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Insert at index
+  *  const list = new SinglyLinkedList<number>([1, 3]);
+  *     list.addAt(1, 2);
+  *     console.log(list.toArray()); // [1, 2, 3];
+    */
+  addAt(index, newElementOrNode) {
+    if (index < 0 || index > this._length) return false;
+    if (index === 0) return this.unshift(newElementOrNode);
+    if (index === this._length) return this.push(newElementOrNode);
+    const newNode = this._ensureNode(newElementOrNode);
+    const prevNode = this.getNodeAt(index - 1);
+    newNode.next = prevNode.next;
+    prevNode.next = newNode;
+    this._length++;
+    return true;
+  }
+  /**
+   * Set the element value at an index.
+   * @remarks Time O(N), Space O(1)
+   * @param index - Zero-based index.
+   * @param value - New value.
+   * @returns True if updated.
+   */
+  setAt(index, value) {
+    const node = this.getNodeAt(index);
+    if (!node) return false;
+    node.value = value;
+    return true;
+  }
+  /**
+    * Check whether the list is empty.
+    * @remarks Time O(1), Space O(1)
+    * @returns True if length is 0.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Check empty
+  *  console.log(new SinglyLinkedList().isEmpty()); // true;
+    */
+  isEmpty() {
+    return this._length === 0;
+  }
+  /**
+    * Remove all nodes and reset length.
+    * @remarks Time O(N), Space O(1)
+    * @returns void
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Remove all
+  *  const list = new SinglyLinkedList<number>([1, 2, 3]);
+  *     list.clear();
+  *     console.log(list.isEmpty()); // true;
+    */
+  clear() {
+    this._head = void 0;
+    this._tail = void 0;
+    this._length = 0;
+  }
+  /**
+    * Reverse the list in place.
+    * @remarks Time O(N), Space O(1)
+    * @returns This list.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Reverse the list in-place
+  *  const list = new SinglyLinkedList<number>([1, 2, 3, 4]);
+  *     list.reverse();
+  *     console.log([...list]); // [4, 3, 2, 1];
+    */
+  reverse() {
+    if (!this.head || this.head === this.tail) return this;
+    let prev;
+    let current = this.head;
+    let next;
+    while (current) {
+      next = current.next;
+      current.next = prev;
+      prev = current;
+      current = next;
+    }
+    [this._head, this._tail] = [this.tail, this.head];
+    return this;
+  }
+  /**
+   * Find a node by value, reference, or predicate.
+   * @remarks Time O(N), Space O(1)
+   * @param [elementNodeOrPredicate] - Element, node, or node predicate to match.
+   * @returns Matching node or undefined.
+   */
+  getNode(elementNodeOrPredicate) {
+    if (elementNodeOrPredicate === void 0) return;
+    if (this.isNode(elementNodeOrPredicate)) return elementNodeOrPredicate;
+    const predicate = this._ensurePredicate(elementNodeOrPredicate);
+    let current = this.head;
+    while (current) {
+      if (predicate(current)) return current;
+      current = current.next;
+    }
+    return void 0;
+  }
+  /**
+   * Insert a new element/node before an existing one.
+   * @remarks Time O(N), Space O(1)
+   * @param existingElementOrNode - Existing element or node.
+   * @param newElementOrNode - Element or node to insert.
+   * @returns True if inserted.
+   */
+  addBefore(existingElementOrNode, newElementOrNode) {
+    const existingNode = this.getNode(existingElementOrNode);
+    if (!existingNode) return false;
+    const prevNode = this._getPrevNode(existingNode);
+    const newNode = this._ensureNode(newElementOrNode);
+    if (!prevNode) {
+      newNode.next = this._head;
+      this._head = newNode;
+      if (!this._tail) this._tail = newNode;
+      this._length++;
+    } else {
+      prevNode.next = newNode;
+      newNode.next = existingNode;
+      this._length++;
+    }
+    return true;
+  }
+  /**
+   * Insert a new element/node after an existing one.
+   * @remarks Time O(N), Space O(1)
+   * @param existingElementOrNode - Existing element or node.
+   * @param newElementOrNode - Element or node to insert.
+   * @returns True if inserted.
+   */
+  addAfter(existingElementOrNode, newElementOrNode) {
+    const existingNode = this.getNode(existingElementOrNode);
+    if (!existingNode) return false;
+    const newNode = this._ensureNode(newElementOrNode);
+    newNode.next = existingNode.next;
+    existingNode.next = newNode;
+    if (existingNode === this.tail) this._tail = newNode;
+    this._length++;
+    return true;
+  }
+  /**
+   * 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 0).
+   * @param [items] - Elements to insert after `start`.
+   * @returns A new list containing the removed elements (typed as `this`).
+   */
+  splice(start, deleteCount = 0, ...items) {
+    start = Math.max(0, Math.min(start, this.length));
+    deleteCount = Math.max(0, deleteCount);
+    const removedList = this._createInstance();
+    const prevNode = start === 0 ? void 0 : this.getNodeAt(start - 1);
+    let cur = prevNode ? prevNode.next : this.head;
+    let removedCount = 0;
+    while (removedCount < deleteCount && cur) {
+      removedList.push(cur.value);
+      cur = cur.next;
+      removedCount++;
+    }
+    const afterNode = cur;
+    if (prevNode) {
+      prevNode.next = afterNode;
+    } else {
+      this._head = afterNode;
+    }
+    if (!afterNode) this._tail = prevNode;
+    if (items.length > 0) {
+      let firstInserted;
+      let lastInserted;
+      for (const it of items) {
+        const node = this._ensureNode(it);
+        if (!firstInserted) firstInserted = node;
+        if (lastInserted) lastInserted.next = node;
+        lastInserted = node;
+      }
+      if (prevNode) prevNode.next = firstInserted;
+      else this._head = firstInserted;
+      lastInserted.next = afterNode;
+      if (!afterNode) this._tail = lastInserted;
+    }
+    this._length += items.length - removedCount;
+    if (this._length === 0) {
+      this._head = void 0;
+      this._tail = void 0;
+    }
+    return removedList;
+  }
+  /**
+   * Count how many nodes match a value/node/predicate.
+   * @remarks Time O(N), Space O(1)
+   * @param elementOrNode - Element, node, or node predicate to match.
+   * @returns Number of matches in the list.
+   */
+  countOccurrences(elementOrNode) {
+    const predicate = elementOrPredicate(elementOrNode, this._equals);
+    let count = 0;
+    let current = this.head;
+    while (current) {
+      if (predicate(current)) count++;
+      current = current.next;
+    }
+    return count;
+  }
+  /**
+   * Set the equality comparator used to compare values.
+   * @remarks Time O(1), Space O(1)
+   * @param equals - Equality predicate (a, b) → boolean.
+   * @returns This list.
+   */
+  setEquality(equals) {
+    this._equals = equals;
+    return this;
+  }
+  /**
+   * Delete the first node whose value matches a predicate.
+   * @remarks Time O(N), Space O(1)
+   * @param predicate - Predicate (value, index, list) → boolean to decide deletion.
+   * @returns True if a node was removed.
+   */
+  deleteWhere(predicate) {
+    let prev;
+    let current = this.head;
+    let i = 0;
+    while (current) {
+      if (predicate(current.value, i++, this)) {
+        if (!prev) {
+          this._head = current.next;
+          if (current === this._tail) this._tail = void 0;
+        } else {
+          prev.next = current.next;
+          if (current === this._tail) this._tail = prev;
+        }
+        this._length--;
+        return true;
+      }
+      prev = current;
+      current = current.next;
+    }
+    return false;
+  }
+  /**
+    * Deep clone this list (values are copied by reference).
+    * @remarks Time O(N), Space O(N)
+    * @returns A new list with the same element sequence.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Deep copy
+  *  const list = new SinglyLinkedList<number>([1, 2, 3]);
+  *     const copy = list.clone();
+  *     copy.pop();
+  *     console.log(list.length); // 3;
+  *     console.log(copy.length); // 2;
+    */
+  clone() {
+    const out = this._createInstance();
+    for (const v of this) out.push(v);
+    return out;
+  }
+  /**
+    * Filter values into a new list of the same class.
+    * @remarks Time O(N), Space O(N)
+    * @param callback - Predicate (value, index, list) → boolean to keep value.
+    * @param [thisArg] - Value for `this` inside the callback.
+    * @returns A new list with kept values.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // SinglyLinkedList filter and map operations
+  *  const list = new SinglyLinkedList<number>([1, 2, 3, 4, 5]);
+  *
+  *     // Filter even numbers
+  *     const filtered = list.filter(value => value % 2 === 0);
+  *     console.log(filtered.length); // 2;
+  *
+  *     // Map to double values
+  *     const doubled = list.map(value => value * 2);
+  *     console.log(doubled.length); // 5;
+  *
+  *     // Use reduce to sum
+  *     const sum = list.reduce((acc, value) => acc + value, 0);
+  *     console.log(sum); // 15;
+    */
+  filter(callback, thisArg) {
+    const out = this._createInstance();
+    let index = 0;
+    for (const value of this) if (callback.call(thisArg, value, index++, this)) out.push(value);
+    return out;
+  }
+  /**
+   * Map values into a new list of the same class.
+   * @remarks Time O(N), Space O(N)
+   * @param callback - Mapping function (value, index, list) → newValue.
+   * @param [thisArg] - Value for `this` inside the callback.
+   * @returns A new list with mapped values.
+   */
+  mapSame(callback, thisArg) {
+    const out = this._createInstance();
+    let index = 0;
+    for (const value of this) {
+      const mv = thisArg === void 0 ? callback(value, index++, this) : callback.call(thisArg, value, index++, this);
+      out.push(mv);
+    }
+    return out;
+  }
+  /**
+    * Map values into a new list (possibly different element type).
+    * @remarks Time O(N), Space O(N)
+    * @template EM
+    * @template RM
+    * @param callback - Mapping function (value, index, list) → newElement.
+    * @param [options] - Options for the output list (e.g., maxLen, toElementFn).
+    * @param [thisArg] - Value for `this` inside the callback.
+    * @returns A new SinglyLinkedList with mapped values.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Transform elements
+  *  const list = new SinglyLinkedList<number>([1, 2, 3]);
+  *     const doubled = list.map(n => n * 2);
+  *     console.log([...doubled]); // [2, 4, 6];
+    */
+  map(callback, options, thisArg) {
+    const out = this._createLike([], { ...options ?? {}, maxLen: this._maxLen });
+    let index = 0;
+    for (const value of this) out.push(callback.call(thisArg, value, index++, this));
+    return out;
+  }
+  /**
+   * (Protected) Create a node from a value.
+   * @remarks Time O(1), Space O(1)
+   * @param value - Value to wrap in a node.
+   * @returns A new SinglyLinkedListNode instance.
+   */
+  createNode(value) {
+    return new SinglyLinkedListNode(value);
+  }
+  /**
+   * (Protected) Check if input is a node predicate function.
+   * @remarks Time O(1), Space O(1)
+   * @param elementNodeOrPredicate - Element, node, or node predicate.
+   * @returns True if input is a predicate function.
+   */
+  _isPredicate(elementNodeOrPredicate) {
+    return typeof elementNodeOrPredicate === "function";
+  }
+  /**
+   * (Protected) Normalize input into a node instance.
+   * @remarks Time O(1), Space O(1)
+   * @param elementOrNode - Element or node.
+   * @returns A SinglyLinkedListNode for the provided input.
+   */
+  _ensureNode(elementOrNode) {
+    if (this.isNode(elementOrNode)) return elementOrNode;
+    return this.createNode(elementOrNode);
+  }
+  /**
+   * (Protected) Normalize input into a node predicate.
+   * @remarks Time O(1), Space O(1)
+   * @param elementNodeOrPredicate - Element, node, or predicate.
+   * @returns A predicate taking a node and returning true/false.
+   */
+  _ensurePredicate(elementNodeOrPredicate) {
+    if (this.isNode(elementNodeOrPredicate)) return (node) => node === elementNodeOrPredicate;
+    if (this._isPredicate(elementNodeOrPredicate)) return elementNodeOrPredicate;
+    const value = elementNodeOrPredicate;
+    return (node) => this._equals(node.value, value);
+  }
+  /**
+   * (Protected) Get the previous node of a given node.
+   * @remarks Time O(N), Space O(1)
+   * @param node - A node in the list.
+   * @returns Previous node or undefined.
+   */
+  _getPrevNode(node) {
+    if (!this.head || this.head === node) return void 0;
+    let current = this.head;
+    while (current.next && current.next !== node) current = current.next;
+    return current.next === node ? current : void 0;
+  }
+  /**
+   * (Protected) Iterate values from head to tail.
+   * @remarks Time O(N), Space O(1)
+   * @returns Iterator of values (E).
+   */
+  *_getIterator() {
+    let current = this.head;
+    while (current) {
+      yield current.value;
+      current = current.next;
+    }
+  }
+  /**
+   * (Protected) Iterate values from tail to head.
+   * @remarks Time O(N), Space O(N)
+   * @returns Iterator of values (E).
+   */
+  *_getReverseIterator() {
+    const reversedArr = [...this].reverse();
+    for (const item of reversedArr) yield item;
+  }
+  /**
+   * (Protected) Iterate nodes from head to tail.
+   * @remarks Time O(N), Space O(1)
+   * @returns Iterator of nodes.
+   */
+  *_getNodeIterator() {
+    let current = this.head;
+    while (current) {
+      yield current;
+      current = current.next;
+    }
+  }
+  /**
+   * (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 list instance.
+   */
+  _createInstance(options) {
+    const Ctor = this.constructor;
+    return new Ctor([], options);
+  }
+  /**
+   * (Protected) Create a like-kind instance and seed it from an iterable.
+   * @remarks Time O(N), Space O(N)
+   * @template EM
+   * @template RM
+   * @param [elements] - Iterable used to seed the new list.
+   * @param [options] - Options forwarded to the constructor.
+   * @returns A like-kind SinglyLinkedList instance.
+   */
+  _createLike(elements = [], options) {
+    const Ctor = this.constructor;
+    return new Ctor(elements, options);
+  }
+  /**
+   * (Protected) Spawn an empty like-kind list instance.
+   * @remarks Time O(1), Space O(1)
+   * @template EM
+   * @template RM
+   * @param [options] - Options forwarded to the constructor.
+   * @returns An empty like-kind SinglyLinkedList instance.
+   */
+  _spawnLike(options) {
+    return this._createLike([], options);
+  }
+};
+function elementOrPredicate(input, equals) {
+  if (input instanceof SinglyLinkedListNode) return (node) => node === input;
+  if (typeof input === "function") return input;
+  const value = input;
+  return (node) => equals(node.value, value);
+}
+__name(elementOrPredicate, "elementOrPredicate");
+
+// src/data-structures/linked-list/doubly-linked-list.ts
+var DoublyLinkedListNode = class extends LinkedListNode {
+  static {
+    __name(this, "DoublyLinkedListNode");
+  }
+  /**
+   * Create a node.
+   * @remarks Time O(1), Space O(1)
+   * @param value - Element value to store.
+   * @returns New node instance.
+   */
+  constructor(value) {
+    super(value);
+    this._value = value;
+    this._next = void 0;
+    this._prev = void 0;
+  }
+  _next;
+  /**
+   * Get the next node link.
+   * @remarks Time O(1), Space O(1)
+   * @returns Next node or undefined.
+   */
+  get next() {
+    return this._next;
+  }
+  /**
+   * Set the next node link.
+   * @remarks Time O(1), Space O(1)
+   * @param value - Next node or undefined.
+   * @returns void
+   */
+  set next(value) {
+    this._next = value;
+  }
+  _prev;
+  /**
+   * Get the previous node link.
+   * @remarks Time O(1), Space O(1)
+   * @returns Previous node or undefined.
+   */
+  get prev() {
+    return this._prev;
+  }
+  /**
+   * Set the previous node link.
+   * @remarks Time O(1), Space O(1)
+   * @param value - Previous node or undefined.
+   * @returns void
+   */
+  set prev(value) {
+    this._prev = value;
+  }
+};
+var DoublyLinkedList = class extends LinearLinkedBase {
+  static {
+    __name(this, "DoublyLinkedList");
+  }
+  _equals = /* @__PURE__ */ __name((a, b) => Object.is(a, b), "_equals");
+  /**
+   * Create a DoublyLinkedList and optionally bulk-insert elements.
+   * @remarks Time O(N), Space O(N)
+   * @param [elements] - Iterable of elements or nodes (or raw records if toElementFn is provided).
+   * @param [options] - Options such as maxLen and toElementFn.
+   * @returns New DoublyLinkedList instance.
+   */
+  constructor(elements = [], options) {
+    super(options);
+    this._head = void 0;
+    this._tail = void 0;
+    this._length = 0;
+    if (options?.maxLen && Number.isInteger(options.maxLen) && options.maxLen > 0) {
+      this._maxLen = options.maxLen;
+    }
+    this.pushMany(elements);
+  }
+  _head;
+  /**
+   * Get the head node.
+   * @remarks Time O(1), Space O(1)
+   * @returns Head node or undefined.
+   */
+  get head() {
+    return this._head;
+  }
+  _tail;
+  /**
+   * Get the tail node.
+   * @remarks Time O(1), Space O(1)
+   * @returns Tail node or undefined.
+   */
+  get tail() {
+    return this._tail;
+  }
+  _length = 0;
+  /**
+   * Get the number of elements.
+   * @remarks Time O(1), Space O(1)
+   * @returns Current length.
+   */
+  get length() {
+    return this._length;
+  }
+  /**
+   * Get the first element value.
+   * @remarks Time O(1), Space O(1)
+   * @returns First element or undefined.
+   */
+  get first() {
+    return this.head?.value;
+  }
+  /**
+   * Get the last element value.
+   * @remarks Time O(1), Space O(1)
+   * @returns Last element or undefined.
+   */
+  get last() {
+    return this.tail?.value;
+  }
+  /**
+   * Create a new list from an array of elements.
+   * @remarks Time O(N), Space O(N)
+   * @template E
+   * @template R
+   * @param this - The constructor (subclass) to instantiate.
+   * @param data - Array of elements to insert.
+   * @returns A new list populated with the array's elements.
+   */
+  static fromArray(data) {
+    return new this(data);
+  }
+  /**
+   * Type guard: check whether the input is a DoublyLinkedListNode.
+   * @remarks Time O(1), Space O(1)
+   * @param elementNodeOrPredicate - Element, node, or predicate.
+   * @returns True if the value is a DoublyLinkedListNode.
+   */
+  isNode(elementNodeOrPredicate) {
+    return elementNodeOrPredicate instanceof DoublyLinkedListNode;
+  }
+  /**
+    * Append an element/node to the tail.
+    * @remarks Time O(1), Space O(1)
+    * @param elementOrNode - Element or node to append.
+    * @returns True when appended.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // basic DoublyLinkedList creation and push operation
+  *  // Create a simple DoublyLinkedList with initial values
+  *     const list = new DoublyLinkedList([1, 2, 3, 4, 5]);
+  *
+  *     // Verify the list maintains insertion order
+  *     console.log([...list]); // [1, 2, 3, 4, 5];
+  *
+  *     // Check length
+  *     console.log(list.length); // 5;
+  *
+  *     // Push a new element to the end
+  *     list.push(6);
+  *     console.log(list.length); // 6;
+  *     console.log([...list]); // [1, 2, 3, 4, 5, 6];
+    */
+  push(elementOrNode) {
+    const newNode = this._ensureNode(elementOrNode);
+    if (!this.head) {
+      this._head = newNode;
+      this._tail = newNode;
+    } else {
+      newNode.prev = this.tail;
+      this.tail.next = newNode;
+      this._tail = newNode;
+    }
+    this._length++;
+    if (this._maxLen > 0 && this.length > this._maxLen) this.shift();
+    return true;
+  }
+  /**
+    * Remove and return the tail element.
+    * @remarks Time O(1), Space O(1)
+    * @returns Removed element or undefined.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // DoublyLinkedList pop and shift operations
+  *  const list = new DoublyLinkedList<number>([10, 20, 30, 40, 50]);
+  *
+  *     // Pop removes from the end
+  *     const last = list.pop();
+  *     console.log(last); // 50;
+  *
+  *     // Shift removes from the beginning
+  *     const first = list.shift();
+  *     console.log(first); // 10;
+  *
+  *     // Verify remaining elements
+  *     console.log([...list]); // [20, 30, 40];
+  *     console.log(list.length); // 3;
+    */
+  pop() {
+    if (!this.tail) return void 0;
+    const removed = this.tail;
+    if (this.head === this.tail) {
+      this._head = void 0;
+      this._tail = void 0;
+    } else {
+      this._tail = removed.prev;
+      this.tail.next = void 0;
+    }
+    this._length--;
+    return removed.value;
+  }
+  /**
+    * Remove and return the head element.
+    * @remarks Time O(1), Space O(1)
+    * @returns Removed element or undefined.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Remove from the front
+  *  const list = new DoublyLinkedList<number>([10, 20, 30]);
+  *     console.log(list.shift()); // 10;
+  *     console.log(list.first); // 20;
+    */
+  shift() {
+    if (!this.head) return void 0;
+    const removed = this.head;
+    if (this.head === this.tail) {
+      this._head = void 0;
+      this._tail = void 0;
+    } else {
+      this._head = removed.next;
+      this.head.prev = void 0;
+    }
+    this._length--;
+    return removed.value;
+  }
+  /**
+    * Prepend an element/node to the head.
+    * @remarks Time O(1), Space O(1)
+    * @param elementOrNode - Element or node to prepend.
+    * @returns True when prepended.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Add to the front
+  *  const list = new DoublyLinkedList<number>([2, 3]);
+  *     list.unshift(1);
+  *     console.log([...list]); // [1, 2, 3];
+    */
+  unshift(elementOrNode) {
+    const newNode = this._ensureNode(elementOrNode);
+    if (!this.head) {
+      this._head = newNode;
+      this._tail = newNode;
+    } else {
+      newNode.next = this.head;
+      this.head.prev = newNode;
+      this._head = newNode;
+    }
+    this._length++;
+    if (this._maxLen > 0 && this._length > this._maxLen) this.pop();
+    return true;
+  }
+  /**
+   * Append a sequence of elements/nodes.
+   * @remarks Time O(N), Space O(1)
+   * @param elements - Iterable of elements or nodes (or raw records if toElementFn is provided).
+   * @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/nodes.
+   * @remarks Time O(N), Space O(1)
+   * @param elements - Iterable of elements or nodes (or raw records if toElementFn is provided).
+   * @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;
+  }
+  /**
+    * Get the element at a given index.
+    * @remarks Time O(N), Space O(1)
+    * @param index - Zero-based index.
+    * @returns Element or undefined.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Access by index
+  *  const list = new DoublyLinkedList<string>(['a', 'b', 'c']);
+  *     console.log(list.at(1)); // 'b';
+  *     console.log(list.at(2)); // 'c';
+    */
+  at(index) {
+    if (index < 0 || index >= this._length) return void 0;
+    let current = this.head;
+    for (let i = 0; i < index && current; i++) current = current.next;
+    return current?.value;
+  }
+  /**
+    * Get the node reference at a given index.
+    * @remarks Time O(N), Space O(1)
+    * @param index - Zero-based index.
+    * @returns Node or undefined.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Get node at index
+  *  const list = new DoublyLinkedList<string>(['a', 'b', 'c']);
+  *     console.log(list.getNodeAt(1)?.value); // 'b';
+    */
+  getNodeAt(index) {
+    if (index < 0 || index >= this._length) return void 0;
+    let current = this.head;
+    for (let i = 0; i < index && current; i++) current = current.next;
+    return current;
+  }
+  /**
+   * Find a node by value, reference, or predicate.
+   * @remarks Time O(N), Space O(1)
+   * @param [elementNodeOrPredicate] - Element, node, or predicate to match.
+   * @returns Matching node or undefined.
+   */
+  getNode(elementNodeOrPredicate) {
+    if (elementNodeOrPredicate === void 0) return;
+    if (this.isNode(elementNodeOrPredicate)) {
+      const target = elementNodeOrPredicate;
+      let cur = this.head;
+      while (cur) {
+        if (cur === target) return target;
+        cur = cur.next;
+      }
+      const isMatch = /* @__PURE__ */ __name((node) => this._equals(node.value, target.value), "isMatch");
+      cur = this.head;
+      while (cur) {
+        if (isMatch(cur)) return cur;
+        cur = cur.next;
+      }
+      return void 0;
+    }
+    const predicate = this._ensurePredicate(elementNodeOrPredicate);
+    let current = this.head;
+    while (current) {
+      if (predicate(current)) return current;
+      current = current.next;
+    }
+    return void 0;
+  }
+  /**
+    * Insert a new element/node at an index, shifting following nodes.
+    * @remarks Time O(N), Space O(1)
+    * @param index - Zero-based index.
+    * @param newElementOrNode - Element or node to insert.
+    * @returns True if inserted.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Insert at position
+  *  const list = new DoublyLinkedList<number>([1, 3]);
+  *     list.addAt(1, 2);
+  *     console.log(list.toArray()); // [1, 2, 3];
+    */
+  addAt(index, newElementOrNode) {
+    if (index < 0 || index > this._length) return false;
+    if (index === 0) return this.unshift(newElementOrNode);
+    if (index === this._length) return this.push(newElementOrNode);
+    const newNode = this._ensureNode(newElementOrNode);
+    const prevNode = this.getNodeAt(index - 1);
+    const nextNode = prevNode.next;
+    newNode.prev = prevNode;
+    newNode.next = nextNode;
+    prevNode.next = newNode;
+    nextNode.prev = newNode;
+    this._length++;
+    return true;
+  }
+  /**
+   * Insert a new element/node before an existing one.
+   * @remarks Time O(N), Space O(1)
+   * @param existingElementOrNode - Existing element or node.
+   * @param newElementOrNode - Element or node to insert.
+   * @returns True if inserted.
+   */
+  addBefore(existingElementOrNode, newElementOrNode) {
+    const existingNode = this.isNode(existingElementOrNode) ? existingElementOrNode : this.getNode(existingElementOrNode);
+    if (!existingNode) return false;
+    const newNode = this._ensureNode(newElementOrNode);
+    newNode.prev = existingNode.prev;
+    if (existingNode.prev) existingNode.prev.next = newNode;
+    newNode.next = existingNode;
+    existingNode.prev = newNode;
+    if (existingNode === this.head) this._head = newNode;
+    this._length++;
+    return true;
+  }
+  /**
+   * Insert a new element/node after an existing one.
+   * @remarks Time O(N), Space O(1)
+   * @param existingElementOrNode - Existing element or node.
+   * @param newElementOrNode - Element or node to insert.
+   * @returns True if inserted.
+   */
+  addAfter(existingElementOrNode, newElementOrNode) {
+    const existingNode = this.isNode(existingElementOrNode) ? existingElementOrNode : this.getNode(existingElementOrNode);
+    if (!existingNode) return false;
+    const newNode = this._ensureNode(newElementOrNode);
+    newNode.next = existingNode.next;
+    if (existingNode.next) existingNode.next.prev = newNode;
+    newNode.prev = existingNode;
+    existingNode.next = newNode;
+    if (existingNode === this.tail) this._tail = newNode;
+    this._length++;
+    return true;
+  }
+  /**
+   * Set the element value at an index.
+   * @remarks Time O(N), Space O(1)
+   * @param index - Zero-based index.
+   * @param value - New value.
+   * @returns True if updated.
+   */
+  setAt(index, value) {
+    const node = this.getNodeAt(index);
+    if (!node) return false;
+    node.value = value;
+    return true;
+  }
+  /**
+    * Delete the element at an index.
+    * @remarks Time O(N), Space O(1)
+    * @param index - Zero-based index.
+    * @returns Removed element or undefined.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Remove by index
+  *  const list = new DoublyLinkedList<string>(['a', 'b', 'c']);
+  *     list.deleteAt(1);
+  *     console.log(list.toArray()); // ['a', 'c'];
+    */
+  deleteAt(index) {
+    if (index < 0 || index >= this._length) return;
+    if (index === 0) return this.shift();
+    if (index === this._length - 1) return this.pop();
+    const removedNode = this.getNodeAt(index);
+    const prevNode = removedNode.prev;
+    const nextNode = removedNode.next;
+    prevNode.next = nextNode;
+    nextNode.prev = prevNode;
+    this._length--;
+    return removedNode.value;
+  }
+  /**
+    * Delete the first match by value/node.
+    * @remarks Time O(N), Space O(1)
+    * @param [elementOrNode] - Element or node to remove.
+    * @returns True if removed.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Remove first occurrence
+  *  const list = new DoublyLinkedList<number>([1, 2, 3, 2]);
+  *     list.delete(2);
+  *     console.log(list.toArray()); // [1, 3, 2];
+    */
+  delete(elementOrNode) {
+    const node = this.getNode(elementOrNode);
+    if (!node) return false;
+    if (node === this.head) this.shift();
+    else if (node === this.tail) this.pop();
+    else {
+      const prevNode = node.prev;
+      const nextNode = node.next;
+      prevNode.next = nextNode;
+      nextNode.prev = prevNode;
+      this._length--;
+    }
+    return true;
+  }
+  /**
+    * Check whether the list is empty.
+    * @remarks Time O(1), Space O(1)
+    * @returns True if length is 0.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Check empty
+  *  console.log(new DoublyLinkedList().isEmpty()); // true;
+    */
+  isEmpty() {
+    return this._length === 0;
+  }
+  /**
+    * Remove all nodes and reset length.
+    * @remarks Time O(N), Space O(1)
+    * @returns void
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Remove all
+  *  const list = new DoublyLinkedList<number>([1, 2]);
+  *     list.clear();
+  *     console.log(list.isEmpty()); // true;
+    */
+  clear() {
+    this._head = void 0;
+    this._tail = void 0;
+    this._length = 0;
+  }
+  /**
+    * Find the first value matching a predicate scanning forward.
+    * @remarks Time O(N), Space O(1)
+    * @param elementNodeOrPredicate - Element, node, or predicate to match.
+    * @returns Matched value or undefined.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Search with predicate
+  *  const list = new DoublyLinkedList<number>([10, 20, 30]);
+  *     const found = list.search(node => node.value > 15);
+  *     console.log(found); // 20;
+    */
+  search(elementNodeOrPredicate) {
+    const predicate = this._ensurePredicate(elementNodeOrPredicate);
+    let current = this.head;
+    while (current) {
+      if (predicate(current)) return current.value;
+      current = current.next;
+    }
+    return void 0;
+  }
+  /**
+    * Find the first value matching a predicate scanning backward.
+    * @remarks Time O(N), Space O(1)
+    * @param elementNodeOrPredicate - Element, node, or predicate to match.
+    * @returns Matched value or undefined.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Find value scanning from tail
+  *  const list = new DoublyLinkedList<number>([1, 2, 3, 4]);
+  *     // getBackward scans from tail to head, returns first match
+  *     const found = list.getBackward(node => node.value < 4);
+  *     console.log(found); // 3;
+    */
+  getBackward(elementNodeOrPredicate) {
+    const predicate = this._ensurePredicate(elementNodeOrPredicate);
+    let current = this.tail;
+    while (current) {
+      if (predicate(current)) return current.value;
+      current = current.prev;
+    }
+    return void 0;
+  }
+  /**
+    * Reverse the list in place.
+    * @remarks Time O(N), Space O(1)
+    * @returns This list.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Reverse in-place
+  *  const list = new DoublyLinkedList<number>([1, 2, 3]);
+  *     list.reverse();
+  *     console.log([...list]); // [3, 2, 1];
+    */
+  reverse() {
+    let current = this.head;
+    [this._head, this._tail] = [this.tail, this.head];
+    while (current) {
+      const next = current.next;
+      [current.prev, current.next] = [current.next, current.prev];
+      current = next;
+    }
+    return this;
+  }
+  /**
+   * Set the equality comparator used to compare values.
+   * @remarks Time O(1), Space O(1)
+   * @param equals - Equality predicate (a, b) → boolean.
+   * @returns This list.
+   */
+  setEquality(equals) {
+    this._equals = equals;
+    return this;
+  }
+  /**
+    * Deep clone this list (values are copied by reference).
+    * @remarks Time O(N), Space O(N)
+    * @returns A new list with the same element sequence.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Deep copy
+  *  const list = new DoublyLinkedList<number>([1, 2, 3]);
+  *     const copy = list.clone();
+  *     copy.pop();
+  *     console.log(list.length); // 3;
+    */
+  clone() {
+    const out = this._createInstance({ toElementFn: this._toElementFn, maxLen: this._maxLen });
+    for (const v of this) out.push(v);
+    return out;
+  }
+  /**
+    * Filter values into a new list of the same class.
+    * @remarks Time O(N), Space O(N)
+    * @param callback - Predicate (value, index, list) → boolean to keep value.
+    * @param [thisArg] - Value for `this` inside the callback.
+    * @returns A new list with kept values.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Filter elements
+  *  const list = new DoublyLinkedList<number>([1, 2, 3, 4, 5]);
+  *     const evens = list.filter(n => n % 2 === 0);
+  *     console.log([...evens]); // [2, 4];
+    */
+  filter(callback, thisArg) {
+    const out = this._createInstance({ toElementFn: this._toElementFn, maxLen: this._maxLen });
+    let index = 0;
+    for (const v of this) if (callback.call(thisArg, v, index++, this)) out.push(v);
+    return out;
+  }
+  /**
+   * Map values into a new list of the same class.
+   * @remarks Time O(N), Space O(N)
+   * @param callback - Mapping function (value, index, list) → newValue.
+   * @param [thisArg] - Value for `this` inside the callback.
+   * @returns A new list with mapped values.
+   */
+  mapSame(callback, thisArg) {
+    const out = this._createInstance({ toElementFn: this._toElementFn, maxLen: this._maxLen });
+    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 values into a new list (possibly different element type).
+    * @remarks Time O(N), Space O(N)
+    * @template EM
+    * @template RM
+    * @param callback - Mapping function (value, index, list) → newElement.
+    * @param [options] - Options for the output list (e.g., maxLen, toElementFn).
+    * @param [thisArg] - Value for `this` inside the callback.
+    * @returns A new DoublyLinkedList with mapped values.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // DoublyLinkedList for...of iteration and map operation
+  *  const list = new DoublyLinkedList<number>([1, 2, 3, 4, 5]);
+  *
+  *     // Iterate through list
+  *     const doubled = list.map(value => value * 2);
+  *     console.log(doubled.length); // 5;
+  *
+  *     // Use for...of loop
+  *     const result: number[] = [];
+  *     for (const item of list) {
+  *       result.push(item);
+  *     }
+  *     console.log(result); // [1, 2, 3, 4, 5];
+    */
+  map(callback, options, thisArg) {
+    const out = this._createLike([], { ...options ?? {}, maxLen: this._maxLen });
+    let index = 0;
+    for (const v of this) out.push(callback.call(thisArg, v, index++, this));
+    return out;
+  }
+  /**
+   * (Protected) Create or return a node for the given input (node or raw element).
+   * @remarks Time O(1), Space O(1)
+   * @param elementOrNode - Element value or node to normalize.
+   * @returns A DoublyLinkedListNode for the provided input.
+   */
+  _ensureNode(elementOrNode) {
+    if (this.isNode(elementOrNode)) return elementOrNode;
+    return new DoublyLinkedListNode(elementOrNode);
+  }
+  /**
+   * (Protected) Normalize input into a predicate over nodes.
+   * @remarks Time O(1), Space O(1)
+   * @param elementNodeOrPredicate - Element, node, or node predicate.
+   * @returns A predicate function taking a node and returning true/false.
+   */
+  _ensurePredicate(elementNodeOrPredicate) {
+    if (this.isNode(elementNodeOrPredicate)) {
+      const target = elementNodeOrPredicate;
+      return (node) => node === target;
+    }
+    if (typeof elementNodeOrPredicate === "function") {
+      return elementNodeOrPredicate;
+    }
+    const value = elementNodeOrPredicate;
+    return (node) => this._equals(node.value, value);
+  }
+  /**
+   * (Protected) Get the previous node of a given node.
+   * @remarks Time O(1), Space O(1)
+   * @param node - A node in the list.
+   * @returns Previous node or undefined.
+   */
+  _getPrevNode(node) {
+    return node.prev;
+  }
+  /**
+   * (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 list instance.
+   */
+  _createInstance(options) {
+    const Ctor = this.constructor;
+    return new Ctor([], options);
+  }
+  /**
+   * (Protected) Create a like-kind instance and seed it from an iterable.
+   * @remarks Time O(N), Space O(N)
+   * @template EM
+   * @template RM
+   * @param [elements] - Iterable used to seed the new list.
+   * @param [options] - Options forwarded to the constructor.
+   * @returns A like-kind DoublyLinkedList instance.
+   */
+  _createLike(elements = [], options) {
+    const Ctor = this.constructor;
+    return new Ctor(elements, options);
+  }
+  *_getIterator() {
+    let current = this.head;
+    while (current) {
+      yield current.value;
+      current = current.next;
+    }
+  }
+  *_getReverseIterator() {
+    let current = this.tail;
+    while (current) {
+      yield current.value;
+      current = current.prev;
+    }
+  }
+  *_getNodeIterator() {
+    let current = this.head;
+    while (current) {
+      yield current;
+      current = current.next;
+    }
+  }
+};
+
+// src/common/error.ts
+var ERR = {
+  // Range / index
+  indexOutOfRange: /* @__PURE__ */ __name((index, min, max, ctx) => `${ctx ? ctx + ": " : ""}Index ${index} is out of range [${min}, ${max}].`, "indexOutOfRange"),
+  invalidIndex: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Index must be an integer.`, "invalidIndex"),
+  // Type / argument
+  invalidArgument: /* @__PURE__ */ __name((reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`, "invalidArgument"),
+  comparatorRequired: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Comparator is required for non-number/non-string/non-Date keys.`, "comparatorRequired"),
+  invalidKey: /* @__PURE__ */ __name((reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`, "invalidKey"),
+  notAFunction: /* @__PURE__ */ __name((name, ctx) => `${ctx ? ctx + ": " : ""}${name} must be a function.`, "notAFunction"),
+  invalidEntry: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Each entry must be a [key, value] tuple.`, "invalidEntry"),
+  invalidNaN: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}NaN is not a valid key.`, "invalidNaN"),
+  invalidDate: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Invalid Date key.`, "invalidDate"),
+  reduceEmpty: /* @__PURE__ */ __name((ctx) => `${ctx ? ctx + ": " : ""}Reduce of empty structure with no initial value.`, "reduceEmpty"),
+  callbackReturnType: /* @__PURE__ */ __name((expected, got, ctx) => `${ctx ? ctx + ": " : ""}Callback must return ${expected}; got ${got}.`, "callbackReturnType"),
+  // State / operation
+  invalidOperation: /* @__PURE__ */ __name((reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`, "invalidOperation"),
+  // Matrix
+  matrixDimensionMismatch: /* @__PURE__ */ __name((op) => `Matrix: Dimensions must be compatible for ${op}.`, "matrixDimensionMismatch"),
+  matrixSingular: /* @__PURE__ */ __name(() => "Matrix: Singular matrix, inverse does not exist.", "matrixSingular"),
+  matrixNotSquare: /* @__PURE__ */ __name(() => "Matrix: Must be square for inversion.", "matrixNotSquare"),
+  matrixNotRectangular: /* @__PURE__ */ __name(() => "Matrix: Must be rectangular for transposition.", "matrixNotRectangular"),
+  matrixRowMismatch: /* @__PURE__ */ __name((expected, got) => `Matrix: Expected row length ${expected}, but got ${got}.`, "matrixRowMismatch")
+};
+
+// src/data-structures/base/iterable-entry-base.ts
+var IterableEntryBase = class {
+  static {
+    __name(this, "IterableEntryBase");
+  }
+  /**
+   * Default iterator yielding `[key, value]` entries.
+   * @returns Iterator of `[K, V]`.
+   * @remarks Time O(n) to iterate, Space O(1)
+   */
+  *[Symbol.iterator](...args) {
+    yield* this._getIterator(...args);
+  }
+  /**
+   * Iterate over `[key, value]` pairs (may yield `undefined` values).
+   * @returns Iterator of `[K, V | undefined]`.
+   * @remarks Time O(n), Space O(1)
+   */
+  *entries() {
+    for (const item of this) {
+      yield item;
+    }
+  }
+  /**
+   * Iterate over keys only.
+   * @returns Iterator of keys.
+   * @remarks Time O(n), Space O(1)
+   */
+  *keys() {
+    for (const item of this) {
+      yield item[0];
+    }
+  }
+  /**
+   * Iterate over values only.
+   * @returns Iterator of values.
+   * @remarks Time O(n), Space O(1)
+   */
+  *values() {
+    for (const item of this) {
+      yield item[1];
+    }
+  }
+  /**
+   * Test whether all entries satisfy the predicate.
+   * @param predicate - `(key, value, index, self) => boolean`.
+   * @param thisArg - Optional `this` for callback.
+   * @returns `true` if all pass; otherwise `false`.
+   * @remarks Time O(n), Space O(1)
+   */
+  every(predicate, thisArg) {
+    let index = 0;
+    for (const item of this) {
+      if (!predicate.call(thisArg, item[1], item[0], index++, this)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Test whether any entry satisfies the predicate.
+   * @param predicate - `(key, value, index, self) => boolean`.
+   * @param thisArg - Optional `this` for callback.
+   * @returns `true` if any passes; otherwise `false`.
+   * @remarks Time O(n), Space O(1)
+   */
+  some(predicate, thisArg) {
+    let index = 0;
+    for (const item of this) {
+      if (predicate.call(thisArg, item[1], item[0], index++, this)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Visit each entry, left-to-right.
+   * @param callbackfn - `(key, value, index, self) => void`.
+   * @param thisArg - Optional `this` for callback.
+   * @remarks Time O(n), Space O(1)
+   */
+  forEach(callbackfn, thisArg) {
+    let index = 0;
+    for (const item of this) {
+      const [key, value] = item;
+      callbackfn.call(thisArg, value, key, index++, this);
+    }
+  }
+  /**
+   * Find the first entry that matches a predicate.
+   * @param callbackfn - `(key, value, index, self) => boolean`.
+   * @param thisArg - Optional `this` for callback.
+   * @returns Matching `[key, value]` or `undefined`.
+   * @remarks Time O(n), Space O(1)
+   */
+  find(callbackfn, thisArg) {
+    let index = 0;
+    for (const item of this) {
+      const [key, value] = item;
+      if (callbackfn.call(thisArg, value, key, index++, this)) return item;
+    }
+    return;
+  }
+  /**
+   * Whether the given key exists.
+   * @param key - Key to test.
+   * @returns `true` if found; otherwise `false`.
+   * @remarks Time O(n) generic, Space O(1)
+   */
+  has(key) {
+    for (const item of this) {
+      const [itemKey] = item;
+      if (itemKey === key) return true;
+    }
+    return false;
+  }
+  /**
+   * Whether there exists an entry with the given value.
+   * @param value - Value to test.
+   * @returns `true` if found; otherwise `false`.
+   * @remarks Time O(n), Space O(1)
+   */
+  hasValue(value) {
+    for (const [, elementValue] of this) {
+      if (elementValue === value) return true;
+    }
+    return false;
+  }
+  /**
+   * Get the value under a key.
+   * @param key - Key to look up.
+   * @returns Value or `undefined`.
+   * @remarks Time O(n) generic, Space O(1)
+   */
+  get(key) {
+    for (const item of this) {
+      const [itemKey, value] = item;
+      if (itemKey === key) return value;
+    }
+    return;
+  }
+  /**
+   * Reduce entries into a single accumulator.
+   * @param callbackfn - `(acc, value, key, index, self) => acc`.
+   * @param initialValue - Initial accumulator.
+   * @returns Final accumulator.
+   * @remarks Time O(n), Space O(1)
+   */
+  reduce(callbackfn, initialValue) {
+    let accumulator = initialValue;
+    let index = 0;
+    for (const item of this) {
+      const [key, value] = item;
+      accumulator = callbackfn(accumulator, value, key, index++, this);
+    }
+    return accumulator;
+  }
+  /**
+   * Converts data structure to `[key, value]` pairs.
+   * @returns Array of entries.
+   * @remarks Time O(n), Space O(n)
+   */
+  toArray() {
+    return [...this];
+  }
+  /**
+   * Visualize the iterable as an array of `[key, value]` pairs (or a custom string).
+   * @returns Array of entries (default) or a string.
+   * @remarks Time O(n), Space O(n)
+   */
+  toVisual() {
+    return [...this];
+  }
+  /**
+   * Print a human-friendly representation to the console.
+   * @remarks Time O(n), Space O(n)
+   */
+  print() {
+    console.log(this.toVisual());
+  }
+};
+
+// src/data-structures/linked-list/skip-linked-list.ts
+var SkipListNode = class {
+  static {
+    __name(this, "SkipListNode");
+  }
+  key;
+  value;
+  forward;
+  constructor(key, value, level) {
+    this.key = key;
+    this.value = value;
+    this.forward = new Array(level).fill(void 0);
+  }
+};
+var SkipList = class _SkipList extends IterableEntryBase {
+  static {
+    __name(this, "SkipList");
+  }
+  #comparator;
+  #isDefaultComparator;
+  constructor(entries = [], options = {}) {
+    super();
+    const { comparator, toEntryFn, maxLevel, probability } = options;
+    if (typeof maxLevel === "number" && maxLevel > 0) this._maxLevel = maxLevel;
+    if (typeof probability === "number" && probability > 0 && probability < 1) this._probability = probability;
+    this.#isDefaultComparator = comparator === void 0;
+    this.#comparator = comparator ?? _SkipList.createDefaultComparator();
+    this._head = new SkipListNode(void 0, void 0, this._maxLevel);
+    for (const item of entries) {
+      let k;
+      let v;
+      if (toEntryFn) {
+        [k, v] = toEntryFn(item);
+      } else {
+        if (!Array.isArray(item) || item.length < 2) {
+          throw new TypeError(ERR.invalidEntry("SkipList"));
+        }
+        [k, v] = item;
+      }
+      this.set(k, v);
+    }
+  }
+  /**
+   * Creates a default comparator supporting number, string, Date, and bigint.
+   */
+  static createDefaultComparator() {
+    return (a, b) => {
+      if (typeof a === "number" && typeof b === "number") {
+        if (Number.isNaN(a) || Number.isNaN(b)) throw new TypeError(ERR.invalidNaN("SkipList"));
+        return a - b;
+      }
+      if (typeof a === "string" && typeof b === "string") {
+        return a < b ? -1 : a > b ? 1 : 0;
+      }
+      if (a instanceof Date && b instanceof Date) {
+        const ta = a.getTime(), tb = b.getTime();
+        if (Number.isNaN(ta) || Number.isNaN(tb)) throw new TypeError(ERR.invalidDate("SkipList"));
+        return ta - tb;
+      }
+      if (typeof a === "bigint" && typeof b === "bigint") {
+        return a < b ? -1 : a > b ? 1 : 0;
+      }
+      throw new TypeError(ERR.comparatorRequired("SkipList"));
+    };
+  }
+  // ─── Internal state ──────────────────────────────────────────
+  _head;
+  _level = 0;
+  _size = 0;
+  _maxLevel = 16;
+  _probability = 0.5;
+  // ─── Size & lifecycle ────────────────────────────────────────
+  get size() {
+    return this._size;
+  }
+  get maxLevel() {
+    return this._maxLevel;
+  }
+  get probability() {
+    return this._probability;
+  }
+  get comparator() {
+    return this.#comparator;
+  }
+  /**
+    * Check if empty
+   
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Check if empty
+  *  const sl = new SkipList<number, string>();
+  *     console.log(sl.isEmpty()); // true;
+    */
+  isEmpty() {
+    return this._size === 0;
+  }
+  /**
+    * Remove all entries
+   
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Remove all entries
+  *  const sl = new SkipList<number, string>([[1, 'a'], [2, 'b']]);
+  *     sl.clear();
+  *     console.log(sl.isEmpty()); // true;
+    */
+  clear() {
+    this._head = new SkipListNode(void 0, void 0, this._maxLevel);
+    this._level = 0;
+    this._size = 0;
+  }
+  /**
+    * Create independent copy
+   
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Create independent copy
+  *  const sl = new SkipList<number, string>([[1, 'a'], [2, 'b']]);
+  *     const copy = sl.clone();
+  *     copy.delete(1);
+  *     console.log(sl.has(1)); // true;
+    */
+  clone() {
+    return new _SkipList(this, {
+      comparator: this.#isDefaultComparator ? void 0 : this.#comparator,
+      maxLevel: this._maxLevel,
+      probability: this._probability
+    });
+  }
+  // ─── Core CRUD ───────────────────────────────────────────────
+  /**
+    * Insert or update a key-value pair. Returns `this` for chaining.
+    * Unique keys only — if key exists, value is updated in place.
+   
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // In-memory sorted key-value store
+  *  const store = new SkipList<number, string>();
+  *
+  *     store.set(3, 'three');
+  *     store.set(1, 'one');
+  *     store.set(5, 'five');
+  *     store.set(2, 'two');
+  *
+  *     console.log(store.get(3)); // 'three';
+  *     console.log(store.get(1)); // 'one';
+  *     console.log(store.get(5)); // 'five';
+  *
+  *     // Update existing key
+  *     store.set(3, 'THREE');
+  *     console.log(store.get(3)); // 'THREE';
+    */
+  set(key, value) {
+    const cmp = this.#comparator;
+    const update = this._findUpdate(key);
+    const existing = update[0].forward[0];
+    if (existing && cmp(existing.key, key) === 0) {
+      existing.value = value;
+      return this;
+    }
+    const newLevel = this._randomLevel();
+    const newNode = new SkipListNode(key, value, newLevel);
+    if (newLevel > this._level) {
+      for (let i = this._level; i < newLevel; i++) {
+        update[i] = this._head;
+      }
+      this._level = newLevel;
+    }
+    for (let i = 0; i < newLevel; i++) {
+      newNode.forward[i] = update[i].forward[i];
+      update[i].forward[i] = newNode;
+    }
+    this._size++;
+    return this;
+  }
+  /**
+    * Get the value for a key, or `undefined` if not found.
+    * Overrides base O(n) with O(log n) skip-list search.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Building a sorted index
+  *  type Product = { id: number; name: string; price: number };
+  *     const products: Product[] = [
+  *       { id: 1, name: 'Widget', price: 25 },
+  *       { id: 2, name: 'Gadget', price: 50 },
+  *       { id: 3, name: 'Doohickey', price: 15 }
+  *     ];
+  *
+  *     const index = new SkipList<number, Product, Product>(products, {
+  *       toEntryFn: (p: Product) => [p.price, p]
+  *     });
+  *
+  *     // Iterate in sorted order by price
+  *     const names = [...index.values()].map(p => p!.name);
+  *     console.log(names); // ['Doohickey', 'Widget', 'Gadget'];
+  *
+  *     // Range search: products between $20 and $60
+  *     const range = index.rangeSearch([20, 60]);
+  *     console.log(range.map(([, p]) => p!.name)); // ['Widget', 'Gadget'];
+    */
+  get(key) {
+    const node = this._findNode(key);
+    return node ? node.value : void 0;
+  }
+  /**
+    * Check if a key exists.
+    * Overrides base O(n) with O(log n) skip-list search.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Check key existence
+  *  const sl = new SkipList<number, string>([[1, 'a'], [3, 'c'], [5, 'e']]);
+  *     console.log(sl.has(3)); // true;
+  *     console.log(sl.has(4)); // false;
+    */
+  has(key) {
+    return this._findNode(key) !== void 0;
+  }
+  /**
+    * Delete a key. Returns `true` if the key was found and removed.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Fast lookup with deletion
+  *  const cache = new SkipList<string, number>();
+  *
+  *     cache.set('alpha', 1);
+  *     cache.set('beta', 2);
+  *     cache.set('gamma', 3);
+  *
+  *     console.log(cache.has('beta')); // true;
+  *     cache.delete('beta');
+  *     console.log(cache.has('beta')); // false;
+  *     console.log(cache.size); // 2;
+    */
+  delete(key) {
+    const cmp = this.#comparator;
+    const update = this._findUpdate(key);
+    const target = update[0].forward[0];
+    if (!target || cmp(target.key, key) !== 0) return false;
+    for (let i = 0; i < this._level; i++) {
+      if (update[i].forward[i] !== target) break;
+      update[i].forward[i] = target.forward[i];
+    }
+    while (this._level > 0 && !this._head.forward[this._level - 1]) {
+      this._level--;
+    }
+    this._size--;
+    return true;
+  }
+  // ─── Navigation ──────────────────────────────────────────────
+  /**
+    * Returns the first (smallest key) entry, or `undefined` if empty.
+   
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Access the minimum entry
+  *  const sl = new SkipList<number, string>([[5, 'e'], [1, 'a'], [3, 'c']]);
+  *     console.log(sl.first()); // [1, 'a'];
+    */
+  first() {
+    const node = this._head.forward[0];
+    return node ? [node.key, node.value] : void 0;
+  }
+  /**
+    * Returns the last (largest key) entry, or `undefined` if empty.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Access the maximum entry
+  *  const sl = new SkipList<number, string>([[5, 'e'], [1, 'a'], [3, 'c']]);
+  *     console.log(sl.last()); // [5, 'e'];
+    */
+  last() {
+    let current = this._head;
+    for (let i = this._level - 1; i >= 0; i--) {
+      while (current.forward[i]) {
+        current = current.forward[i];
+      }
+    }
+    return current === this._head ? void 0 : [current.key, current.value];
+  }
+  /**
+    * Remove and return the first (smallest key) entry.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Remove and return smallest
+  *  const sl = new SkipList<number, string>([[1, 'a'], [2, 'b'], [3, 'c']]);
+  *     console.log(sl.pollFirst()); // [1, 'a'];
+  *     console.log(sl.size); // 2;
+    */
+  pollFirst() {
+    const entry = this.first();
+    if (!entry) return void 0;
+    this.delete(entry[0]);
+    return entry;
+  }
+  /**
+    * Remove and return the last (largest key) entry.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Remove and return largest
+  *  const sl = new SkipList<number, string>([[1, 'a'], [2, 'b'], [3, 'c']]);
+  *     console.log(sl.pollLast()); // [3, 'c'];
+  *     console.log(sl.size); // 2;
+    */
+  pollLast() {
+    const entry = this.last();
+    if (!entry) return void 0;
+    this.delete(entry[0]);
+    return entry;
+  }
+  /**
+    * Least entry ≥ key, or `undefined`.
+   
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Least entry ≥ key
+  *  const sl = new SkipList<number, string>([[10, 'a'], [20, 'b'], [30, 'c']]);
+  *     console.log(sl.ceiling(15)); // [20, 'b'];
+  *     console.log(sl.ceiling(20)); // [20, 'b'];
+    */
+  ceiling(key) {
+    const cmp = this.#comparator;
+    let current = this._head;
+    for (let i = this._level - 1; i >= 0; i--) {
+      while (current.forward[i] && cmp(current.forward[i].key, key) < 0) {
+        current = current.forward[i];
+      }
+    }
+    const node = current.forward[0];
+    return node ? [node.key, node.value] : void 0;
+  }
+  /**
+    * Greatest entry ≤ key, or `undefined`.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Greatest entry ≤ key
+  *  const sl = new SkipList<number, string>([[10, 'a'], [20, 'b'], [30, 'c']]);
+  *     console.log(sl.floor(25)); // [20, 'b'];
+  *     console.log(sl.floor(5)); // undefined;
+    */
+  floor(key) {
+    const cmp = this.#comparator;
+    let current = this._head;
+    for (let i = this._level - 1; i >= 0; i--) {
+      while (current.forward[i] && cmp(current.forward[i].key, key) <= 0) {
+        current = current.forward[i];
+      }
+    }
+    const result = current === this._head ? void 0 : current;
+    if (result && cmp(result.key, key) <= 0) return [result.key, result.value];
+    return void 0;
+  }
+  /**
+    * Least entry strictly > key, or `undefined`.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Strictly greater entry
+  *  const sl = new SkipList<number, string>([[10, 'a'], [20, 'b'], [30, 'c']]);
+  *     console.log(sl.higher(15)); // [20, 'b'];
+  *     console.log(sl.higher(30)); // undefined;
+    */
+  higher(key) {
+    const cmp = this.#comparator;
+    let current = this._head;
+    for (let i = this._level - 1; i >= 0; i--) {
+      while (current.forward[i] && cmp(current.forward[i].key, key) <= 0) {
+        current = current.forward[i];
+      }
+    }
+    const node = current.forward[0];
+    return node ? [node.key, node.value] : void 0;
+  }
+  /**
+    * Greatest entry strictly < key, or `undefined`.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Strictly less entry
+  *  const sl = new SkipList<number, string>([[10, 'a'], [20, 'b'], [30, 'c']]);
+  *     console.log(sl.lower(25)); // [20, 'b'];
+  *     console.log(sl.lower(10)); // undefined;
+    */
+  lower(key) {
+    const cmp = this.#comparator;
+    let current = this._head;
+    let result;
+    for (let i = this._level - 1; i >= 0; i--) {
+      while (current.forward[i] && cmp(current.forward[i].key, key) < 0) {
+        current = current.forward[i];
+      }
+      if (current !== this._head && cmp(current.key, key) < 0) {
+        result = current;
+      }
+    }
+    return result ? [result.key, result.value] : void 0;
+  }
+  /**
+    * Returns entries within the given key range.
+   
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Find entries in a range
+  *  const sl = new SkipList<number, string>([[1, 'a'], [2, 'b'], [3, 'c'], [4, 'd'], [5, 'e']]);
+  *     const result = sl.rangeSearch([2, 4]);
+  *     console.log(result); // [[2, 'b'], [3, 'c'], [4, 'd']];
+    */
+  rangeSearch(range, options = {}) {
+    const { lowInclusive = true, highInclusive = true } = options;
+    const [low, high] = range;
+    const cmp = this.#comparator;
+    const out = [];
+    let current = this._head;
+    for (let i = this._level - 1; i >= 0; i--) {
+      while (current.forward[i] && cmp(current.forward[i].key, low) < 0) {
+        current = current.forward[i];
+      }
+    }
+    current = current.forward[0];
+    while (current) {
+      const cmpHigh = cmp(current.key, high);
+      if (cmpHigh > 0) break;
+      if (cmpHigh === 0 && !highInclusive) break;
+      const cmpLow = cmp(current.key, low);
+      if (cmpLow > 0 || cmpLow === 0 && lowInclusive) {
+        out.push([current.key, current.value]);
+      }
+      current = current.forward[0];
+    }
+    return out;
+  }
+  // ─── Functional (overrides) ──────────────────────────────────
+  /**
+    * Creates a new SkipList with entries transformed by callback.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Transform entries
+  *  const sl = new SkipList<number, string>([[1, 'a'], [2, 'b']]);
+  *     const mapped = sl.map((v, k) => [k, v?.toUpperCase()] as [number, string]);
+  *     console.log([...mapped.values()]); // ['A', 'B'];
+    */
+  map(callback, options) {
+    const out = new _SkipList([], options ?? {});
+    let i = 0;
+    for (const [k, v] of this) {
+      const [nk, nv] = callback(v, k, i++, this);
+      out.set(nk, nv);
+    }
+    return out;
+  }
+  /**
+    * Creates a new SkipList with entries that pass the predicate.
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Filter entries
+  *  const sl = new SkipList<number, string>([[1, 'a'], [2, 'b'], [3, 'c']]);
+  *     const result = sl.filter((v, k) => k > 1);
+  *     console.log(result.size); // 2;
+    */
+  filter(callbackfn, thisArg) {
+    const out = new _SkipList([], {
+      comparator: this.#isDefaultComparator ? void 0 : this.#comparator,
+      maxLevel: this._maxLevel,
+      probability: this._probability
+    });
+    let i = 0;
+    for (const [k, v] of this) {
+      const ok = callbackfn.call(thisArg, v, k, i++, this);
+      if (ok) out.set(k, v);
+    }
+    return out;
+  }
+  // ─── Iterator (required by IterableEntryBase) ────────────────
+  _getIterator() {
+    const head = this._head;
+    return (function* () {
+      let node = head.forward[0];
+      while (node) {
+        yield [node.key, node.value];
+        node = node.forward[0];
+      }
+    })();
+  }
+  // ─── Internal helpers ────────────────────────────────────────
+  /**
+   * Finds the update array (predecessors at each level) for a given key.
+   */
+  _findUpdate(key) {
+    const cmp = this.#comparator;
+    const update = new Array(this._maxLevel).fill(this._head);
+    let current = this._head;
+    for (let i = this._level - 1; i >= 0; i--) {
+      while (current.forward[i] && cmp(current.forward[i].key, key) < 0) {
+        current = current.forward[i];
+      }
+      update[i] = current;
+    }
+    return update;
+  }
+  /**
+   * Finds the node for a given key, or undefined.
+   */
+  _findNode(key) {
+    const cmp = this.#comparator;
+    let current = this._head;
+    for (let i = this._level - 1; i >= 0; i--) {
+      while (current.forward[i] && cmp(current.forward[i].key, key) < 0) {
+        current = current.forward[i];
+      }
+    }
+    const candidate = current.forward[0];
+    if (candidate && cmp(candidate.key, key) === 0) return candidate;
+    return void 0;
+  }
+  _randomLevel() {
+    let level = 1;
+    while (Math.random() < this._probability && level < this._maxLevel) {
+      level++;
+    }
+    return level;
+  }
+};
+/**
+ * data-structure-typed
+ *
+ * @author Pablo Zeng
+ * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+
+exports.DoublyLinkedList = DoublyLinkedList;
+exports.DoublyLinkedListNode = DoublyLinkedListNode;
+exports.SinglyLinkedList = SinglyLinkedList;
+exports.SinglyLinkedListNode = SinglyLinkedListNode;
+exports.SkipList = SkipList;
+exports.SkipListNode = SkipListNode;
+//# sourceMappingURL=linked-list.cjs.map
+//# sourceMappingURL=linked-list.cjs.map