@design-edito/tools 0.2.39 → 0.2.41

package/agnostic/numbers/interpolate/index.js

@@ -1,9 +1,14 @@
-import {
-  exterpolate,
-  interpolate
-} from "../../../chunks/chunk-BJAYUP7M.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
+
+// src/agnostic/numbers/interpolate/index.ts
+function interpolate(ratio, bound1, bound2) {
+  return bound1 + ratio * (bound2 - bound1);
+}
+function unlerp(value, bound1, bound2) {
+  if (bound2 === void 0) return value / bound1;
+  return (value - bound1) / (bound2 - bound1);
+}
 export {
-  exterpolate,
-  interpolate
+  interpolate,
+  unlerp
 };

package/agnostic/numbers/interpolate/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/agnostic/numbers/responsive-harmonics/index.d.ts

@@ -1,3 +1,12 @@
+/**
+ * Computes the harmonic value at a specific level between a minimum and maximum over a number of steps.
+ *
+ * @param {number} min - The minimum value (must be non-zero).
+ * @param {number} max - The maximum value.
+ * @param {number} level - The current level (1-based).
+ * @param {number} steps - Total number of steps (must be ≥ 1).
+ * @returns {number} The computed harmonic value, or `NaN` if input is invalid.
+ */
 export declare function getHarmonic(min: number, max: number, level: number, steps: number): number;
 type ScaleDescriptor = {
     screenBounds: [number, number];
@@ -6,5 +15,16 @@ type ScaleDescriptor = {
     steps: number;
     clamp?: boolean;
 };
+/**
+ * Creates a scale function that maps a level to a CSS size value using harmonic interpolation.
+ *
+ * @param {ScaleDescriptor} descriptor - The scale configuration.
+ * @param {[number, number]} descriptor.screenBounds - The lower and upper bounds for screen width in pixels.
+ * @param {[number, number]} descriptor.lowLevel - Minimum and maximum values for the low level range.
+ * @param {[number, number]} descriptor.highLevel - Minimum and maximum values for the high level range.
+ * @param {number} descriptor.steps - Number of discrete steps in the scale.
+ * @param {boolean} [descriptor.clamp] - Whether to wrap the resulting CSS value in a `clamp()` function.
+ * @returns {(level: number) => string | undefined} A function mapping a level to a CSS value string.
+ */
 export declare function createScale(descriptor: ScaleDescriptor): (level: number) => string | undefined;
 export {};

package/agnostic/numbers/responsive-harmonics/index.js

@@ -1,9 +1,53 @@
 import {
-  createScale,
-  getHarmonic
-} from "../../../chunks/chunk-KXIA3YGF.js";
-import "../../../chunks/chunk-EOE2ODJR.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
+  round
+} from "../../../chunks/chunk-QHEWBOQI.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
+
+// src/agnostic/numbers/responsive-harmonics/index.ts
+function getHarmonic(min, max, level, steps) {
+  if (min === 0) {
+    console.warn("Cannot generate harmonics if min value is zero");
+    return NaN;
+  }
+  if (steps < 1) {
+    console.warn("Cannot generate harmonics if steps is lower than one");
+    return NaN;
+  }
+  const maxOverMin = max / min;
+  const oneOverSteps = 1 / parseInt(`${steps}`);
+  const factor = Math.pow(maxOverMin, oneOverSteps);
+  return min * Math.pow(factor, level);
+}
+function getAffineFunction(x1, y1, x2, y2) {
+  const slope = (y2 - y1) / (x2 - x1);
+  const yIntercept = y1 - x1 * slope;
+  return { slope, yIntercept };
+}
+function getCssValueFromAffine(affine) {
+  const { slope, yIntercept } = affine;
+  const roundedSlope = round(100 * slope, 3);
+  const roundedIntercept = round(yIntercept, 2);
+  return `calc(${roundedSlope}vw + ${roundedIntercept}px)`;
+}
+function createScale(descriptor) {
+  const {
+    screenBounds: [loBound, hiBound],
+    lowLevel: [loLevelMin, loLevelMax],
+    highLevel: [hiLevelMin, hiLevelMax],
+    steps,
+    clamp
+  } = descriptor;
+  return function scale(level) {
+    if (steps < 2) return;
+    const loBoundVal = getHarmonic(loLevelMin, hiLevelMin, level - 1, steps - 1);
+    const hiBoundVal = getHarmonic(loLevelMax, hiLevelMax, level - 1, steps - 1);
+    if (loBoundVal === void 0) return;
+    if (hiBoundVal === void 0) return;
+    const affine = getAffineFunction(loBound, loBoundVal, hiBound, hiBoundVal);
+    const cssFormula = getCssValueFromAffine(affine);
+    return clamp === true ? `clamp(${round(loBoundVal, 2)}px, ${cssFormula}, ${round(hiBoundVal, 2)}px)` : cssFormula;
+  };
+}
 export {
   createScale,
   getHarmonic

package/agnostic/numbers/round/index.d.ts

@@ -1,3 +1,24 @@
-export declare function round(number: number, nbDecimals: number): number;
-export declare function ceil(number: number, nbDecimals: number): number;
-export declare function floor(number: number, nbDecimals: number): number;
+/**
+ * Rounds a number to/down a specified number of decimal places.
+ *
+ * @param {number} number - The number to round.
+ * @param {number} nbDecimals - Number of decimal places. Defaults to 0
+ * @returns {number} The rounded number.
+ */
+export declare function round(number: number, nbDecimals?: number): number;
+/**
+ * Ceils a number up to a specified number of decimal places.
+ *
+ * @param {number} number - The number to round up.
+ * @param {number} nbDecimals - Number of decimal places. Defaults to 0
+ * @returns {number} The ceiled-up number.
+ */
+export declare function ceil(number: number, nbDecimals?: number): number;
+/**
+ * Floors a number down to a specified number of decimal places.
+ *
+ * @param {number} number - The number to round down.
+ * @param {number} nbDecimals - Number of decimal places. Defaults to 0
+ * @returns {number} The floored-down number.
+ */
+export declare function floor(number: number, nbDecimals?: number): number;

package/agnostic/numbers/round/index.js

@@ -2,8 +2,8 @@ import {
   ceil,
   floor,
   round
-} from "../../../chunks/chunk-EOE2ODJR.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
+} from "../../../chunks/chunk-QHEWBOQI.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
 export {
   ceil,
   floor,

package/agnostic/numbers/round/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/agnostic/objects/deep-get-property/index.d.ts

@@ -1 +1,9 @@
+/**
+ * Safely retrieves a nested property from an object using a dot-separated path string.
+ *
+ * @param {unknown} anythingThatHasProperties - The object (or record) to traverse.
+ * @param {string} pathString - Dot-separated path of the property to retrieve (e.g., `'a.b.c'`).
+ * @returns {any} The value at the specified path.
+ * @throws {string} `'PROPERTY_UNREACHABLE'` if any part of the path is inaccessible or not an object.
+ */
 export declare function deepGetProperty(anythingThatHasProperties: unknown, pathString: string): any;

package/agnostic/objects/deep-get-property/index.js

@@ -1,8 +1,27 @@
 import {
-  deepGetProperty
-} from "../../../chunks/chunk-SKMCIFS3.js";
-import "../../../chunks/chunk-YDIBNEGA.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
+  isRecord
+} from "../../../chunks/chunk-YDIBNEGA.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
+
+// src/agnostic/objects/deep-get-property/index.ts
+function deepGetProperty(anythingThatHasProperties, pathString) {
+  const pathChunks = pathString.split(".").map((e) => e.trim()).filter((e) => e !== "");
+  let currentObject = anythingThatHasProperties;
+  let returned = currentObject;
+  pathChunks.forEach((chunk, pos) => {
+    const isLast = pos === pathChunks.length - 1;
+    if (!isRecord(currentObject)) throw "PROPERTY_UNREACHABLE";
+    if (isLast) {
+      const val = currentObject[chunk];
+      returned = val;
+    } else {
+      const found = currentObject[chunk];
+      if (isRecord(found)) currentObject = found;
+      else throw "PROPERTY_UNREACHABLE";
+    }
+  });
+  return returned;
+}
 export {
   deepGetProperty
 };

