@tempots/std 0.20.0 → 0.22.0

package/number.d.ts

@@ -165,25 +165,29 @@ export declare const interpolate: (a: number, b: number, t: number) => number;
  **/
 export declare const interpolateAngle: (a: number, b: number, t: number, turn?: number) => number;
 /**
- * Calculates the widest angle difference between two angles.
+ * Calculates the minimum difference between two angles in degrees.
+ * Note: Despite the name "widest", this function actually calculates the shortest
+ * angle difference, identical to `angleDifference`. The name is misleading for
+ * historical reasons.
  *
  * @param a - The first angle in degrees.
  * @param b - The second angle in degrees.
  * @param turn - The total angle of a full turn. Defaults to 360 degrees.
- * @returns The widest angle difference between `a` and `b`.
+ * @returns The shortest angle difference between `a` and `b`.
  * @public
  * @example
  * ```ts
- * widestAngleDifference(0, 90) // returns 90
- * widestAngleDifference(90, 0) // returns -90
- * widestAngleDifference(0, 270) // returns -90
- * widestAngleDifference(270, 0) // returns 90
+ * widestAngleDifference(0, 90) // returns 90 (shortest path)
+ * widestAngleDifference(90, 0) // returns -90 (shortest path)
+ * widestAngleDifference(0, 270) // returns -90 (shortest path, not +270)
+ * widestAngleDifference(270, 0) // returns 90 (shortest path, not -270)
  * ```
  */
 export declare const widestAngleDifference: (a: number, b: number, turn?: number) => number;
 /**
- * Interpolates values in a polar coordinate system looking for the wideset delta angle.
- * It can be either clock-wise or counter-clock-wise.
+ * Interpolates values in a polar coordinate system looking for the shortest delta angle.
+ * Note: Despite the name "widest", this function actually uses the shortest angle
+ * difference, identical to `interpolateAngle`. The name is misleading for historical reasons.
  *
  * @param a - The first angle in degrees.
  * @param b - The second angle in degrees.
@@ -193,10 +197,10 @@ export declare const widestAngleDifference: (a: number, b: number, turn?: number
  * @public
  * @example
  * ```ts
- * interpolateWidestAngle(0, 90, 0.5) // returns 45
- * interpolateWidestAngle(0, 270, 0.5) // returns 315
- * interpolateWidestAngle(0, 90, 0.25) // returns 22.5
- * interpolateWidestAngle(0, 270, 0.25) // returns 337.5
+ * interpolateWidestAngle(0, 90, 0.5) // returns 45 (using shortest path)
+ * interpolateWidestAngle(0, 270, 0.5) // returns 315 (using shortest path)
+ * interpolateWidestAngle(0, 90, 0.25) // returns 22.5 (using shortest path)
+ * interpolateWidestAngle(0, 270, 0.25) // returns 337.5 (using shortest path)
  * ```
  **/
 export declare const interpolateWidestAngle: (a: number, b: number, t: number, turn?: number) => number;
