data-structure-typed 2.5.0 → 2.5.2

package/dist/leetcode/doubly-linked-list.mjs

@@ -1,709 +0,0 @@
-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 DoublyLinkedListNode = class extends LinkedListNode {
-  static {
-    __name(this, "DoublyLinkedListNode");
-  }
-  constructor(value) {
-    super(value);
-    this._value = value;
-    this._next = void 0;
-    this._prev = void 0;
-  }
-  _next;
-  get next() {
-    return this._next;
-  }
-  set next(value) {
-    this._next = value;
-  }
-  _prev;
-  get prev() {
-    return this._prev;
-  }
-  set prev(value) {
-    this._prev = value;
-  }
-};
-var DoublyLinkedList = class extends LinearLinkedBase {
-  static {
-    __name(this, "DoublyLinkedList");
-  }
-  _equals = Object.is;
-  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 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 fromArray(data) {
-    return new this(data);
-  }
-  isNode(elementNodeOrPredicate) {
-    return elementNodeOrPredicate instanceof DoublyLinkedListNode;
-  }
-  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;
-  }
-  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;
-  }
-  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;
-  }
-  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;
-  }
-  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;
-  }
-  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;
-  }
-  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;
-  }
-  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 =  __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;
-  }
-  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;
-  }
-  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;
-  }
-  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;
-  }
-  setAt(index, value) {
-    const node = this.getNodeAt(index);
-    if (!node) return false;
-    node.value = value;
-    return true;
-  }
-  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(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;
-  }
-  isEmpty() {
-    return this._length === 0;
-  }
-  clear() {
-    this._head = void 0;
-    this._tail = void 0;
-    this._length = 0;
-  }
-  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;
-  }
-  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() {
-    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;
-  }
-  setEquality(equals) {
-    this._equals = equals;
-    return this;
-  }
-  clone() {
-    const out = this._createInstance({ toElementFn: this._toElementFn, maxLen: this._maxLen });
-    for (const v of this) out.push(v);
-    return out;
-  }
-  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;
-  }
-  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(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;
-  }
-  _ensureNode(elementOrNode) {
-    if (this.isNode(elementOrNode)) return elementOrNode;
-    return new DoublyLinkedListNode(elementOrNode);
-  }
-  _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);
-  }
-  _getPrevNode(node) {
-    return node.prev;
-  }
-  _createInstance(options) {
-    const Ctor = this.constructor;
-    return new Ctor([], options);
-  }
-  _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;
-    }
-  }
-};
-export {
-  DoublyLinkedList,
-  DoublyLinkedListNode
-};