package/agnostic/objects/enums/is-in-enum/index.d.ts

@@ -1 +1,11 @@
+/**
+ * Checks whether a value exists in a TypeScript enum.
+ *
+ * Works with both string and numeric enums, ignoring reverse mappings in numeric enums.
+ *
+ * @template E - The enum type.
+ * @param {E} enumObj - The enum object to check against.
+ * @param {string | number} value - The value to test.
+ * @returns {value is E[keyof E]} `true` if the value is a valid enum member, otherwise `false`.
+ */
 export declare function isInEnum<E extends Record<string, string | number>>(enumObj: E, value: string | number): value is E[keyof E];

package/agnostic/objects/enums/is-in-enum/index.js

@@ -1,7 +1,7 @@
 import {
   isInEnum
 } from "../../../../chunks/chunk-E6MSDKON.js";
-import "../../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../../chunks/chunk-XCBH6NLF.js";
 export {
   isInEnum
 };

package/agnostic/objects/flatten-getters/index.d.ts

@@ -1 +1,7 @@
+/**
+ * Returns a shallow copy of an object including values from its getter properties.
+ *
+ * @param {unknown} obj - The object to flatten.
+ * @returns {Record<string, unknown>} A new object containing all own properties and evaluated getter values.
+ */
 export declare function flattenGetters(obj: unknown): Record<string, unknown>;

