@limitlesspc/std 0.21.1 → 0.23.0

package/dist/chunk-DYKZK6B5.js

@@ -1,523 +0,0 @@
-import {
-  swap
-} from "./chunk-65SNM7MP.js";
-import {
-  ascend,
-  descend
-} from "./chunk-TMLWLR46.js";
-
-// src/structs/doubly-linked-list.ts
-var DoublyLinkedList = class _DoublyLinkedList {
-  head;
-  tail;
-  size = 0;
-  static from(values) {
-    const list = new _DoublyLinkedList();
-    for (const value of values) {
-      list.push(value);
-    }
-    return list;
-  }
-  get length() {
-    return this.size;
-  }
-  *[Symbol.iterator]() {
-    let current = this.head;
-    while (current) {
-      yield current.value;
-      current = current.next;
-    }
-  }
-  getNode(index) {
-    let current = this.head;
-    let i = 0;
-    while (current) {
-      if (i === index) {
-        return current;
-      }
-      current = current.next;
-      i++;
-    }
-    return void 0;
-  }
-  get(index) {
-    return this.getNode(index)?.value;
-  }
-  set(index, value) {
-    const node = this.getNode(index);
-    if (!node) {
-      return void 0;
-    }
-    const { value: oldValue } = node;
-    node.value = value;
-    return oldValue;
-  }
-  push(value) {
-    const node = { value };
-    if (this.tail) {
-      this.tail.next = node;
-      this.tail = node;
-    } else {
-      this.head = node;
-      this.tail = node;
-    }
-    return ++this.size;
-  }
-  pop() {
-    if (!this.tail) {
-      return void 0;
-    }
-    const { value } = this.tail;
-    this.tail = this.tail.prev;
-    if (!this.tail) {
-      this.head = void 0;
-    }
-    this.size--;
-    return value;
-  }
-  unshift(value) {
-    const node = { value };
-    if (this.head) {
-      this.head.prev = node;
-      this.head = node;
-    } else {
-      this.head = node;
-      this.tail = node;
-    }
-    return ++this.size;
-  }
-  shift() {
-    if (!this.head) {
-      return void 0;
-    }
-    const { value } = this.head;
-    this.head = this.head.next;
-    if (!this.head) {
-      this.tail = void 0;
-    }
-    this.size--;
-    return value;
-  }
-  reverse() {
-    let current = this.head;
-    let previous;
-    let next;
-    while (current) {
-      ({ next } = current);
-      current.next = previous;
-      current.prev = next;
-      previous = current;
-      current = next;
-    }
-    this.tail = this.head;
-    this.head = previous;
-    return this;
-  }
-  remove(index) {
-    const node = this.getNode(index);
-    if (!node) {
-      return void 0;
-    }
-    if (node.prev) {
-      node.prev.next = node.next;
-    }
-    if (node.next) {
-      node.next.prev = node.prev;
-    }
-    if (node === this.head) {
-      this.head = node.next;
-    }
-    if (node === this.tail) {
-      this.tail = node.prev;
-    }
-    this.size--;
-    return node.value;
-  }
-  splice(index, count, ...values) {
-    const removed = [];
-    for (let i = 0; i < count; i++) {
-      const value = this.remove(index);
-      if (value) {
-        removed.push(value);
-      }
-    }
-    for (const value of values) {
-      this.set(index, value);
-    }
-    return removed;
-  }
-};
-
-// src/structs/heaps/heap.ts
-var Heap = class _Heap {
-  constructor(compare, data = [], heapify = true) {
-    this.compare = compare;
-    if (heapify) {
-      this.data = [];
-      this.push(...data);
-    } else {
-      this.data = data;
-    }
-  }
-  data;
-  get length() {
-    return this.data.length;
-  }
-  get height() {
-    return Math.floor(Math.log2(this.length)) + 1;
-  }
-  valueOf() {
-    return this.peek();
-  }
-  copy() {
-    return new _Heap(this.compare, [...this.data], false);
-  }
-  /**
-   * Returns the first value in the heap
-   */
-  peek() {
-    return this.data[0];
-  }
-  /**
-   * Removes the first value from the heap and returns it
-   */
-  pop() {
-    const first = this.data[0];
-    swap(this.data, 0, this.length - 1);
-    this.data.pop();
-    this.heapify();
-    return first;
-  }
-  /**
-   * Inserts values into the heap and makes sure the first value is the min/max
-   * @param values
-   * @returns The new length of the heap
-   */
-  push(...values) {
-    const { data, compare } = this;
-    for (const value of values) {
-      data.push(value);
-      let i = data.length - 1;
-      let parent = Math.floor((i - 1) / 2);
-      while (i > 0 && compare(data[i], data[parent]) < 0) {
-        swap(data, i, parent);
-        i = parent;
-        parent = Math.floor((i - 1) / 2);
-      }
-    }
-    return data.length;
-  }
-  *drain() {
-    while (this.length) {
-      yield this.pop();
-    }
-  }
-  [Symbol.iterator]() {
-    return this.data.values();
-  }
-  heapify(i = 0) {
-    const { length, compare, data } = this;
-    const left = 2 * i + 1;
-    const right = 2 * i + 2;
-    let largest = i;
-    if (left < length && compare(data[left], data[largest]) < 0) {
-      largest = left;
-    }
-    if (right < length && compare(data[right], data[largest]) < 0) {
-      largest = right;
-    }
-    if (largest !== i) {
-      swap(data, i, largest);
-      this.heapify(largest);
-    }
-  }
-};
-
-// src/structs/heaps/max-heap.ts
-var MaxHeap = class _MaxHeap extends Heap {
-  constructor(data, heapify) {
-    super(descend, data, heapify);
-  }
-  copy() {
-    return new _MaxHeap([...this.data], false);
-  }
-};
-
-// src/structs/heaps/min-heap.ts
-var MinHeap = class _MinHeap extends Heap {
-  constructor(data, heapify) {
-    super(ascend, data, heapify);
-  }
-  copy() {
-    return new _MinHeap([...this.data], false);
-  }
-};
-
-// src/structs/linked-list.ts
-var LinkedList = class _LinkedList {
-  node;
-  static from(values) {
-    const list = new _LinkedList();
-    let node;
-    for (const value of values) {
-      const child = { value };
-      if (node) {
-        node.next = child;
-      }
-      node = child;
-    }
-    list.node = node;
-    return list;
-  }
-  get length() {
-    let { node } = this;
-    let length = 0;
-    while (node) {
-      length++;
-      node = node.next;
-    }
-    return length;
-  }
-  *[Symbol.iterator]() {
-    let { node } = this;
-    while (node) {
-      yield node.value;
-      node = node.next;
-    }
-  }
-  get tail() {
-    let { node } = this;
-    while (node) {
-      node = node.next;
-    }
-    return node;
-  }
-  getNode(index) {
-    let current = this.node;
-    let i = 0;
-    while (current) {
-      if (i === index) {
-        return current;
-      }
-      current = current.next;
-      i++;
-    }
-  }
-  get(index) {
-    return this.getNode(index)?.value;
-  }
-  set(index, value) {
-    const node = this.getNode(index);
-    if (!node) {
-      return;
-    }
-    const { value: oldValue } = node;
-    node.value = value;
-    return oldValue;
-  }
-  push(value) {
-    const { tail } = this;
-    const node = { value };
-    if (tail) {
-      tail.next = node;
-    } else {
-      this.node = node;
-    }
-  }
-  pop() {
-    let current = this.node;
-    let parent;
-    while (current) {
-      if (!current.next) {
-        delete parent?.next;
-        return current;
-      }
-      parent = current;
-      current = current.next;
-    }
-  }
-  unshift(value) {
-    const node = { value };
-    if (this.node) {
-      node.next = this.node;
-      this.node = node;
-    }
-    this.node = node;
-  }
-  shift() {
-    const { node } = this;
-    this.node = node?.next;
-    return node;
-  }
-};
-
-// src/structs/queue.ts
-var Queue = class {
-  constructor(items = []) {
-    this.items = items;
-  }
-  get size() {
-    return this.items.length;
-  }
-  enqueue(item) {
-    return this.items.push(item);
-  }
-  dequeue() {
-    return this.items.shift();
-  }
-  *[Symbol.iterator]() {
-    let item;
-    while (item = this.dequeue()) {
-      yield item;
-    }
-  }
-};
-
-// src/structs/sorted-array.ts
-var SortedArray = class _SortedArray {
-  constructor(data = [], compare = ascend, sort = true) {
-    this.data = data;
-    this.compare = compare;
-    if (sort) {
-      this.data.sort(compare);
-    }
-  }
-  valueOf() {
-    return this.at(0);
-  }
-  keys() {
-    return this.data.keys();
-  }
-  values() {
-    return this.data.values();
-  }
-  entries() {
-    return this.data.entries();
-  }
-  [Symbol.iterator]() {
-    return this.values();
-  }
-  length() {
-    return this.data.length;
-  }
-  at(index) {
-    return this.data[index];
-  }
-  copy() {
-    return new _SortedArray([...this.data], this.compare, false);
-  }
-  /**
-   * Returns the index of the value if it exists, otherwise -1
-   * @param value
-   */
-  indexOf(value) {
-    const { data } = this;
-    let low = 0;
-    let high = data.length - 1;
-    while (low <= high) {
-      const mid = Math.floor((low + high) / 2);
-      const cmp = this.compare(value, data[mid]);
-      if (cmp < 0) {
-        high = mid - 1;
-      } else if (cmp > 0) {
-        low = mid + 1;
-      } else {
-        return mid;
-      }
-    }
-    return -1;
-  }
-  /**
-   * Returns if the array has the value
-   * @param value
-   */
-  has(value) {
-    return this.data.includes(value);
-  }
-  /**
-   * Binary inserts a value into the array while maintaining sorted order
-   * @param value
-   * @returns the index of where the value was inserted
-   */
-  push(value) {
-    const { data, compare } = this;
-    let low = 0;
-    let high = data.length - 1;
-    while (low <= high) {
-      const mid = Math.floor((low + high) / 2);
-      const cmp = compare(value, data[mid]);
-      if (cmp < 0) {
-        high = mid - 1;
-      } else if (cmp > 0) {
-        low = mid + 1;
-      } else {
-        data.splice(mid, 0, value);
-        return mid;
-      }
-    }
-    data.splice(low, 0, value);
-    return low;
-  }
-};
-
-// src/structs/unordered-array.ts
-var UnorderedArray = class _UnorderedArray extends Array {
-  copy() {
-    return new _UnorderedArray(...this);
-  }
-  /**
-   * Inserts new elements at the end of an unordered array, and returns the new length of the unordered array.
-   * @param items Elements to insert at the end of the array.
-   */
-  unshift(...items) {
-    return super.push(...items);
-  }
-  /**
-   * Removes the last element from an array and returns it.
-   * If the array is empty, undefined is returned and the array is not modified.
-   */
-  shift() {
-    return super.pop();
-  }
-  /**
-   * Removes an item by index
-   * @param index the index of the item to remove
-   * @returns the removed item, if it exists
-   */
-  removeIndex(index) {
-    swap(this, index, this.length - 1);
-    return this.pop();
-  }
-  splice(start, deleteCount = this.length - start, ...items) {
-    const spliced = [];
-    for (let i = 0; i < deleteCount; i++) {
-      const replacement = items[i];
-      let removed;
-      if (replacement) {
-        removed = this[start + i];
-        this[start + i] = replacement;
-      } else {
-        removed = this.removeIndex(start);
-      }
-      if (removed) {
-        spliced.push(removed);
-      }
-    }
-    return spliced;
-  }
-  toSpliced(start, deleteCount = this.length - start, ...items) {
-    const copy = this.copy();
-    copy.splice(start, deleteCount, ...items);
-    return copy;
-  }
-};
-
-export {
-  DoublyLinkedList,
-  MaxHeap,
-  MinHeap,
-  LinkedList,
-  Queue,
-  SortedArray,
-  UnorderedArray
-};

