@limitlesspc/std 0.23.5 → 0.24.0

package/dist/array.d.ts

@@ -124,18 +124,6 @@ declare function difference<T>(array1: readonly T[], array2: readonly T[]): T[];
  * ```
  */
 declare function union<T>(...arrays: Array<Iterable<T>>): T[];
-/**
- * Test if two arrays contain the same items in the same order
- * @param a
- * @param b
- * @returns if the arrays are equal
- * @example
- * ```ts
- * console.log(equal([1, 2, 3], [1, 2, 3])); // true
- * console.log(equal([1, 2, 3], [3, 2, 1])); // false
- * ```
- */
-declare function equal<T>(a: readonly T[], b: readonly T[]): boolean;
 /**
  * Check if an array contains at least one of the items in another
  * @param a the array to check
@@ -198,32 +186,7 @@ declare function dedupe<T>(array: Iterable<T>): T[];
  * // "dog",
  * // ]
  */
-declare function dedupeBy<T>(array: Iterable<T>, key: (item: T) => any): T[];
-/**
- * Returns a new array with items with a unique key
- * @param array
- * @param key
- * @example
- * ```ts
- * const array = [
- *   { id: 1, name: "Alice" },
- *   { id: 2, name: "Bob" },
- *   { id: 1, name: "Charlie" },
- *   { id: 3, name: "David" },
- *   { id: 2, name: "Eve" },
- *   { id: 4, name: "Frank" },
- * ];
- * console.log(dedupeByKey(array, "id")); // [
- * // { id: 1, name: "Alice" },
- * // { id: 2, name: "Bob" },
- * // { id: 3, name: "David" },
- * // { id: 4, name: "Frank" }
- * // ]
- */
-declare function dedupeByKey<T extends {
-    [K in keyof T]: T[K];
-}>(array: Iterable<T>, key: keyof T): T[];
-declare function filterByKey<T>(array: readonly T[], key: keyof T): T[];
+declare function dedupeBy<T, U>(array: Iterable<T>, callback: (item: T) => U): T[];
 /**
  * Sorts an array of objects by the value of a key
  * @param array
@@ -245,4 +208,4 @@ declare function filterByKey<T>(array: readonly T[], key: keyof T): T[];
  */
 declare function sortByKeys<T, K extends keyof T>(array: readonly T[], key: MaybeArray<K>, compare?: Compare<T[K]>): T[];
 
-export { added, changes, dedupe, dedupeBy, dedupeByKey, difference, equal, filterByKey, hasChange, includesAll, includesAny, intersection, remove, removed, sortByKeys, swap, union, unorderedRemove };
+export { added, changes, dedupe, dedupeBy, difference, hasChange, includesAll, includesAny, intersection, remove, removed, sortByKeys, swap, union, unorderedRemove };

package/dist/array.js

@@ -3,10 +3,7 @@ import {
   changes,
   dedupe,
   dedupeBy,
-  dedupeByKey,
   difference,
-  equal,
-  filterByKey,
   hasChange,
   includesAll,
   includesAny,
@@ -17,20 +14,14 @@ import {
   swap,
   union,
   unorderedRemove
-} from "./chunk-4POIKW4G.js";
-import "./chunk-CCBSTDYA.js";
-import "./chunk-NXILTE26.js";
+} from "./chunk-IZDNCBBO.js";
 import "./chunk-TMLWLR46.js";
