@limitlesspc/std 0.20.2

package/dist/chunk-LJSF3QBT.js

@@ -0,0 +1,122 @@
+// src/object.ts
+var hasOwn = (obj, key) => Object.hasOwn(obj, key);
+function shallowEquals(a, b) {
+  if (a === b) {
+    return true;
+  }
+  for (const key in a) {
+    if (hasOwn(a, key) && !hasOwn(b, key)) {
+      return false;
+    }
+  }
+  for (const key in b) {
+    if (hasOwn(b, key) && !hasOwn(a, key)) {
+      return false;
+    }
+  }
+  return true;
+}
+function deepEquals(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (a == null || b == null) {
+    return false;
+  }
+  if (a.constructor !== b.constructor) {
+    return false;
+  }
+  for (const key in a) {
+    if (hasOwn(a, key)) {
+      if (!hasOwn(b, key)) {
+        return false;
+      }
+      if (a[key] === b[key]) {
+        continue;
+      }
+      if (typeof a[key] !== "object") {
+        return false;
+      }
+      if (!deepEquals(a[key], b[key])) {
+        return false;
+      }
+    }
+  }
+  for (const key in b) {
+    if (hasOwn(b, key)) {
+      if (!hasOwn(a, key)) {
+        return false;
+      }
+      if (a[key] === b[key]) {
+        continue;
+      }
+      if (typeof b[key] !== "object") {
+        return false;
+      }
+      if (!deepEquals(a[key], b[key])) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+var objectKeys = Object.keys;
+var objectEntries = Object.entries;
+var objectFromEntries = Object.fromEntries;
+function value2Keys(obj) {
+  const result = {};
+  for (const [key, iter] of objectEntries(obj)) {
+    for (const v of iter) {
+      result[v] ||= [];
+      result[v].push(key);
+    }
+  }
+  return result;
+}
+function objectMap(obj, fn) {
+  return objectFromEntries(
+    // @ts-expect-error have to nudge the type system here
+    objectEntries(obj).map(([key, value]) => [key, fn([key, value])])
+  );
+}
+function deepCopy(object) {
+  if (object == null) {
+    return object;
+  }
+  if (Array.isArray(object)) {
+    return object.map(deepCopy);
+  }
+  if (typeof object !== "object") {
+    return object;
+  }
+  const copy = Object.create(Object.getPrototypeOf(object));
+  for (const key in object) {
+    if (hasOwn(object, key)) {
+      copy[key] = deepCopy(object[key]);
+    }
+  }
+  return copy;
+}
+function pickByKeys(object, keys) {
+  if (Array.isArray(keys)) {
+    const result = {};
+    for (const key of keys) {
+      result[key] = object[key];
+    }
+    return result;
+  }
+  return object[keys];
+}
+
+export {
+  hasOwn,
+  shallowEquals,
+  deepEquals,
+  objectKeys,
+  objectEntries,
+  objectFromEntries,
+  value2Keys,
+  objectMap,
+  deepCopy,
+  pickByKeys
+};

package/dist/chunk-MG5VQSTV.js

@@ -0,0 +1,89 @@
+// src/fn/pipe.ts
+var pipe = (x, ...fns) => fns.reduce((x2, fn) => fn(x2), x);
+var asyncPipe = async (x, ...fns) => {
+  for (const fn of fns) {
+    x = fn(await x);
+  }
+  return x;
+};
+
+// src/fn/reverse-curry.ts
+var reverseCurry = (fn) => (
+  // @ts-expect-error funky type maneuvering
+  (...args) => {
+    if (args.length === fn.length) {
+      return fn(...args);
+    }
+    return (first) => fn(first, ...args);
+  }
+);
+
+// src/fn/index.ts
+var noop = () => {
+};
+var identity = (x) => x;
+var constant = (x) => () => x;
+function once(fn) {
+  let called = false;
+  let result;
+  return () => {
+    if (called) {
+      return;
+    }
+    result = fn();
+    called = true;
+    return result;
+  };
+}
+function memoize(func) {
+  const cache = /* @__PURE__ */ new Map();
+  return (arg) => {
+    if (cache.has(arg)) {
+      return cache.get(arg);
+    }
+    const output = func(arg);
+    cache.set(arg, output);
+    return output;
+  };
+}
+function memo(fn) {
+  let cache;
+  let called = false;
+  const memoized = () => {
+    if (called) {
+      return cache;
+    }
+    cache = fn();
+    called = true;
+    return cache;
+  };
+  memoized.invalidate = () => called = false;
+  return memoized;
+}
+function ttlCache(fn, ttl) {
+  let cache;
+  let called = false;
+  let lastCalled = performance.now();
+  return () => {
+    if (called && performance.now() - lastCalled < ttl) {
+      return cache;
+    }
+    cache = fn();
+    called = true;
+    lastCalled = performance.now();
+    return cache;
+  };
+}
+
+export {
+  pipe,
+  asyncPipe,
+  reverseCurry,
+  noop,
+  identity,
+  constant,
+  once,
+  memoize,
+  memo,
+  ttlCache
+};

package/dist/chunk-TMLWLR46.js

@@ -0,0 +1,12 @@
+// src/cmp.ts
+var ascend = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+var descend = (a, b) => -ascend(a, b);
+var ascendBy = (f) => (a, b) => ascend(f(a), f(b));
+var descendBy = (f) => (a, b) => descend(f(a), f(b));
+
+export {
+  ascend,
+  descend,
+  ascendBy,
+  descendBy
+};

package/dist/chunk-WBSY6KRH.js

@@ -0,0 +1,358 @@
+import {
+  reverseCurry
+} from "./chunk-MG5VQSTV.js";
+import {
+  pickByKeys
+} from "./chunk-LJSF3QBT.js";
+
+// src/iter/associate-by.ts
+var associateBy = reverseCurry(
+  (array, key) => {
+    const map3 = /* @__PURE__ */ new Map();
+    for (const item of array) {
+      map3[item[key]] = item;
+    }
+    return map3;
+  }
+);
+
+// src/iter/chain.ts
+function* chain(...iterables) {
+  for (const iterable of iterables) {
+    yield* iterable;
+  }
+}
+
+// src/iter/chunk.ts
+var chunk = reverseCurry(function* chunk2(iter, size) {
+  let result = [];
+  for (const value of iter) {
+    result.push(value);
+    if (result.length === size) {
+      yield result;
+      result = [];
+    }
+  }
+  if (result.length) {
+    yield result;
+  }
+});
+
+// src/iter/collect.ts
+function collect(iter) {
+  return [...iter];
+}
+
+// src/iter/count.ts
+function count(iter) {
+  let count2 = 0;
+  for (const _ of iter) {
+    count2++;
+  }
+  return count2;
+}
+
+// src/iter/cycle.ts
+function* cycle(iter) {
+  const values = [];
+  for (const value of iter) {
+    yield value;
+    values.push(value);
+  }
+  while (values.length) {
+    for (const value of values) {
+      yield value;
+    }
+  }
+}
+
+// src/iter/enumerate.ts
+function* enumerate(iter) {
+  let i = 0;
+  for (const value of iter) {
+    yield [i++, value];
+  }
+}
+
+// src/iter/every.ts
+var every = reverseCurry((iter, predicate) => {
+  for (const item of iter) {
+    if (!predicate(item)) {
+      return false;
+    }
+  }
+  return true;
+});
+
+// src/iter/filter.ts
+var filter = reverseCurry(function* filter2(iter, predicate) {
+  for (const value of iter) {
+    if (predicate(value)) {
+      yield value;
+    }
+  }
+});
+var filterByKey = reverseCurry(function* filterByKey2(iter, key) {
+  for (const value of iter) {
+    if (value[key]) {
+      yield value;
+    }
+  }
+});
+
+// src/iter/first.ts
+function first(iter) {
+  const result = iter[Symbol.iterator]().next();
+  if (!result.done) {
+    return result.value;
+  }
+}
+
+// src/iter/group-by.ts
+var groupBy = reverseCurry(
+  (array, key) => {
+    const groups = /* @__PURE__ */ new Map();
+    for (const item of array) {
+      const value = item[key];
+      const group = groups.get(value);
+      if (group) {
+        group.push(item);
+      } else {
+        groups.set(value, [item]);
+      }
+    }
+    return groups;
+  }
+);
+
+// src/iter/intersperse.ts
+var intersperse = reverseCurry(function* intersperse2(iter, separator) {
+  let first2 = true;
+  for (const value of iter) {
+    if (first2) {
+      first2 = false;
+    } else {
+      yield separator;
+    }
+    yield value;
+  }
+});
+
+// src/iter/last.ts
+function last(iter) {
+  let last2;
+  for (const value of iter) {
+    last2 = value;
+  }
+  return last2;
+}
+
+// src/iter/map.ts
+var map = reverseCurry(function* map2(iter, fn) {
+  for (const item of iter) {
+    yield fn(item);
+  }
+});
+
+// src/iter/nth.ts
+var nth = reverseCurry((iter, n) => {
+  let i = 0;
+  for (const value of iter) {
+    if (i++ === n) {
+      return value;
+    }
+  }
+});
+
+// src/iter/partition.ts
+var partition = reverseCurry(
+  (iter, predicate) => {
+    const pass = [];
+    const fail = [];
+    for (const item of iter) {
+      if (predicate(item)) {
+        pass.push(item);
+      } else {
+        fail.push(item);
+      }
+    }
+    return [pass, fail];
+  }
+);
+
+// src/iter/pick.ts
+var pick = reverseCurry(function* pick2(iter, keys) {
+  if (Array.isArray(keys)) {
+    for (const item of iter) {
+      yield pickByKeys(item, keys);
+    }
+  } else {
+    for (const item of iter) {
+      yield item[keys];
+    }
+  }
+});
+
+// src/iter/range.ts
+function* range(min, max, step = 1) {
+  if (max === void 0) {
+    yield* range(0, min);
+  } else {
+    const absStep = Math.abs(step);
+    if (max > min) {
+      for (let i = min; i < max; i += absStep) {
+        yield i;
+      }
+    } else {
+      for (let i = min; i > max; i -= absStep) {
+        yield i;
+      }
+    }
+  }
+}
+
+// src/iter/skip.ts
+var skip = reverseCurry(function* skip2(iter, n) {
+  let count2 = 0;
+  for (const value of iter) {
+    if (++count2 > n) {
+      yield value;
+    }
+  }
+});
+
+// src/iter/sliding-window.ts
+var slidingWindow = reverseCurry(function* slidingWindow2(iter, { size, partial }) {
+  const window = [];
+  for (const value of iter) {
+    window.push(value);
+    if (window.length > size) {
+      window.shift();
+    }
+    if (window.length === size || partial) {
+      yield [...window];
+    }
+  }
+  if (partial) {
+    while (window.length > 1) {
+      window.shift();
+      yield [...window];
+    }
+  }
+});
+
+// src/iter/some.ts
+var some = reverseCurry((iter, predicate) => {
+  for (const item of iter) {
+    if (predicate(item)) {
+      return true;
+    }
+  }
+  return false;
+});
+
+// src/iter/take.ts
+var take = reverseCurry(function* take2(iter, n) {
+  let count2 = 0;
+  for (const value of iter) {
+    if (count2++ < n) {
+      yield value;
+    } else {
+      break;
+    }
+  }
+});
+
+// src/iter/tap.ts
+var tap = reverseCurry(function* tap2(iter, fn) {
+  for (const value of iter) {
+    fn(value);
+    yield value;
+  }
+});
+
+// src/iter/tee.ts
+var tee = reverseCurry((iter, n) => {
+  const values = [...iter];
+  return [...map(range(n ?? 2), () => values[Symbol.iterator]())];
+});
+
+// src/iter/unique.ts
+var unique = reverseCurry(function* unique2(iter) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of iter) {
+    if (!seen.has(item)) {
+      seen.add(item);
+      yield item;
+    }
+  }
+});
+var uniqueBy = reverseCurry(function* uniqueBy2(iter, keyFn) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of iter) {
+    const key = keyFn(item);
+    if (!seen.has(key)) {
+      seen.add(key);
+      yield item;
+    }
+  }
+});
+
+// src/iter/unzip.ts
+var unzip = reverseCurry((iterable) => {
+  const array1 = [];
+  const array2 = [];
+  let i = 0;
+  for (const [a, b] of iterable) {
+    array1[i] = a;
+    array2[i] = b;
+    i++;
+  }
+  return [array1, array2];
+});
+
+// src/iter/zip.ts
+var zip = reverseCurry(function* zip2(iterable1, iterable2) {
+  const iter1 = iterable1[Symbol.iterator]();
+  const iter2 = iterable2[Symbol.iterator]();
+  while (true) {
+    const result1 = iter1.next();
+    const result2 = iter2.next();
+    if (result1.done || result2.done) {
+      break;
+    }
+    yield [result1.value, result2.value];
+  }
+});
+
+export {
+  associateBy,
+  chain,
+  chunk,
+  collect,
+  count,
+  cycle,
+  enumerate,
+  every,
+  filter,
+  filterByKey,
+  first,
+  groupBy,
+  intersperse,
+  last,
+  map,
+  nth,
+  partition,
+  pick,
+  range,
+  skip,
+  slidingWindow,
+  some,
+  take,
+  tap,
+  tee,
+  unique,
+  uniqueBy,
+  unzip,
+  zip
+};