package/dist/easing.d.ts

@@ -1,37 +0,0 @@
-/**
- * @module
- * Easing functions
- */
-declare function linear(t: number): number;
-declare function easeInQuad(t: number): number;
-declare function easeOutQuad(t: number): number;
-declare function easeInOutQuad(t: number): number;
-declare function easeInCubic(t: number): number;
-declare function easeOutCubic(t: number): number;
-declare function easeInOutCubic(t: number): number;
-declare function easeInQuart(t: number): number;
-declare function easeOutQuart(t: number): number;
-declare function easeInOutQuart(t: number): number;
-declare function easeInQuint(t: number): number;
-declare function easeOutQuint(t: number): number;
-declare function easeInOutQuint(t: number): number;
-declare function easeInSine(t: number): number;
-declare function easeOutSine(t: number): number;
-declare function easeInOutSine(t: number): number;
-declare function easeInExpo(t: number): number;
-declare function easeOutExpo(t: number): number;
-declare function easeInOutExpo(t: number): number;
-declare function easeInCirc(t: number): number;
-declare function easeOutCirc(t: number): number;
-declare function easeInOutCirc(t: number): number;
-declare function easeInElastic(t: number): number;
-declare function easeOutElastic(t: number): number;
-declare function easeInOutElastic(t: number): number;
-declare function easeInBack(t: number): number;
-declare function easeOutBack(t: number): number;
-declare function easeInOutBack(t: number): number;
-declare function easeInBounce(t: number): number;
-declare function easeOutBounce(t: number): number;
-declare function easeInOutBounce(t: number): number;
-
-export { easeInBack, easeInBounce, easeInCirc, easeInCubic, easeInElastic, easeInExpo, easeInOutBack, easeInOutBounce, easeInOutCirc, easeInOutCubic, easeInOutElastic, easeInOutExpo, easeInOutQuad, easeInOutQuart, easeInOutQuint, easeInOutSine, easeInQuad, easeInQuart, easeInQuint, easeInSine, easeOutBack, easeOutBounce, easeOutCirc, easeOutCubic, easeOutElastic, easeOutExpo, easeOutQuad, easeOutQuart, easeOutQuint, easeOutSine, linear };