package/agnostic/objects/flatten-getters/index.js

@@ -1,10 +1,25 @@
 import {
-  flattenGetters
-} from "../../../chunks/chunk-VFJYLXCI.js";
-import "../../../chunks/chunk-SNJJII7A.js";
+  toRecord
+} from "../../../chunks/chunk-YWSXCFYY.js";
 import "../../../chunks/chunk-QXAJXTXV.js";
 import "../../../chunks/chunk-HC6ZOHCS.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
+
+// src/agnostic/objects/flatten-getters/index.ts
+function flattenGetters(obj) {
+  try {
+    const { entries, getOwnPropertyDescriptors } = Object;
+    const properties = toRecord(obj);
+    const getters = entries(getOwnPropertyDescriptors(obj)).filter(([_, desc]) => typeof desc.get === "function").map(([key]) => key);
+    const returned = { ...properties };
+    getters.forEach((getter) => {
+      returned[getter] = obj[getter];
+    });
+    return returned;
+  } catch (err) {
+    return {};
+  }
+}
 export {
   flattenGetters
 };

package/agnostic/objects/is-object/index.d.ts

@@ -1,2 +1,14 @@
+/**
+ * Checks if a value is of type "object", including `null`.
+ *
+ * @param {unknown} unk - The value to check.
+ * @returns {unk is object | null} `true` if the value is an object or `null`, otherwise `false`.
+ */
 export declare function isObject(unk: unknown): unk is object | null;
+/**
+ * Checks if a value is a non-null object.
+ *
+ * @param {unknown} unk - The value to check.
+ * @returns {unk is object} `true` if the value is a non-null object, otherwise `false`.
+ */
 export declare function isNonNullObject(unk: unknown): unk is object;

package/agnostic/objects/is-object/index.js