package/dist/cmath/index.d.ts

@@ -0,0 +1,57 @@
+interface ComplexLike {
+    readonly r: number;
+    readonly i: number;
+}
+declare class Complex implements ComplexLike {
+    r: number;
+    i: number;
+    constructor(r?: number, i?: number);
+    toString(): string;
+    valueOf(): number;
+    copy(): Complex;
+    get conj(): Complex;
+    static fromAngle(angle: number, mag?: number): Complex;
+    isReal(): boolean;
+    add(c: number | ComplexLike): this;
+    static add(c1: Complex, c2: number | ComplexLike): Complex;
+    sub(c: number | ComplexLike): this;
+    static sub(c1: Complex, c2: number | ComplexLike): Complex;
+    mul(c: number | ComplexLike): this;
+    static mul(c1: Complex, c2: number | ComplexLike): Complex;
+    div(c: number | Complex): this;
+    static div(c1: Complex, c2: number | Complex): Complex;
+    sq(): this;
+    mag(): number;
+    magSq(): number;
+    angle(): number;
+    pow(z: ComplexLike): this;
+}
+declare function complex(real?: number, imaginary?: number): Complex;
+
+/**
+ * Solves ax² + bx + c = 0 for x. In other words, finds the roots of a quadratic equation.
+ * @param a the coefficient of x²
+ * @param b the coefficient of x
+ * @param c the constant
+ * @returns An array of roots for the quadratic equation. Any imaginary roots will be NaN.
+ */
+declare function cquadraticRoots(a: number, b: number, c: number): [Complex, Complex];
+
+declare function csqrt(z: Complex): Complex;
+declare function clog(z: Complex): Complex;
+declare const cln: typeof clog;
+declare function cexp({ r, i }: ComplexLike): Complex;
+declare function csin({ r, i }: ComplexLike): Complex;
+declare function ccos({ r, i }: ComplexLike): Complex;
+declare function ctan(z: ComplexLike): Complex;
+declare function casin({ r, i }: ComplexLike): Complex;
+declare function cacos({ r, i }: ComplexLike): Complex;
+declare function catan({ r, i }: ComplexLike): Complex;
+declare function csinh({ r, i }: ComplexLike): Complex;
+declare function ccosh({ r, i }: ComplexLike): Complex;
+declare function ctanh(z: ComplexLike): Complex;
+declare function casinh({ r, i }: ComplexLike): Complex;
+declare function cacosh({ r, i }: ComplexLike): Complex;
+declare function catanh({ r, i }: ComplexLike): Complex;
+
+export { Complex, type ComplexLike, cacos, cacosh, casin, casinh, catan, catanh, ccos, ccosh, cexp, cln, clog, complex, cquadraticRoots, csin, csinh, csqrt, ctan, ctanh };