package/dist/easing.js

@@ -1,157 +0,0 @@
-// src/easing.ts
-function linear(t) {
-  return t;
-}
-function easeInQuad(t) {
-  return t * t;
-}
-function easeOutQuad(t) {
-  return t * (2 - t);
-}
-function easeInOutQuad(t) {
-  const t2 = 2 * t;
-  return t < 0.5 ? t2 * t : -1 + (4 - t2) * t;
-}
-function easeInCubic(t) {
-  return t * t * t;
-}
-function easeOutCubic(t) {
-  return 1 + --t * t * t;
-}
-function easeInOutCubic(t) {
-  const a = 2 * t - 2;
-  return t < 0.5 ? 4 * t * t * t : (t - 1) * a * a + 1;
-}
-function easeInQuart(t) {
-  const tt = t * t;
-  return tt * tt;
-}
-function easeOutQuart(t) {
-  const tt = --t * t;
-  return 1 - tt * tt;
-}
-function easeInOutQuart(t) {
-  const firstHalf = t < 0.5;
-  const tt = t * t;
-  const a = --t * t;
-  return firstHalf ? 8 * tt * tt : 1 - 8 * a * a;
-}
-function easeInQuint(t) {
-  const tt = t * t;
-  return tt * tt * t;
-}
-function easeOutQuint(t) {
-  const tt = --t * t;
-  return 1 + tt * tt * t;
-}
-function easeInOutQuint(t) {
-  const firstHalf = t < 0.5;
-  const tt = t * t;
-  const a = --t * t;
-  return firstHalf ? 16 * tt * tt * t : 1 + 16 * a * a * t;
-}
-function easeInSine(t) {
-  return 1 - Math.cos(t * Math.PI / 2);
-}
-function easeOutSine(t) {
-  return Math.sin(t * Math.PI / 2);
-}
-function easeInOutSine(t) {
-  return -(Math.cos(t * Math.PI) - 1) / 2;
-}
-function easeInExpo(t) {
-  return t === 0 ? 0 : 2 ** (10 * (t - 1));
-}
-function easeOutExpo(t) {
-  return t === 1 ? 1 : -(2 ** (-10 * t)) + 1;
-}
-function easeInOutExpo(t) {
-  if (t === 0 || t === 1) {
-    return t;
-  }
-  return t < 0.5 ? 2 ** (20 * (t - 1)) / 2 : -(2 ** (-20 * t)) / 2 + 1;
-}
-function easeInCirc(t) {
-  return 1 - Math.sqrt(1 - t * t);
-}
-function easeOutCirc(t) {
-  return Math.sqrt(1 - --t * t);
-}
-function easeInOutCirc(t) {
-  return t < 0.5 ? (1 - Math.sqrt(1 - 2 * t)) / 2 : (Math.sqrt(1 - (t -= 2) * t) + 1) / 2;
-}
-function easeInElastic(t) {
-  if (t === 0 || t === 1) {
-    return t;
-  }
-  return -(2 ** (10 * (t - 1))) * Math.sin((t - 1.1) * 5 * Math.PI);
-}
-function easeOutElastic(t) {
-  if (t === 0 || t === 1) {
-    return t;
-  }
-  return 2 ** (-10 * t) * Math.sin((t - 0.1) * 5 * Math.PI) + 1;
-}
-function easeInOutElastic(t) {
-  if (t === 0 || t === 1) {
-    return t;
-  }
-  return t < 0.5 ? -(2 ** (20 * (t - 1)) * Math.sin((t - 1.1) * 5 * Math.PI)) / 2 : 2 ** (-20 * t) * Math.sin((t - 1.1) * 5 * Math.PI) / 2 + 1;
-}
-function easeInBack(t) {
-  return t * t * (2.70158 * t - 1.70158);
-}
-function easeOutBack(t) {
-  return --t * t * (2.70158 * t + 1.70158) + 1;
-}
-function easeInOutBack(t) {
-  return t < 0.5 ? (2.70158 * t * t * t + 2) / 2 : (1.70158 * (t - 1) * (t - 1) * (t - 1) + 2) / 2;
-}
-function easeInBounce(t) {
-  return 1 - easeOutBounce(1 - t);
-}
-function easeOutBounce(t) {
-  if (t < 1 / 2.75) {
-    return 7.5625 * t * t;
-  }
-  if (t < 2 / 2.75) {
-    return 7.5625 * (t -= 1.5 / 2.75) * t + 0.75;
-  }
-  return t < 2.5 / 2.75 ? 7.5625 * (t -= 2.25 / 2.75) * t + 0.9375 : 7.5625 * (t -= 2.625 / 2.75) * t + 0.984375;
-}
-function easeInOutBounce(t) {
-  return t < 0.5 ? (1 - easeOutBounce(1 - t * 2)) / 2 : (easeOutBounce(t * 2 - 1) + 1) / 2;
-}
-export {
-  easeInBack,
-  easeInBounce,
-  easeInCirc,
-  easeInCubic,
-  easeInElastic,
-  easeInExpo,
-  easeInOutBack,
-  easeInOutBounce,
-  easeInOutCirc,
-  easeInOutCubic,
-  easeInOutElastic,
-  easeInOutExpo,
-  easeInOutQuad,
-  easeInOutQuart,
-  easeInOutQuint,
-  easeInOutSine,
-  easeInQuad,
-  easeInQuart,
-  easeInQuint,
-  easeInSine,
-  easeOutBack,
-  easeOutBounce,
-  easeOutCirc,
-  easeOutCubic,
-  easeOutElastic,
-  easeOutExpo,
-  easeOutQuad,
-  easeOutQuart,
-  easeOutQuint,
-  easeOutSine,
-  linear
-};