@limitlesspc/std 0.20.2

package/dist/chunk-DO4NH5XG.js

@@ -0,0 +1,523 @@
+import {
+  swap
+} from "./chunk-ILLWUQPY.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/chunk-EWSJTMH2.js

@@ -0,0 +1,68 @@
+import {
+  swap,
+  unorderedRemove
+} from "./chunk-ILLWUQPY.js";
+
+// src/random.ts
+function random(min, max) {
+  if (!min) {
+    return Math.random();
+  }
+  if (!max) {
+    return Math.random() * min;
+  }
+  const Min = Math.min(min, max);
+  return (Math.max(min, max) - Min) * Math.random() + Min;
+}
+function randomInt(min = 0, max) {
+  if (typeof max === "number") {
+    return Math.floor(random(min, max + 1));
+  }
+  return Math.floor(random(min + 1));
+}
+function shuffle(array) {
+  for (let { length } = array, i = length - 1; i > 0; i--) {
+    const j = randomInt(i);
+    swap(array, i, j);
+  }
+  return array;
+}
+function choice(array) {
+  return array[randomInt(array.length - 1)];
+}
+function choices(array, n) {
+  if (!array.length || !n) {
+    return [];
+  }
+  if (typeof array === "string") {
+    let result = "";
+    for (let i = 0; i < n; i++) {
+      result += choice(array);
+    }
+    return result;
+  }
+  return Array.from({ length: n }).map(
+    () => array[randomInt(array.length - 1)]
+  );
+}
+function sample(array, n) {
+  const copy = [...array];
+  const result = Array.from({ length: n });
+  for (let i = 0; i < n; i++) {
+    const index = randomInt(copy.length - 1);
+    const item = unorderedRemove(copy, index);
+    if (item) {
+      result[i] = item;
+    }
+  }
+  return result;
+}
+
+export {
+  random,
+  randomInt,
+  shuffle,
+  choice,
+  choices,
+  sample
+};

package/dist/chunk-ILLWUQPY.js

@@ -0,0 +1,139 @@
+import {
+  zip
+} from "./chunk-WBSY6KRH.js";
+import {
+  ascend
+} from "./chunk-TMLWLR46.js";
+
+// src/array.ts
+function swap(array, i, j) {
+  const temp = array[i];
+  array[i] = array[j];
+  array[j] = temp;
+}
+function remove(array, item) {
+  const index = array.indexOf(item);
+  if (index === -1) {
+    return false;
+  }
+  array.splice(index, 1);
+  return true;
+}
+function unorderedRemove(array, index) {
+  swap(array, index, array.length - 1);
+  return array.pop();
+}
+function intersection(...arrays) {
+  const [first, ...rest] = arrays;
+  if (!first) {
+    return [];
+  }
+  return first.filter((item) => rest.every((array) => array.includes(item)));
+}
+function added(oldArray, newArray) {
+  return newArray.filter((value) => !oldArray.includes(value));
+}
+function removed(oldArray, newArray) {
+  return oldArray.filter((value) => !newArray.includes(value));
+}
+function changes(oldArray, newArray) {
+  return [added(oldArray, newArray), removed(oldArray, newArray)];
+}
+function hasChange(a, b) {
+  if (a.length !== b.length) {
+    return true;
+  }
+  for (const item of a) {
+    if (!b.includes(item)) {
+      return true;
+    }
+  }
+  for (const item of b) {
+    if (!a.includes(item)) {
+      return true;
+    }
+  }
+  return false;
+}
+function difference(array1, array2) {
+  const [added2, removed2] = changes(array1, array2);
+  return [...added2, ...removed2];
+}
+function union(...arrays) {
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const array of arrays) {
+    for (const item of array) {
+      if (!seen.has(item)) {
+        seen.add(item);
+        result.push(item);
+      }
+    }
+  }
+  return result;
+}
+function equal(a, b) {
+  if (a.length !== b.length) {
+    return false;
+  }
+  for (const [item1, item2] of zip(a, b)) {
+    if (item1 !== item2) {
+      return false;
+    }
+  }
+  return true;
+}
+function includesAny(a, b) {
+  return b.some((item) => a.includes(item));
+}
+function includesAll(a, b) {
+  return b.every((item) => a.includes(item));
+}
+function dedupe(array, key) {
+  const result = [];
+  const values = /* @__PURE__ */ new Set();
+  for (const item of array) {
+    const value = item[key];
+    if (!values.has(value)) {
+      result.push(item);
+      values.add(value);
+    }
+  }
+  return result;
+}
+function filterByKey(array, key) {
+  return array.filter((item) => item[key]);
+}
+function sortByKeys(array, key, compare = ascend) {
+  return [...array].sort((a, b) => {
+    const keys = Array.isArray(key) ? key : [key];
+    for (const key2 of keys) {
+      const value1 = a[key2];
+      const value2 = b[key2];
+      const cmp = compare(value1, value2);
+      if (cmp) {
+        return cmp;
+      }
+    }
+    return 0;
+  });
+}
+
+export {
+  swap,
+  remove,
+  unorderedRemove,
+  intersection,
+  added,
+  removed,
+  changes,
+  hasChange,
+  difference,
+  union,
+  equal,
+  includesAny,
+  includesAll,
+  dedupe,
+  filterByKey,
+  sortByKeys
+};