data-structure-typed 2.2.7 → 2.2.8

package/dist/leetcode/queue.mjs

@@ -0,0 +1,943 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var IterableElementBase = class {
+  static {
+    __name(this, "IterableElementBase");
+  }
+  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");
+    }
+  }
+  _toElementFn;
+  get toElementFn() {
+    return this._toElementFn;
+  }
+  *[Symbol.iterator](...args) {
+    yield* this._getIterator(...args);
+  }
+  *values() {
+    for (const item of this) yield item;
+  }
+  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;
+  }
+  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;
+  }
+  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);
+      }
+    }
+  }
+  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;
+  }
+  has(element) {
+    for (const ele of this) if (ele === element) return true;
+    return false;
+  }
+  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;
+  }
+  toArray() {
+    return [...this];
+  }
+  toVisual() {
+    return [...this];
+  }
+  print() {
+    console.log(this.toVisual());
+  }
+};
+var LinkedListNode = class {
+  static {
+    __name(this, "LinkedListNode");
+  }
+  constructor(value) {
+    this._value = value;
+    this._next = void 0;
+  }
+  _value;
+  get value() {
+    return this._value;
+  }
+  set value(value) {
+    this._value = value;
+  }
+  _next;
+  get next() {
+    return this._next;
+  }
+  set next(value) {
+    this._next = value;
+  }
+};
+var LinearBase = class _LinearBase extends IterableElementBase {
+  static {
+    __name(this, "LinearBase");
+  }
+  constructor(options) {
+    super(options);
+    if (options) {
+      const { maxLen } = options;
+      if (typeof maxLen === "number" && maxLen > 0 && maxLen % 1 === 0) this._maxLen = maxLen;
+    }
+  }
+  _maxLen = -1;
+  get maxLen() {
+    return this._maxLen;
+  }
+  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;
+  }
+  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;
+  }
+  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;
+  }
+  concat(...items) {
+    const newList = this.clone();
+    for (const item of items) {
+      if (item instanceof _LinearBase) {
+        newList.pushMany(item);
+      } else {
+        newList.push(item);
+      }
+    }
+    return newList;
+  }
+  sort(compareFn) {
+    const arr = this.toArray();
+    arr.sort(compareFn);
+    this.clear();
+    for (const item of arr) this.push(item);
+    return this;
+  }
+  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(separator = ",") {
+    return this.toArray().join(separator);
+  }
+  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;
+  }
+  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(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;
+    }
+  }
+  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;
+  }
+  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;
+  }
+  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(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(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;
+  }
+};
+var SinglyLinkedListNode = class extends LinkedListNode {
+  static {
+    __name(this, "SinglyLinkedListNode");
+  }
+  constructor(value) {
+    super(value);
+    this._value = value;
+    this._next = void 0;
+  }
+  _next;
+  get next() {
+    return this._next;
+  }
+  set next(value) {
+    this._next = value;
+  }
+};
+var SinglyLinkedList = class extends LinearLinkedBase {
+  static {
+    __name(this, "SinglyLinkedList");
+  }
+  _equals = Object.is;
+  constructor(elements = [], options) {
+    super(options);
+    this.pushMany(elements);
+  }
+  _head;
+  get head() {
+    return this._head;
+  }
+  _tail;
+  get tail() {
+    return this._tail;
+  }
+  _length = 0;
+  get length() {
+    return this._length;
+  }
+  get first() {
+    return this.head?.value;
+  }
+  get last() {
+    return this.tail?.value;
+  }
+  static from(data, options) {
+    const list = new this([], options);
+    for (const x of data) list.push(x);
+    return list;
+  }
+  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;
+  }
+  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 !== this.tail) current = current.next;
+    const value = this.tail.value;
+    current.next = void 0;
+    this._tail = current;
+    this._length--;
+    return value;
+  }
+  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;
+  }
+  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;
+  }
+  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;
+  }
+  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;
+  }
+  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;
+  }
+  at(index) {
+    if (index < 0 || index >= this._length) return void 0;
+    let current = this.head;
+    for (let i = 0; i < index; i++) current = current.next;
+    return current.value;
+  }
+  isNode(elementNodeOrPredicate) {
+    return elementNodeOrPredicate instanceof SinglyLinkedListNode;
+  }
+  getNodeAt(index) {
+    if (index < 0 || index >= this._length) return void 0;
+    let current = this.head;
+    for (let i = 0; i < index; i++) current = current.next;
+    return current;
+  }
+  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(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;
+  }
+  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;
+  }
+  setAt(index, value) {
+    const node = this.getNodeAt(index);
+    if (!node) return false;
+    node.value = value;
+    return true;
+  }
+  isEmpty() {
+    return this._length === 0;
+  }
+  clear() {
+    this._head = void 0;
+    this._tail = void 0;
+    this._length = 0;
+  }
+  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;
+  }
+  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;
+  }
+  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;
+  }
+  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;
+  }
+  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;
+  }
+  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;
+  }
+  setEquality(equals) {
+    this._equals = equals;
+    return this;
+  }
+  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;
+  }
+  clone() {
+    const out = this._createInstance();
+    for (const v of this) out.push(v);
+    return out;
+  }
+  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;
+  }
+  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(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;
+  }
+  createNode(value) {
+    return new SinglyLinkedListNode(value);
+  }
+  _isPredicate(elementNodeOrPredicate) {
+    return typeof elementNodeOrPredicate === "function";
+  }
+  _ensureNode(elementOrNode) {
+    if (this.isNode(elementOrNode)) return elementOrNode;
+    return this.createNode(elementOrNode);
+  }
+  _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);
+  }
+  _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;
+  }
+  *_getIterator() {
+    let current = this.head;
+    while (current) {
+      yield current.value;
+      current = current.next;
+    }
+  }
+  *_getReverseIterator() {
+    const reversedArr = [...this].reverse();
+    for (const item of reversedArr) yield item;
+  }
+  *_getNodeIterator() {
+    let current = this.head;
+    while (current) {
+      yield current;
+      current = current.next;
+    }
+  }
+  _createInstance(options) {
+    const Ctor = this.constructor;
+    return new Ctor([], options);
+  }
+  _createLike(elements = [], options) {
+    const Ctor = this.constructor;
+    return new Ctor(elements, options);
+  }
+  _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");
+var Queue = class _Queue extends LinearBase {
+  static {
+    __name(this, "Queue");
+  }
+  constructor(elements = [], options) {
+    super(options);
+    if (options) {
+      const { autoCompactRatio = 0.5 } = options;
+      this._autoCompactRatio = autoCompactRatio;
+    }
+    this.pushMany(elements);
+  }
+  _elements = [];
+  get elements() {
+    return this._elements;
+  }
+  _offset = 0;
+  get offset() {
+    return this._offset;
+  }
+  _autoCompactRatio = 0.5;
+  get autoCompactRatio() {
+    return this._autoCompactRatio;
+  }
+  set autoCompactRatio(value) {
+    this._autoCompactRatio = value;
+  }
+  get length() {
+    return this.elements.length - this._offset;
+  }
+  get first() {
+    return this.length > 0 ? this.elements[this._offset] : void 0;
+  }
+  get last() {
+    return this.length > 0 ? this.elements[this.elements.length - 1] : void 0;
+  }
+  static fromArray(elements) {
+    return new _Queue(elements);
+  }
+  isEmpty() {
+    return this.length === 0;
+  }
+  push(element) {
+    this.elements.push(element);
+    if (this._maxLen > 0 && this.length > this._maxLen) this.shift();
+    return true;
+  }
+  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;
+  }
+  shift() {
+    if (this.length === 0) return void 0;
+    const first = this.first;
+    this._offset += 1;
+    if (this.elements.length > 0 && this.offset / this.elements.length > this.autoCompactRatio) this.compact();
+    return first;
+  }
+  delete(element) {
+    for (let i = this._offset; i < this.elements.length; i++) {
+      if (Object.is(this.elements[i], element)) {
+        this.elements.splice(i, 1);
+        return true;
+      }
+    }
+    return false;
+  }
+  at(index) {
+    if (index < 0 || index >= this.length) return void 0;
+    return this._elements[this._offset + index];
+  }
+  deleteAt(index) {
+    if (index < 0 || index >= this.length) return void 0;
+    const gi = this._offset + index;
+    const [deleted] = this.elements.splice(gi, 1);
+    return deleted;
+  }
+  addAt(index, newElement) {
+    if (index < 0 || index > this.length) return false;
+    this._elements.splice(this._offset + index, 0, newElement);
+    return true;
+  }
+  setAt(index, newElement) {
+    if (index < 0 || index >= this.length) return false;
+    this._elements[this._offset + index] = newElement;
+    return true;
+  }
+  reverse() {
+    this._elements = this.elements.slice(this._offset).reverse();
+    this._offset = 0;
+    return this;
+  }
+  clear() {
+    this._elements = [];
+    this._offset = 0;
+  }
+  compact() {
+    this._elements = this.elements.slice(this._offset);
+    this._offset = 0;
+    return true;
+  }
+  splice(start, deleteCount = 0, ...items) {
+    start = Math.max(0, Math.min(start, this.length));
+    deleteCount = Math.max(0, Math.min(deleteCount, this.length - start));
+    const gi = this._offset + start;
+    const removedArray = this._elements.splice(gi, deleteCount, ...items);
+    if (this.elements.length > 0 && this.offset / this.elements.length > this.autoCompactRatio) this.compact();
+    const removed = this._createInstance({ toElementFn: this.toElementFn, maxLen: this._maxLen });
+    removed._setAutoCompactRatio(this._autoCompactRatio);
+    removed.pushMany(removedArray);
+    return removed;
+  }
+  clone() {
+    const out = this._createInstance({ toElementFn: this.toElementFn, maxLen: this._maxLen });
+    out._setAutoCompactRatio(this._autoCompactRatio);
+    for (let i = this._offset; i < this.elements.length; i++) out.push(this.elements[i]);
+    return out;
+  }
+  filter(predicate, thisArg) {
+    const out = this._createInstance({ toElementFn: this.toElementFn, maxLen: this._maxLen });
+    out._setAutoCompactRatio(this._autoCompactRatio);
+    let index = 0;
+    for (const v of this) {
+      if (predicate.call(thisArg, v, index, this)) out.push(v);
+      index++;
+    }
+    return out;
+  }
+  map(callback, options, thisArg) {
+    const out = new this.constructor([], {
+      toElementFn: options?.toElementFn,
+      maxLen: options?.maxLen ?? this._maxLen,
+      autoCompactRatio: options?.autoCompactRatio ?? this._autoCompactRatio
+    });
+    let index = 0;
+    for (const v of this)
+      out.push(thisArg === void 0 ? callback(v, index++, this) : callback.call(thisArg, v, index++, this));
+    return out;
+  }
+  mapSame(callback, thisArg) {
+    const Ctor = this.constructor;
+    const out = new Ctor([], {
+      toElementFn: this.toElementFn,
+      maxLen: this._maxLen,
+      autoCompactRatio: this._autoCompactRatio
+    });
+    out._setAutoCompactRatio?.(this._autoCompactRatio);
+    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;
+  }
+  _setAutoCompactRatio(value) {
+    this._autoCompactRatio = value;
+  }
+  *_getIterator() {
+    for (let i = this._offset; i < this.elements.length; i++) yield this.elements[i];
+  }
+  *_getReverseIterator() {
+    for (let i = this.length - 1; i >= 0; i--) {
+      const cur = this.at(i);
+      if (cur !== void 0) yield cur;
+    }
+  }
+  _createInstance(options) {
+    const Ctor = this.constructor;
+    return new Ctor([], options);
+  }
+  _createLike(elements = [], options) {
+    const Ctor = this.constructor;
+    return new Ctor(elements, options);
+  }
+};
+var LinkedListQueue = class extends SinglyLinkedList {
+  static {
+    __name(this, "LinkedListQueue");
+  }
+  clone() {
+    const out = this._createInstance({ toElementFn: this.toElementFn, maxLen: this._maxLen });
+    for (const v of this) out.push(v);
+    return out;
+  }
+};
+export {
+  LinkedListQueue,
+  Queue
+};