-import "./chunk-LJSF3QBT.js";
 export {
   added,
   changes,
   dedupe,
   dedupeBy,
-  dedupeByKey,
   difference,
-  equal,
-  filterByKey,
   hasChange,
   includesAll,
   includesAny,

package/dist/bytes.js

@@ -8,10 +8,10 @@ var MEBIBYTE = 1024 * KIBIBYTE;
 var GIBIBYTE = 1024 * MEBIBYTE;
 var TEBIBYTE = 1024 * GIBIBYTE;
 function hex(buffer) {
-  const hexCodes = [];
-  for (const element of buffer) {
-    hexCodes.push(element.toString(16).padStart(2, "0"));
-  }
+  const hexCodes = Array.from(
+    buffer,
+    (element) => element.toString(16).padStart(2, "0")
+  );
   return hexCodes.join("");
 }
 function unhex(hex2) {

package/dist/{chunk-NXILTE26.js → chunk-7LRKWWT5.js}

@@ -57,7 +57,9 @@ function memo(fn) {
     called = true;
     return cache;
   };
-  memoized.invalidate = () => called = false;
+  memoized.invalidate = () => {
+    called = false;
+  };
   return memoized;
 }
 function ttlCache(fn, ttl) {

package/dist/{chunk-4POIKW4G.js → chunk-IZDNCBBO.js}

@@ -1,6 +1,3 @@
-import {
-  zip
-} from "./chunk-CCBSTDYA.js";
 import {
   ascend
 } from "./chunk-TMLWLR46.js";
@@ -72,17 +69,6 @@ function union(...arrays) {
   }
   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));
 }