@@ -2,7 +2,7 @@ import {
   isNonNullObject,
   isObject
 } from "../../../chunks/chunk-HQLRJ7XW.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
 export {
   isNonNullObject,
   isObject

package/agnostic/objects/is-record/index.d.ts

@@ -1 +1,7 @@
+/**
+ * Checks if a value is a plain object with string keys.
+ *
+ * @param {unknown} input - The value to check.
+ * @returns {input is Record<string, unknown>} `true` if the value is an object with string keys, otherwise `false`.
+ */
 export declare function isRecord(input: unknown): input is Record<string, unknown>;

package/agnostic/objects/is-record/index.js

@@ -1,7 +1,7 @@
 import {
   isRecord
 } from "../../../chunks/chunk-YDIBNEGA.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
 export {
   isRecord
 };

package/agnostic/objects/record-format/index.d.ts

@@ -1,11 +1,38 @@
+/**
+ * A key of the input object or a string.
+ */
 export type FormatKey<Input extends {} = any> = keyof Input | string;
+/**
+ * The value type of a given key in the input object, or `undefined` if the key does not exist.
+ */
 export type InputValue<Input extends {}, Key extends FormatKey<Input>> = Input extends Record<Key, infer V> ? V : undefined;
+/**
+ * A function that transforms a value of type I into type O, can return a Promise.
+ */
 export type FormatterFunc<I, O> = (val: I) => O | Promise<O>;
+/**
+ * An object mapping keys to formatter functions.
+ */
 export type Format<Input extends {} = any> = {
     [Key in FormatKey<Input>]: FormatterFunc<InputValue<Input, Key>, any>;
 };
+/**
+ * Utility type that extracts the resolved type of a Promise, or returns the type itself if not a Promise.
+ */
 export type UnwrapPromise<PromiseOrNot> = PromiseOrNot extends Promise<infer Resolved> ? Resolved : PromiseOrNot;
+/**
+ * The object type resulting from applying all formatters and unwrapping any Promises.
+ */
 export type Formatted<F extends Format<{}>> = {
     [Key in keyof F]: UnwrapPromise<ReturnType<F[Key]>>;
 };
+/**
+ * Applies a set of formatter functions to the corresponding properties of an input object.
+ *
+ * @template I - Input object type.
+ * @template F - Format object type mapping keys to formatter functions.
+ * @param {I} input - The object to format.
+ * @param {F} format - An object of formatter functions for each key.
+ * @returns {Promise<Formatted<F>>} A Promise resolving to the formatted object with all promises unwrapped.
+ */
 export declare function recordFormat<I extends {}, F extends Format<I>>(input: I, format: F): Promise<Formatted<F>>;

package/agnostic/objects/record-format/index.js

@@ -1,7 +1,18 @@
-import {
-  recordFormat
-} from "../../../chunks/chunk-YP64J65L.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
+
+// src/agnostic/objects/record-format/index.ts
+async function recordFormat(input, format) {
+  const result = {};
+  for (const key in format) {
+    const formatter = format[key];
+    if (typeof formatter === "function") {
+      result[key] = await formatter(input[key]);
+    } else {
+      result[key] = formatter;
+    }
+  }
+  return result;
+}
 export {
   recordFormat
 };

package/agnostic/objects/record-map/index.d.ts

@@ -1,3 +1,12 @@
+/**
+ * Maps the values of a record using a provided mapper function, returning a new record with the same keys.
+ *
+ * @template Input - The type of the input record.
+ * @template Mapped - The type of the mapped values.
+ * @param {Input} record - The record whose values will be mapped.
+ * @param {(value: Input[keyof Input], key: keyof Input) => Mapped} mapper - Function to transform each value.
+ * @returns {{ [K in keyof Input]: Mapped }} A new record with the same keys and mapped values.
+ */
 export declare function recordMap<Input extends Record<string, any>, Mapped>(record: Input, mapper: (value: Input[keyof Input], key: keyof Input) => Mapped): {
     [K in keyof Input]: Mapped;
 };

package/agnostic/objects/record-map/index.js

@@ -1,7 +1,7 @@
 import {
   recordMap
 } from "../../../chunks/chunk-XNF5MLCQ.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
 export {
   recordMap
 };

package/agnostic/objects/validation/index.d.ts

@@ -1,3 +1,11 @@
-export declare namespace Validation {
-    function fromPartial<T extends object>(obj: T, partial: Partial<T>): boolean;
-}
+/**
+ * Checks if an object contains all the key-value pairs from a partial object.
+ *
+ * Performs a shallow equality check for each property in `partial`.
+ *
+ * @template T - The type of the full object.
+ * @param {T} obj - The object to validate.
+ * @param {Partial<T>} partial - The partial object with key-value pairs to check.
+ * @returns {boolean} `true` if all entries in `partial` match those in `obj`, otherwise `false`.
+ */
+export declare function fromPartial<T extends object>(obj: T, partial: Partial<T>): boolean;

package/agnostic/objects/validation/index.js

@@ -1,7 +1,11 @@
-import {
-  Validation
-} from "../../../chunks/chunk-FPEW3A27.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
+
+// src/agnostic/objects/validation/index.ts
+function fromPartial(obj, partial) {
+  return Object.entries(partial).every(([key, val]) => {
+    return obj[key] === val;
+  });
+}
 export {
-  Validation
+  fromPartial
 };

package/agnostic/optim/memoize/index.d.ts

@@ -1,3 +1,12 @@
 type BasicFunc = (...args: any[]) => any;
-export declare function memoize<T extends BasicFunc = BasicFunc>(toMemoizeFunc: T): (...args: Parameters<T>) => any;
+/**
+ * Creates a memoized version of a function, caching the result for repeated calls with the same arguments.
+ *
+ * Only performs shallow equality checks on arguments (strict equality `===`).
+ *
+ * @template T - The type of the function to memoize.
+ * @param {T} toMemoizeFunc - The function to memoize.
+ * @returns {T} A memoized version of the input function.
+ */
+export declare function memoize<T extends BasicFunc>(toMemoizeFunc: T): T;
 export {};

package/agnostic/optim/memoize/index.js

@@ -1,7 +1,19 @@
-import {
-  memoize
-} from "../../../chunks/chunk-JWBDZPQG.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
+
+// src/agnostic/optim/memoize/index.ts
+function memoize(toMemoizeFunc) {
+  let cachedArgs;
+  let cachedResult;
+  const memoizedFunc = (...args) => {
+    const argsMatch = cachedArgs !== void 0 && args.length === cachedArgs.length && args.every((arg, i) => arg === cachedArgs[i]);
+    if (argsMatch && cachedResult !== void 0) return cachedResult.value;
+    const result = toMemoizeFunc(...args);
+    cachedArgs = args;
+    cachedResult = { value: result };
+    return result;
+  };
+  return memoizedFunc;
+}
 export {
   memoize
 };

package/agnostic/optim/throttle-debounce/index.js

@@ -1,8 +1,113 @@
-import {
-  debounce,
-  throttle
-} from "../../../chunks/chunk-VZDUZTW6.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
+
+// src/agnostic/optim/throttle-debounce/index.ts
+function throttle(toThrottleFunc, delayMs) {
+  let currentDelayMs = delayMs;
+  let lastArgs = [];
+  let lastExecutedOn = 0;
+  let lastReturnValue = void 0;
+  let nextExecutionTimeout = null;
+  function scheduleNextCall() {
+    if (nextExecutionTimeout !== null) {
+      clearTimeout(nextExecutionTimeout);
+      nextExecutionTimeout = null;
+    }
+    const now = Date.now();
+    const nextExecutionTimestamp = lastExecutedOn + currentDelayMs;
+    const msTillNextExecution = nextExecutionTimestamp - now;
+    nextExecutionTimeout = setTimeout(() => {
+      nextExecutionTimeout = null;
+      const returnValue = toThrottleFunc(...lastArgs);
+      lastReturnValue = returnValue;
+      lastExecutedOn = now;
+    }, msTillNextExecution) ?? null;
+  }
+  function throttled(...args) {
+    const now = Date.now();
+    lastArgs = args;
+    if (now - lastExecutedOn >= delayMs) {
+      const returnValue = toThrottleFunc(...lastArgs);
+      lastReturnValue = returnValue;
+      lastExecutedOn = now;
+      return {
+        returnValue: lastReturnValue,
+        lastExecutedOn,
+        delayMs: currentDelayMs,
+        isCached: false
+      };
+    }
+    if (nextExecutionTimeout === null) scheduleNextCall();
+    return {
+      returnValue: lastReturnValue,
+      lastExecutedOn,
+      delayMs: currentDelayMs,
+      isCached: true
+    };
+  }
+  function setDelay(delayMs2) {
+    currentDelayMs = delayMs2;
+    if (nextExecutionTimeout !== null) scheduleNextCall();
+  }
+  return {
+    throttled,
+    setDelay
+  };
+}
+function debounce(toDebounceFunc, delayMs) {
+  let currentDelayMs = delayMs;
+  let lastArgs = [];
+  let lastCalledOn = 0;
+  let lastExecutedOn = 0;
+  let lastReturnValue = void 0;
+  let nextExecutionTimeout = null;
+  function scheduleNextCall() {
+    if (typeof nextExecutionTimeout === "number") {
+      clearTimeout(nextExecutionTimeout);
+      nextExecutionTimeout = null;
+    }
+    const now = Date.now();
+    const nextExecutionTimestamp = lastCalledOn + currentDelayMs;
+    const msTillNextExecution = nextExecutionTimestamp - now;
+    nextExecutionTimeout = setTimeout(() => {
+      nextExecutionTimeout = null;
+      const returnValue = toDebounceFunc(...lastArgs);
+      lastReturnValue = returnValue;
+      lastExecutedOn = now;
+    }, msTillNextExecution) ?? null;
+  }
+  function debounced(...args) {
+    const now = Date.now();
+    lastArgs = args;
+    if (now - lastCalledOn >= currentDelayMs) {
+      lastCalledOn = now;
+      const returnValue = toDebounceFunc(...lastArgs);
+      lastReturnValue = returnValue;
+      lastExecutedOn = now;
+      return {
+        returnValue: lastReturnValue,
+        lastExecutedOn,
+        delayMs: currentDelayMs,
+        isCached: false
+      };
+    }
+    lastCalledOn = now;
+    scheduleNextCall();
+    return {
+      returnValue: lastReturnValue,
+      lastExecutedOn,
+      delayMs: currentDelayMs,
+      isCached: true
+    };
+  }
+  function setDelay(delayMs2) {
+    currentDelayMs = delayMs2;
+    if (nextExecutionTimeout !== null) scheduleNextCall();
+  }
+  return {
+    debounced,
+    setDelay
+  };
+}
 export {
   debounce,
   throttle

package/agnostic/optim/throttle-debounce/types.d.ts

@@ -1,2 +1,2 @@
 import { setTimeout } from 'node:timers';
-export type Timeout = ReturnType<typeof setTimeout>;
+export type NodeTimeout = ReturnType<typeof setTimeout>;

package/agnostic/random/hex-char/index.d.ts

@@ -1,2 +1,4 @@
+/** List of hex chars (0-9a-f) */
 export declare const hexChars: string[];
+/** Generates a random hexadecimal char (0-9a-f) */
 export declare function randomHexChar(): string;

package/agnostic/random/hex-char/index.js

@@ -2,7 +2,7 @@ import {
   hexChars,
   randomHexChar
 } from "../../../chunks/chunk-OGBUSUE6.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
 export {
   hexChars,
   randomHexChar

package/agnostic/random/random/index.d.ts

@@ -1,3 +1,17 @@
+/**
+ * Generates a random number within a range.
+ *
+ * @param {number} [bound1=1] - The lower bound if `bound2` is provided, otherwise the upper bound (min is 0).
+ * @param {number} [bound2] - Optional upper bound. If omitted, the range is `[0, bound1)`.
+ * @returns {number | undefined} A random floating-point number in `[min, max)`, or `undefined` if bounds are invalid.
+ */
 export declare function random(bound1?: number): number | undefined;
 export declare function random(bound1?: number, bound2?: number | undefined): number | undefined;
+/**
+ * Generates a random integer within a range.
+ *
+ * @param {number} [bound1=1] - The lower bound if `bound2` is provided, otherwise the upper bound (min is 0).
+ * @param {number} [bound2] - Optional upper bound. If omitted, the range is `[0, bound1)`.
+ * @returns {number | undefined} A random integer in `[min, max)`, or `undefined` if bounds are invalid.
+ */
 export declare function randomInt(...args: Parameters<typeof random>): number | undefined;

package/agnostic/random/random/index.js

@@ -2,7 +2,7 @@ import {
   random,
   randomInt
 } from "../../../chunks/chunk-D3ERTRDW.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
 export {
   random,
   randomInt