@@ -321,19 +325,6 @@ export declare const root: (base: number, index: number) => number;
  * ```
  **/
 export declare const roundTo: (f: number, decimals: number) => number;
-/**
- * `sign` returns `-1` if `value` is a negative number, `1` otherwise.
- *
- * @param value - The number to check.
- * @returns `-1` if the number is negative, `1` otherwise.
- * @public
- * @example
- * ```ts
- * sign(-5) // returns -1
- * sign(5) // returns 1
- * ```
- */
-export declare const sign: <T extends number>(value: T) => number;
 /**
  * Passed two boundaries values (`min`, `max`), `wrap` ensures that the passed value `v` will
  * be included in the boundaries. If the value exceeds `max`, the value is reduced by `min`

package/number.js

@@ -1,32 +1,32 @@
 import { lpad as a } from "./string.js";
-const c = 1e-9, i = (t, e, n = 360) => {
-  let o = (e - t) % n;
-  return o < 0 && (o += n), o > n / 2 && (o -= n), o;
+const i = 1e-9, c = (t, e, r = 360) => {
+  let n = (e - t) % r;
+  return n < 0 && (n += r), n > r / 2 && (n -= r), n;
 }, h = (t, e) => {
-  const n = Math.pow(10, e);
-  return Math.ceil(t * n) / n;
-}, l = (t, e, n) => Math.min(Math.max(t, e), n), M = (t, e, n) => Math.trunc(l(t, e, n)), u = (t, e) => l(t, -e, e), g = (t, e) => t < e ? -1 : t > e ? 1 : 0, N = (t, e) => {
-  const n = Math.pow(10, e);
-  return Math.floor(t * n) / n;
-}, w = (t, e = 0) => a(t.toString(16), "0", e), s = (t, e, n) => (e - t) * n + t, A = (t, e, n, o = 360) => r(s(t, t + i(t, e, o), n), o), f = (t, e, n = 360) => {
-  let o = (e - t) % n;
-  return o < 0 && (o += n), o > n / 2 && (o -= n), o;
-}, d = (t, e, n, o = 360) => r(s(t, t + f(t, e, o), n), o), m = (t, e, n, o = 360) => (t = r(t, o), e = r(e, o), e < t && (e += o), r(s(t, e, n), o)), C = (t, e, n, o = 360) => (t = r(t, o), e = r(e, o), e > t && (e -= o), r(s(t, e, n), o)), E = (t, e, n = c) => isFinite(t) ? isFinite(e) ? Math.abs(t - e) <= n : !1 : isNaN(t) ? isNaN(e) : isNaN(e) || isFinite(e) ? !1 : t > 0 == e > 0, F = (t, e, n = 360, o = c) => Math.abs(i(t, e, n)) <= o, S = (t, e = c) => Math.abs(t) <= e, T = (t, e) => Math.pow(t, 1 / e), W = (t, e) => {
-  const n = Math.pow(10, e);
-  return Math.round(t * n) / n;
-}, q = (t) => t < 0 ? -1 : 1, D = (t, e, n) => {
-  const o = n - e + 1;
-  return t < e && (t += o * ((e - t) / o + 1)), e + (t - e) % o;
-}, r = (t, e) => (t = t % e, t < 0 && (t += e), t);
+  const r = Math.pow(10, e);
+  return Math.ceil(t * r) / r;
+}, l = (t, e, r) => Math.min(Math.max(t, e), r), u = (t, e, r) => Math.trunc(l(t, e, r)), M = (t, e) => l(t, -e, e), N = (t, e) => t < e ? -1 : t > e ? 1 : 0, g = (t, e) => {
+  const r = Math.pow(10, e);
+  return Math.floor(t * r) / r;
+}, w = (t, e = 0) => a(t.toString(16), "0", e), s = (t, e, r) => (e - t) * r + t, A = (t, e, r, n = 360) => o(s(t, t + c(t, e, n), r), n), f = (t, e, r = 360) => {
+  let n = (e - t) % r;
+  return n < 0 && (n += r), n > r / 2 && (n -= r), n;
+}, d = (t, e, r, n = 360) => o(s(t, t + f(t, e, n), r), n), m = (t, e, r, n = 360) => (t = o(t, n), e = o(e, n), e < t && (e += n), o(s(t, e, r), n)), C = (t, e, r, n = 360) => (t = o(t, n), e = o(e, n), e > t && (e -= n), o(s(t, e, r), n)), E = (t, e, r = i) => isFinite(t) ? isFinite(e) ? Math.abs(t - e) <= r : !1 : isNaN(t) && isNaN(e) ? !0 : isNaN(t) || isNaN(e) || isFinite(e) ? !1 : t > 0 == e > 0, F = (t, e, r = 360, n = i) => Math.abs(c(t, e, r)) <= n, S = (t, e = i) => Math.abs(t) <= e, T = (t, e) => Math.pow(t, 1 / e), W = (t, e) => {
+  const r = Math.pow(10, e);
+  return Math.round(t * r) / r;
+}, q = (t, e, r) => {
+  const n = r - e + 1;
+  return t < e && (t += n * ((e - t) / n + 1)), e + (t - e) % n;
+}, o = (t, e) => (t = t % e, t < 0 && (t += e), t);
 export {
-  c as EPSILON,
-  i as angleDifference,
+  i as EPSILON,
+  c as angleDifference,
   h as ceilTo,
   l as clamp,
-  M as clampInt,
-  u as clampSym,
-  g as compareNumbers,
-  N as floorTo,
+  u as clampInt,
+  M as clampSym,
+  N as compareNumbers,
+  g as floorTo,
   s as interpolate,
   A as interpolateAngle,
   C as interpolateAngleCCW,
@@ -37,9 +37,8 @@ export {
   S as nearZero,
   T as root,
   W as roundTo,
-  q as sign,
   w as toHex,
   f as widestAngleDifference,
-  D as wrap,
-  r as wrapCircular
+  q as wrap,
+  o as wrapCircular
 };

package/object.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const o=e=>Object.keys(e),r=e=>Object.values(e),b=e=>Object.entries(e),j=e=>Object.fromEntries(e),i=(e,t)=>{const n=o(e),c=o(t);if(n.length!==c.length)return!1;for(const s of n)if(!(s in t))return!1;return!0},O=e=>e!=null&&Object.getPrototypeOf(e)===Object.prototype,l=(e,...t)=>o(e).reduce((c,s)=>(t.includes(s)||(c[s]=e[s]),c),{}),u=(e,t)=>Object.assign({},e,t),m=e=>Object.keys(e).length===0;exports.isEmptyObject=m;exports.isObject=O;exports.mergeObjects=u;exports.objectEntries=b;exports.objectFromEntries=j;exports.objectKeys=o;exports.objectValues=r;exports.removeObjectFields=l;exports.sameObjectKeys=i;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const r=e=>Object.keys(e),i=e=>Object.values(e),l=e=>Object.entries(e),f=e=>Object.fromEntries(e),u=(e,t)=>{const n=r(e),s=r(t);if(n.length!==s.length)return!1;for(const c of n)if(!(c in t))return!1;return!0},O=e=>e!=null&&Object.getPrototypeOf(e)===Object.prototype,a=(e,...t)=>r(e).reduce((s,c)=>(t.includes(c)||(s[c]=e[c]),s),{}),y=(e,t)=>Object.assign({},e,t),b=e=>Object.keys(e).length===0,j=(e,t)=>{const n={};for(const s of t)s in e&&(n[s]=e[s]);return n},m=(e,t)=>{const n={...e};for(const s of t)delete n[s];return n},o=e=>{if(e===null||typeof e!="object")return e;if(e instanceof Date)return new Date(e.getTime());if(e instanceof Array)return e.map(t=>o(t));if(typeof e=="object"){const t={};for(const n in e)Object.prototype.hasOwnProperty.call(e,n)&&(t[n]=o(e[n]));return t}return e};exports.deepClone=o;exports.isEmptyObject=b;exports.isObject=O;exports.mergeObjects=y;exports.objectEntries=l;exports.objectFromEntries=f;exports.objectKeys=r;exports.objectValues=i;exports.omit=m;exports.pick=j;exports.removeObjectFields=a;exports.sameObjectKeys=u;

package/object.d.ts

@@ -1,33 +1,109 @@
 import { IndexKey, Merge, TupleToUnion } from './domain';
 /**
- * Returns an array of keys from the given object.
+ * Returns an array of keys from the given object with proper type inference.
+ *
+ * This function provides better type safety than `Object.keys()` by returning
+ * `Array<keyof T>` instead of `string[]`, ensuring type correctness when working
+ * with the keys in TypeScript.
+ *
+ * @example
+ * ```typescript
+ * const user = { id: 1, name: 'Alice', active: true }
+ * const keys = objectKeys(user)
+ * // Type: Array<'id' | 'name' | 'active'>
+ * // Result: ['id', 'name', 'active']
+ *
+ * // Type-safe iteration
+ * keys.forEach(key => {
+ *   console.log(user[key]) // TypeScript knows this is valid
+ * })
+ * ```
  *
  * @param obj - The object from which to extract keys.
- * @returns An array of keys from the object.
+ * @returns An array of keys from the object with proper typing.
  * @public
  */
 export declare const objectKeys: <T extends object>(obj: T) => Array<keyof T>;
 /**
- * Returns an array of values from the given object.
+ * Returns an array of values from the given object with proper type inference.
+ *
+ * This function provides better type safety than `Object.values()` by returning
+ * `Array<T[keyof T]>` instead of `unknown[]`, preserving the union type of all
+ * possible values in the object.
+ *
+ * @example
+ * ```typescript
+ * const user = { id: 1, name: 'Alice', active: true }
+ * const values = objectValues(user)
+ * // Type: Array<number | string | boolean>
+ * // Result: [1, 'Alice', true]
+ *
+ * // Type-safe processing
+ * values.forEach(value => {
+ *   // TypeScript knows value can be number | string | boolean
+ *   if (typeof value === 'string') {
+ *     console.log(value.toUpperCase())
+ *   }
+ * })
+ * ```
  *
  * @param obj - The object from which to extract values.
- * @returns An array of values from the object.
+ * @returns An array of values from the object with proper typing.
  * @public
  */
 export declare const objectValues: <T extends object>(obj: T) => Array<T[keyof T]>;
 /**
- * Returns an array of entries (key-value pairs) from the given object.
+ * Returns an array of entries (key-value pairs) from the given object with proper type inference.
+ *
+ * This function provides better type safety than `Object.entries()` by returning
+ * `[keyof T, T[keyof T]][]` instead of `[string, unknown][]`, preserving both
+ * key and value types for type-safe destructuring and iteration.
+ *
+ * @example
+ * ```typescript
+ * const user = { id: 1, name: 'Alice', active: true }
+ * const entries = objectEntries(user)
+ * // Type: Array<['id' | 'name' | 'active', number | string | boolean]>
+ * // Result: [['id', 1], ['name', 'Alice'], ['active', true]]
+ *
+ * // Type-safe destructuring
+ * entries.forEach(([key, value]) => {
+ *   // TypeScript knows key is 'id' | 'name' | 'active'
+ *   // TypeScript knows value is number | string | boolean
+ *   console.log(`${key}: ${value}`)
+ * })
+ * ```
  *
  * @param obj - The object from which to extract entries.
- * @returns An array of tuples, where each tuple contains a key and its corresponding value from the object.
+ * @returns An array of tuples with proper typing, where each tuple contains a key and its corresponding value.
  * @public
  */
 export declare const objectEntries: <T extends object>(obj: T) => [keyof T, T[keyof T]][];
 /**
- * Creates an object from an array of entries.
+ * Creates an object from an array of entries with proper type inference.
+ *
+ * This function provides better type safety than `Object.fromEntries()` by
+ * accepting properly typed entries and returning a typed object instead of
+ * `{ [k: string]: unknown }`.
+ *
+ * @example
+ * ```typescript
+ * const entries: [string, number][] = [['a', 1], ['b', 2], ['c', 3]]
+ * const obj = objectFromEntries(entries)
+ * // Type: { [x: string]: number }
+ * // Result: { a: 1, b: 2, c: 3 }
+ *
+ * // Works with union types
+ * const mixedEntries: Array<['id' | 'name', number | string]> = [
+ *   ['id', 123],
+ *   ['name', 'Alice']
+ * ]
+ * const user = objectFromEntries(mixedEntries)
+ * // Type: { [x: string]: number | string }
+ * ```
  *
  * @param entries - The array of entries to create an object from.
- * @returns The created object.
+ * @returns The created object with proper typing.
  * @public
  */
 export declare const objectFromEntries: <T extends object>(entries: [keyof T, T[keyof T]][]) => T;
@@ -77,3 +153,65 @@ export declare const mergeObjects: <A extends Record<IndexKey, unknown>, B exten
  * @public
  */
 export declare const isEmptyObject: (obj: object) => boolean;
+/**
+ * Creates a new object with only the specified keys from the source object.
+ *
+ * This function provides type-safe property selection, ensuring that only
+ * valid keys can be picked and the result type reflects the selected properties.
+ *
+ * @example
+ * ```typescript
+ * const user = { id: 1, name: 'Alice', email: 'alice@example.com', password: 'secret' }
+ * const publicUser = pick(user, ['id', 'name', 'email'])
+ * // Result: { id: 1, name: 'Alice', email: 'alice@example.com' }
+ * // Type: Pick<typeof user, 'id' | 'name' | 'email'>
+ * ```
+ *
+ * @param obj - The source object
+ * @param keys - Array of keys to pick
+ * @returns A new object containing only the specified keys
+ * @public
+ */
+export declare const pick: <T extends object, K extends keyof T>(obj: T, keys: readonly K[]) => Pick<T, K>;
+/**
+ * Creates a new object with all keys except the specified ones from the source object.
+ *
+ * This function provides type-safe property exclusion, ensuring that only
+ * valid keys can be omitted and the result type reflects the remaining properties.
+ *
+ * @example
+ * ```typescript
+ * const user = { id: 1, name: 'Alice', email: 'alice@example.com', password: 'secret' }
+ * const publicUser = omit(user, ['password'])
+ * // Result: { id: 1, name: 'Alice', email: 'alice@example.com' }
+ * // Type: Omit<typeof user, 'password'>
+ * ```
+ *
+ * @param obj - The source object
+ * @param keys - Array of keys to omit
+ * @returns A new object without the specified keys
+ * @public
+ */
+export declare const omit: <T extends object, K extends keyof T>(obj: T, keys: readonly K[]) => Omit<T, K>;
+/**
+ * Creates a deep clone of an object.
+ *
+ * This function recursively clones objects, arrays, and primitive values.
+ * It handles Date objects specially and avoids infinite recursion.
+ *
+ * @example
+ * ```typescript
+ * const original = {
+ *   name: 'Alice',
+ *   settings: { theme: 'dark', notifications: true },
+ *   tags: ['user', 'admin']
+ * }
+ * const cloned = deepClone(original)
+ * cloned.settings.theme = 'light' // Original remains unchanged
+ * ```
+ *
+ * @param obj - The object to clone
+ * @returns A deep clone of the object
+ * @public
+ */
+export declare const deepClone: <T>(obj: T) => T;

package/object.js

@@ -1,18 +1,45 @@
-const o = (e) => Object.keys(e), r = (e) => Object.values(e), j = (e) => Object.entries(e), b = (e) => Object.fromEntries(e), O = (e, t) => {
-  const n = o(e), c = o(t);
-  if (n.length !== c.length) return !1;
-  for (const s of n)
-    if (!(s in t)) return !1;
+const c = (e) => Object.keys(e), i = (e) => Object.values(e), f = (e) => Object.entries(e), u = (e) => Object.fromEntries(e), l = (e, t) => {
+  const n = c(e), s = c(t);
+  if (n.length !== s.length) return !1;
+  for (const r of n)
+    if (!(r in t)) return !1;
   return !0;
-}, i = (e) => e != null && Object.getPrototypeOf(e) === Object.prototype, l = (e, ...t) => o(e).reduce((c, s) => (t.includes(s) || (c[s] = e[s]), c), {}), u = (e, t) => Object.assign({}, e, t), f = (e) => Object.keys(e).length === 0;
+}, O = (e) => e != null && Object.getPrototypeOf(e) === Object.prototype, a = (e, ...t) => c(e).reduce((s, r) => (t.includes(r) || (s[r] = e[r]), s), {}), p = (e, t) => Object.assign({}, e, t), y = (e) => Object.keys(e).length === 0, k = (e, t) => {
+  const n = {};
+  for (const s of t)
+    s in e && (n[s] = e[s]);
+  return n;
+}, m = (e, t) => {
+  const n = { ...e };
+  for (const s of t)
+    delete n[s];
+  return n;
+}, o = (e) => {
+  if (e === null || typeof e != "object")
+    return e;
+  if (e instanceof Date)
+    return new Date(e.getTime());
+  if (e instanceof Array)
+    return e.map((t) => o(t));
+  if (typeof e == "object") {
+    const t = {};
+    for (const n in e)
+      Object.prototype.hasOwnProperty.call(e, n) && (t[n] = o(e[n]));
+    return t;
+  }
+  return e;
+};
 export {
-  f as isEmptyObject,
-  i as isObject,
-  u as mergeObjects,
-  j as objectEntries,
-  b as objectFromEntries,
-  o as objectKeys,
-  r as objectValues,
-  l as removeObjectFields,
-  O as sameObjectKeys
+  o as deepClone,
+  y as isEmptyObject,
+  O as isObject,
+  p as mergeObjects,
+  f as objectEntries,
+  u as objectFromEntries,
+  c as objectKeys,
+  i as objectValues,
+  m as omit,
+  k as pick,
+  a as removeObjectFields,
+  l as sameObjectKeys
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tempots/std",
-  "version": "0.20.0",
+  "version": "0.22.0",
   "priority": 8,
   "description": "Std library for TypeScript. Natural complement to the Tempo libraries.",
   "keywords": [
@@ -41,6 +41,10 @@
       "import": "./boolean.js",
       "require": "./boolean.cjs"
     },
+    "./date": {
+      "import": "./date.js",
+      "require": "./date.cjs"
+    },
     "./deferred": {
       "import": "./deferred.js",
       "require": "./deferred.cjs"
@@ -61,10 +65,18 @@
       "import": "./function.js",
       "require": "./function.cjs"
     },
+    "./iterator": {
+      "import": "./iterator.js",
+      "require": "./iterator.cjs"
+    },
     "./json": {
       "import": "./json.js",
       "require": "./json.cjs"
     },
+    "./map": {
+      "import": "./map.js",
+      "require": "./map.cjs"
+    },
     "./number": {
       "import": "./number.js",
       "require": "./number.cjs"
@@ -77,6 +89,10 @@
       "import": "./promise.js",
       "require": "./promise.cjs"
     },
+    "./random": {
+      "import": "./random.js",
+      "require": "./random.cjs"
+    },
     "./regexp": {
       "import": "./regexp.js",
       "require": "./regexp.cjs"
@@ -85,6 +101,10 @@
       "import": "./result.js",
       "require": "./result.cjs"
     },
+    "./set": {
+      "import": "./set.js",
+      "require": "./set.cjs"
+    },
     "./string": {
       "import": "./string.js",
       "require": "./string.cjs"
@@ -97,6 +117,10 @@
       "import": "./union.js",
       "require": "./union.cjs"
     },
+    "./url": {
+      "import": "./url.js",
+      "require": "./url.cjs"
+    },
     "./validation": {
       "import": "./validation.js",
       "require": "./validation.cjs"
@@ -124,6 +148,9 @@
       "boolean": [
         "./boolean.d.ts"
       ],
+      "date": [
+        "./date.d.ts"
+      ],
       "deferred": [
         "./deferred.d.ts"
       ],
@@ -139,9 +166,15 @@
       "function": [
         "./function.d.ts"
       ],
+      "iterator": [
+        "./iterator.d.ts"
+      ],
       "json": [
         "./json.d.ts"
       ],
+      "map": [
+        "./map.d.ts"
+      ],
       "number": [
         "./number.d.ts"
       ],
@@ -151,12 +184,18 @@
       "promise": [
         "./promise.d.ts"
       ],
+      "random": [
+        "./random.d.ts"
+      ],
       "regexp": [
         "./regexp.d.ts"
       ],
       "result": [
         "./result.d.ts"
       ],
+      "set": [
+        "./set.d.ts"
+      ],
       "string": [
         "./string.d.ts"
       ],
@@ -166,6 +205,9 @@
       "union": [
         "./union.d.ts"
       ],
+      "url": [
+        "./url.d.ts"
+      ],
       "validation": [
         "./validation.d.ts"
       ]

package/random.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const s=(t,e)=>{if(t>e)throw new Error("min must be less than or equal to max");return Math.floor(Math.random()*(e-t+1))+t},l=(t,e,n=!1)=>{if(t>e)throw new Error("min must be less than or equal to max");const r=Math.random(),o=e-t;return r*o+t},x=t=>{if(t.length===0)throw new Error("Cannot choose from empty array");const e=s(0,t.length-1);return t[e]},c=(t,e)=>{if(t.length===0)throw new Error("Cannot choose from empty array");if(e>t.length)throw new Error("Cannot select more elements than available in array");if(e<=0)return[];const n=[...t];for(let r=n.length-1;r>0;r--){const o=s(0,r);[n[r],n[o]]=[n[o],n[r]]}return n.slice(0,e)},h=()=>"xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g,t=>{const e=Math.random()*16|0;return(t==="x"?e:e&3|8).toString(16)}),d=t=>{if(t<=0)return"";const e="0123456789abcdef";let n="";for(let r=0;r<t;r++)n+=e[s(0,e.length-1)];return n},f=t=>{if(t<=0)return new Uint8Array(0);const e=new Uint8Array(t);for(let n=0;n<t;n++)e[n]=s(0,255);return e},u=t=>{let e=0;for(let r=0;r<t.length;r++){const o=t.charCodeAt(r);e=(e<<5)-e+o,e=e&e}let n=Math.abs(e);return()=>(n=(n*1664525+1013904223)%4294967296,n/4294967296)},a=t=>{for(let e=t.length-1;e>0;e--){const n=s(0,e);[t[e],t[n]]=[t[n],t[e]]}return t},i=t=>a([...t]);exports.randomBytes=f;exports.randomChoice=x;exports.randomChoices=c;exports.randomFloat=l;exports.randomHex=d;exports.randomInt=s;exports.randomUuid=h;exports.seedRandom=u;exports.shuffle=a;exports.shuffled=i;