@@ -92,11 +78,11 @@ function includesAll(a, b) {
 function dedupe(array) {
   return dedupeBy(array, (x) => x);
 }
-function dedupeBy(array, key) {
+function dedupeBy(array, callback) {
   const result = [];
   const seen = /* @__PURE__ */ new Set();
   for (const item of array) {
-    const value = key(item);
+    const value = callback(item);
     if (!seen.has(value)) {
       result.push(item);
       seen.add(value);
@@ -104,12 +90,6 @@ function dedupeBy(array, key) {
   }
   return result;
 }
-function dedupeByKey(array, key) {
-  return dedupeBy(array, (x) => x[key]);
-}
-function filterByKey(array, key) {
-  return array.filter((item) => item[key]);
-}
 function sortByKeys(array, key, compare = ascend) {
   return array.toSorted((a, b) => {
     const keys = Array.isArray(key) ? key : [key];
@@ -136,12 +116,9 @@ export {
   hasChange,
   difference,
   union,
-  equal,
   includesAny,
   includesAll,
   dedupe,
   dedupeBy,
-  dedupeByKey,
-  filterByKey,
   sortByKeys
 };

package/dist/{chunk-4AJ6WSEF.js → chunk-LPLI3P2H.js}

@@ -1,21 +1,21 @@
-import {
-  random
-} from "./chunk-ZAXC26KZ.js";
 import {
   chunk,
   collect,
   filter,
   map,
   range
-} from "./chunk-CCBSTDYA.js";
+} from "./chunk-XEPJIWIE.js";
 import {
   pipe,
   reverseCurry
-} from "./chunk-NXILTE26.js";
+} from "./chunk-7LRKWWT5.js";
+import {
+  random
+} from "./chunk-OMJMLVK3.js";
 
 // src/math/stats.ts
 function min(iter) {
-  let min2 = Number.POSITIVE_INFINITY;
+  let min2 = Infinity;
   for (const value of iter) {
     if (value < min2) {
       min2 = value;
@@ -24,7 +24,7 @@ function min(iter) {
   return min2;
 }
 function max(iter) {
-  let max2 = Number.NEGATIVE_INFINITY;
+  let max2 = -Infinity;
   for (const value of iter) {
     if (value > max2) {
       max2 = value;
@@ -33,8 +33,8 @@ function max(iter) {
   return max2;
 }
 function minmax(iter) {
-  let min2 = Number.POSITIVE_INFINITY;
-  let max2 = Number.NEGATIVE_INFINITY;
+  let min2 = Infinity;
+  let max2 = -Infinity;
   for (const value of iter) {
     if (value < min2) {
       min2 = value;

package/dist/{chunk-ZAXC26KZ.js → chunk-OMJMLVK3.js}

@@ -1,7 +1,7 @@
 import {
   swap,
   unorderedRemove
-} from "./chunk-4POIKW4G.js";
+} from "./chunk-IZDNCBBO.js";
 
 // src/random.ts
 function random(min, max) {
@@ -32,7 +32,7 @@ function choice(array) {
   return array[randomInt(array.length - 1)];
 }
 function choices(array, n) {
-  if (!array.length || !n) {
+  if (array.length === 0 || !n) {
     return [];
   }
   if (typeof array === "string") {
@@ -50,9 +50,9 @@ function sample(array, n) {
   const copy = [...array];
   const results = [];
   for (let i = 0; i < n; i++) {
-    const index = randomInt(copy.length - 1);
-    const item = unorderedRemove(copy, index);
-    if (item) {
+    if (copy.length > 0) {
+      const index = randomInt(copy.length - 1);
+      const item = unorderedRemove(copy, index);
       results.push(item);
     }
   }

package/dist/{chunk-LJSF3QBT.js → chunk-XCUELLWZ.js}

@@ -4,6 +4,9 @@ function shallowEquals(a, b) {
   if (a === b) {
     return true;
   }
+  if (a == null || b == null) {
+    return false;
+  }
   for (const key in a) {
     if (hasOwn(a, key) && !hasOwn(b, key)) {
       return false;
@@ -73,10 +76,9 @@ function value2Keys(obj) {
   }
   return result;
 }
-function objectMap(obj, fn) {
+function objectMap(obj, callback) {
   return objectFromEntries(
-    // @ts-expect-error have to nudge the type system here
-    objectEntries(obj).map(([key, value]) => [key, fn([key, value])])
+    objectEntries(obj).map(([key, value]) => callback([key, value]))
   );
 }
 function deepCopy(object) {

package/dist/{chunk-CCBSTDYA.js → chunk-XEPJIWIE.js}

@@ -1,20 +1,19 @@
 import {
   reverseCurry
-} from "./chunk-NXILTE26.js";
+} from "./chunk-7LRKWWT5.js";
 import {
   pickByKeys
-} from "./chunk-LJSF3QBT.js";
+} from "./chunk-XCUELLWZ.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;
+var associateBy = reverseCurry((array, callback) => {
+  const map3 = /* @__PURE__ */ new Map();
+  for (const item of array) {
+    const key = callback(item);
+    map3.set(key, item);
   }
-);
+  return map3;
+});
 
 // src/iter/chain.ts
 function* chain(...iterables) {
@@ -33,7 +32,7 @@ var chunk = reverseCurry(function* chunk2(iter, size) {
       result = [];
     }
   }
-  if (result.length) {
+  if (result.length > 0) {
     yield result;
   }
 });
@@ -59,7 +58,7 @@ function* cycle(iter) {
     yield value;
     values.push(value);
   }
-  while (values.length) {
+  while (values.length > 0) {
     for (const value of values) {
       yield value;
     }
@@ -92,13 +91,6 @@ var filter = reverseCurry(function* filter2(iter, predicate) {
     }
   }
 });
-var filterByKey = reverseCurry(function* filterByKey2(iter, key) {
-  for (const value of iter) {
-    if (value[key]) {
-      yield value;
-    }
-  }
-});
 
 // src/iter/first.ts
 function first(iter) {
@@ -109,21 +101,19 @@ function first(iter) {
 }
 
 // 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]);
-      }
+var groupBy = reverseCurry((array, callback) => {
+  const groups = /* @__PURE__ */ new Map();
+  for (const item of array) {
+    const key = callback(item);
+    const group = groups.get(key);
+    if (group) {
+      group.push(item);
+    } else {
+      groups.set(key, [item]);
     }
-    return groups;
   }
-);
+  return groups;
+});
 
 // src/iter/intersperse.ts
 var intersperse = reverseCurry(function* intersperse2(iter, separator) {
@@ -335,7 +325,6 @@ export {
   enumerate,
   every,
   filter,
-  filterByKey,
   first,
   groupBy,
   intersperse,

package/dist/csv.d.ts

@@ -1,3 +1,4 @@
 declare function formatCsv(rows: any[][]): string;
+declare function parseCsv(csv: string): string[][];
 
-export { formatCsv };
+export { formatCsv, parseCsv };

package/dist/csv.js

@@ -3,7 +3,7 @@ var specialCharRegex = /[\n",]/;
 function formatCsv(rows) {
   return rows.map(
     (row) => row.map((value) => {
-      const str = `${value}`;
+      const str = String(value);
       if (specialCharRegex.test(str)) {
         return `"${str.replaceAll('"', '""')}"`;
       }
@@ -11,6 +11,56 @@ function formatCsv(rows) {
     }).join(",")
   ).join("\n");
 }
+function parseCsv(csv) {
+  const data = [];
+  let inStr = false;
+  let char = "";
+  let cell = "";
+  let row = [];
+  for (let i = 0; i < csv.length; i++) {
+    char = csv[i];
+    if (!inStr) {
+      switch (char) {
+        case ",": {
+          row.push(cell);
+          cell = "";
+          break;
+        }
+        case "\n": {
+          row.push(cell);
+          data.push(row);
+          row = [];
+          cell = "";
+          break;
+        }
+        case '"': {
+          inStr = true;
+          break;
+        }
+        default: {
+          cell += char;
+        }
+      }
+    } else if (char === '"') {
+      if (csv[i + 1] === '"') {
+        cell += char;
+        i++;
+      } else {
+        inStr = false;
+      }
+    } else {
+      cell += char;
+    }
+  }
+  if (cell.length > 0 || char === "," || char === "\n") {
+    row.push(cell);
+  }
+  if (row.length > 0) {
+    data.push(row);
+  }
+  return data;
+}
 export {
-  formatCsv
+  formatCsv,
+  parseCsv
 };

package/dist/easing.d.ts

@@ -0,0 +1,15 @@
+declare function linear(t: number): number;
+declare function quadIn(t: number): number;
+declare function quadOut(t: number): number;
+declare function quadInOut(t: number): number;
+declare function cubicIn(t: number): number;
+declare function cubicOut(t: number): number;
+declare function cubicInOut(t: number): number;
+declare function quartIn(t: number): number;
+declare function quartOut(t: number): number;
+declare function quartInOut(t: number): number;
+declare function quintIn(t: number): number;
+declare function quintOut(t: number): number;
+declare function quintInOut(t: number): number;
+
+export { cubicIn, cubicInOut, cubicOut, linear, quadIn, quadInOut, quadOut, quartIn, quartInOut, quartOut, quintIn, quintInOut, quintOut };

package/dist/easing.js

@@ -0,0 +1,67 @@
+// src/easing.ts
+function linear(t) {
+  return t;
+}
+function quadIn(t) {
+  return t * t;
+}
+function quadOut(t) {
+  return t * (2 - t);
+}
+function quadInOut(t) {
+  if (t < 0.5) {
+    return 2 * t * t;
+  }
+  return 1 - 2 * --t * t;
+}
+function cubicIn(t) {
+  return t * t * t;
+}
+function cubicOut(t) {
+  return --t * t * t + 1;
+}
+function cubicInOut(t) {
+  if (t < 0.5) {
+    return 4 * t * t * t;
+  }
+  return 4 * --t * t * t + 1;
+}
+function quartIn(t) {
+  return t * t * t * t;
+}
+function quartOut(t) {
+  return 1 - --t * t * t * t;
+}
+function quartInOut(t) {
+  if (t < 0.5) {
+    return 8 * t * t * t * t;
+  }
+  return 1 - 8 * --t * t * t * t;
+}
+function quintIn(t) {
+  return t * t * t * t * t;
+}
+function quintOut(t) {
+  return --t * t * t * t * t + 1;
+}
+function quintInOut(t) {
+  if (t < 0.5) {
+    return 16 * t * t * t * t * t;
+  }
+  return 16 * --t * t * t * t * t + 1;
+}
+export {
+  cubicIn,
+  cubicInOut,
+  cubicOut,
+  linear,
+  quadIn,
+  quadInOut,
+  quadOut,
+  quartIn,
+  quartInOut,
+  quartOut,
+  quintIn,
+  quintInOut,
+  quintOut
+};

package/dist/events.js

@@ -1,16 +1,16 @@
 import {
   sum
-} from "./chunk-4AJ6WSEF.js";
-import "./chunk-ZAXC26KZ.js";
-import "./chunk-4POIKW4G.js";
+} from "./chunk-LPLI3P2H.js";
 import {
   pick
-} from "./chunk-CCBSTDYA.js";
+} from "./chunk-XEPJIWIE.js";
 import {
   pipe
-} from "./chunk-NXILTE26.js";
+} from "./chunk-7LRKWWT5.js";
+import "./chunk-XCUELLWZ.js";
+import "./chunk-OMJMLVK3.js";
+import "./chunk-IZDNCBBO.js";
 import "./chunk-TMLWLR46.js";
-import "./chunk-LJSF3QBT.js";
 
 // src/events.ts
 var EventEmitter = class {

package/dist/fn/index.js

@@ -9,7 +9,7 @@ import {
   pipe,
   reverseCurry,
   ttlCache
-} from "../chunk-NXILTE26.js";
+} from "../chunk-7LRKWWT5.js";
 export {
   asyncPipe,
   constant,

package/dist/gfx/index.js

@@ -1,12 +1,12 @@
 import {
   vec3
-} from "../chunk-4AJ6WSEF.js";
-import "../chunk-ZAXC26KZ.js";
-import "../chunk-4POIKW4G.js";
-import "../chunk-CCBSTDYA.js";
-import "../chunk-NXILTE26.js";
+} from "../chunk-LPLI3P2H.js";
+import "../chunk-XEPJIWIE.js";
+import "../chunk-7LRKWWT5.js";
+import "../chunk-XCUELLWZ.js";
+import "../chunk-OMJMLVK3.js";
+import "../chunk-IZDNCBBO.js";
 import "../chunk-TMLWLR46.js";
-import "../chunk-LJSF3QBT.js";
 
 // src/gfx/color.ts
 function hsv2rgb(h, s, v) {

package/dist/iter/index.d.ts

@@ -1,8 +1,8 @@
-import { AnyRecord, uint, Repeat, NonFalsy, int } from '../types.js';
+import { uint, Repeat, NonFalsy, AnyRecord, int } from '../types.js';
 
 declare const associateBy: {
-    <T extends AnyRecord, K extends keyof T>(first: Iterable<T>, key: K): Map<T[K], T>;
-    <T extends AnyRecord, K extends keyof T>(key: K): (first: Iterable<T>) => Map<T[K], T>;
+    <T, U>(first: Iterable<T>, callback: (item: T) => U): Map<U, T>;
+    <T, U>(callback: (item: T) => U): (first: Iterable<T>) => Map<U, T>;
 };
 
 /**
@@ -66,10 +66,6 @@ declare const filter: {
     <T>(iter: Iterable<T>, predicate: (value: T) => unknown): Generator<T>;
     <T>(predicate: (value: T) => unknown): (iter: Iterable<T>) => Generator<T>;
 };
-declare const filterByKey: {
-    <T extends AnyRecord>(iter: Iterable<T>, key: keyof T): Generator<T>;
-    <T extends AnyRecord>(key: keyof T): (iter: Iterable<T>) => Generator<T>;
-};
 
 /**
  * Returns the first value of an iterable
@@ -78,8 +74,8 @@ declare const filterByKey: {
 declare function first<T>(iter: Iterable<T>): T | undefined;
 
 declare const groupBy: {
-    <T extends AnyRecord, K extends keyof T>(first: Iterable<T>, key: K): Map<T[K], T[]>;
-    <T extends AnyRecord, K extends keyof T>(key: K): (first: Iterable<T>) => Map<T[K], T[]>;
+    <T, U>(first: Iterable<T>, callback: (item: T) => U): Map<U, T[]>;
+    <T, U>(callback: (item: T) => U): (first: Iterable<T>) => Map<U, T[]>;
 };
 
 /**
@@ -223,4 +219,4 @@ declare const zip: {
     <T, U>(iterable2: Iterable<U>): (iterable1: Iterable<T>) => Generator<[T, U]>;
 };
 
-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 };
+export { associateBy, chain, chunk, collect, count, cycle, enumerate, every, filter, first, groupBy, intersperse, last, map, nth, partition, pick, range, skip, slidingWindow, some, take, tap, tee, unique, uniqueBy, unzip, zip };

package/dist/iter/index.js

@@ -8,7 +8,6 @@ import {
   enumerate,
   every,
   filter,
-  filterByKey,
   first,
   groupBy,
   intersperse,
@@ -28,9 +27,9 @@ import {
   uniqueBy,
   unzip,
   zip
-} from "../chunk-CCBSTDYA.js";
-import "../chunk-NXILTE26.js";
-import "../chunk-LJSF3QBT.js";
+} from "../chunk-XEPJIWIE.js";
+import "../chunk-7LRKWWT5.js";
+import "../chunk-XCUELLWZ.js";
 export {
   associateBy,
   chain,
@@ -41,7 +40,6 @@ export {
   enumerate,
   every,
   filter,
-  filterByKey,
   first,
   groupBy,
   intersperse,

package/dist/math/index.js

@@ -55,13 +55,13 @@ import {
   vec2,
   vec3,
   vec4
-} from "../chunk-4AJ6WSEF.js";
-import "../chunk-ZAXC26KZ.js";
-import "../chunk-4POIKW4G.js";
-import "../chunk-CCBSTDYA.js";
-import "../chunk-NXILTE26.js";
+} from "../chunk-LPLI3P2H.js";
+import "../chunk-XEPJIWIE.js";
+import "../chunk-7LRKWWT5.js";
+import "../chunk-XCUELLWZ.js";
+import "../chunk-OMJMLVK3.js";
+import "../chunk-IZDNCBBO.js";
 import "../chunk-TMLWLR46.js";
-import "../chunk-LJSF3QBT.js";
 export {
   DEG2RAD,
   Mat,

package/dist/object.d.ts

@@ -3,7 +3,7 @@
  * Functions for working with objects
  */
 /**
- * Determines if an object has a property. This is simply a type-safe wrapper around `Object.prototype.hasOwnProperty`
+ * Determines if an object has a property. This is simply a type-safe wrapper around `Object.hasOwn`
  * @param obj The object
  * @param key The property key
  * @returns true if the object has the property
@@ -14,7 +14,7 @@
  * console.log(hasOwn(obj, "c")); // false
  * ```
  */
-declare const hasOwn: <T, K extends PropertyKey>(obj: T, key: K) => obj is T & { [key in K]: unknown; };
+declare const hasOwn: <T extends object, K extends PropertyKey>(obj: T, key: K) => obj is T & { [key in K]: unknown; };
 /**
  * Determines if two objects are shallowly equal, that is,
  * if they have the same properties and the properties have the same values.
@@ -51,19 +51,21 @@ type ReadonlyEntry<T> = [key: keyof T, value: T[keyof T]];
 declare const objectFromEntries: <T>(entries: Iterable<ReadonlyEntry<T>>) => T;
 declare function value2Keys<K extends string, T extends string>(obj: Record<K, Iterable<T>>): Record<T, K[]>;
 /**
- * Maps the values of an object to a new object
+ * Maps the keys and values of an object to a new object
+ * Basically the equivalent of `Object.fromEntries(Object.entries(obj).map(callback))` but with
+ * more accurate typing
  * @param obj The object
- * @param fn The mapping function
- * @returns A new object with the mapped values
+ * @param callback The mapping function
+ * @returns A new object with the mapped entries
  * @example
  * ```ts
  * const obj = { a: 1, b: 2 };
- * const result = objectMap(obj, ([key, value]) => [key, value * 2]);
- * console.log(result); // { a: 2, b: 4 }
+ * const result = objectMap(obj, ([key, value]) => [`num${key}`, value * 2]);
+ * console.log(result); // { numa: 2, numb: 4 }
  * ```
  */
-declare function objectMap<T, U>(obj: T, fn: (value: Entry<T>) => U): {
-    [K in keyof T]: U;
+declare function objectMap<T, NewKey extends PropertyKey, NewValue>(obj: T, callback: (value: Entry<T>) => [NewKey, NewValue]): {
+    [K in NewKey]: NewValue;
 };
 declare function deepCopy<T>(object: T): T;
 declare function pickByKeys<T, K extends keyof T>(object: T, key: K): T[K];

package/dist/object.js

@@ -9,7 +9,7 @@ import {
   pickByKeys,
   shallowEquals,
   value2Keys
-} from "./chunk-LJSF3QBT.js";
+} from "./chunk-XCUELLWZ.js";
 export {
   deepCopy,
   deepEquals,

package/dist/random.js

@@ -5,12 +5,9 @@ import {
   randomInt,
   sample,
   shuffle
-} from "./chunk-ZAXC26KZ.js";
-import "./chunk-4POIKW4G.js";
-import "./chunk-CCBSTDYA.js";
-import "./chunk-NXILTE26.js";
+} from "./chunk-OMJMLVK3.js";
+import "./chunk-IZDNCBBO.js";
 import "./chunk-TMLWLR46.js";
-import "./chunk-LJSF3QBT.js";
 export {
   choice,
   choices,

package/dist/string/index.d.ts

@@ -2,7 +2,7 @@ declare const lowercase = "abcdefghijklmnopqrstuvwxyz";
 declare const uppercase = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
 declare const letters: string;
 declare const digits = "0123456789";
-declare const hexdigits: `0123456789abcdefABCDEF`;
+declare const hexdigits: "0123456789abcdefABCDEF";
 declare const octdigits = "01234567";
 
 /**

package/dist/structs/index.js

@@ -1,12 +1,9 @@
 import {
   swap
-} from "../chunk-4POIKW4G.js";
-import "../chunk-CCBSTDYA.js";
-import "../chunk-NXILTE26.js";
+} from "../chunk-IZDNCBBO.js";
 import {
   ascend
 } from "../chunk-TMLWLR46.js";
-import "../chunk-LJSF3QBT.js";
 
 // src/structs/heap.ts
 var Heap = class _Heap {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@limitlesspc/std",
   "type": "module",
-  "version": "0.23.5",
+  "version": "0.24.0",
   "description": "A standard library for JavaScript",
   "license": "MIT",
   "exports": {
@@ -58,6 +58,10 @@
       "types": "./dist/csv.d.ts",
       "default": "./dist/csv.js"
     },
+    "./easing": {
+      "types": "./dist/easing.d.ts",
+      "default": "./dist/easing.js"
+    },
     "./events": {
       "types": "./dist/events.d.ts",
       "default": "./dist/events.js"
@@ -80,11 +84,11 @@
   ],
   "prettier": "@limitlesspc/prettier-config",
   "devDependencies": {
-    "@limitlesspc/eslint-config": "^0.18.4",
+    "@limitlesspc/eslint-config": "^0.24.1",
     "@limitlesspc/prettier-config": "^1.2.1",
     "@vitest/coverage-v8": "^4.0.16",
     "bumpp": "^10.3.2",
-    "eslint": "^9.39.2",
+    "eslint": "^9.39.5",
     "prettier": "^3.7.4",
     "tsup": "^8.5.1",
     "typescript": "^5.9.3",