@design-edito/tools 0.2.39 → 0.2.41

package/agnostic/time/dates/format-date/index.js

@@ -1,7 +1,61 @@
-import {
-  formatDate
-} from "../../../../chunks/chunk-YQWZ3EP2.js";
-import "../../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../../chunks/chunk-XCBH6NLF.js";
+
+// src/agnostic/time/dates/format-date/index.ts
+function formatDate(date, format, locale = "en") {
+  try {
+    new Intl.DateTimeFormat(locale);
+  } catch {
+    locale = "en";
+  }
+  const day = date.getDate();
+  const dayOfWeek = date.getDay();
+  const month = date.getMonth();
+  const year = date.getFullYear();
+  const hours = date.getHours();
+  const minutes = date.getMinutes();
+  const seconds = date.getSeconds();
+  const isPM = hours >= 12;
+  const shortDateNames = [...Array(7)].map((_, i) => new Intl.DateTimeFormat(locale, { weekday: "short" }).format(new Date(2023, 0, i + 1)));
+  const dateNames = [...Array(7)].map((_, i) => new Intl.DateTimeFormat(locale, { weekday: "long" }).format(new Date(2023, 0, i + 1)));
+  const shortMonthNames = [...Array(12)].map((_, i) => new Intl.DateTimeFormat(locale, { month: "short" }).format(new Date(2023, i, 1)));
+  const monthNames = [...Array(12)].map((_, i) => new Intl.DateTimeFormat(locale, { month: "long" }).format(new Date(2023, i, 1)));
+  const replacements = {
+    "DD": () => String(day).padStart(2, "0"),
+    "D": () => String(day),
+    "dd": () => dateNames[dayOfWeek],
+    "d": () => shortDateNames[dayOfWeek],
+    "MM": () => String(month + 1).padStart(2, "0"),
+    "M": () => String(month + 1),
+    "MMMM": () => monthNames[month],
+    "MMM": () => shortMonthNames[month],
+    "YYYY": () => String(year),
+    "YY": () => String(year).slice(-2),
+    "hh": () => String(hours % 12 || 12).padStart(2, "0"),
+    "h": () => String(hours % 12 || 12),
+    "HH": () => String(hours).padStart(2, "0"),
+    "H": () => String(hours),
+    "mm": () => String(minutes).padStart(2, "0"),
+    "m": () => String(minutes),
+    "ss": () => String(seconds).padStart(2, "0"),
+    "s": () => String(seconds),
+    "A": () => isPM ? "PM" : "AM",
+    "a": () => isPM ? "pm" : "am",
+    "th": () => {
+      if (locale.startsWith("fr") && day === 1) return "er";
+      if (locale.startsWith("en")) {
+        const mod10 = day % 10;
+        const mod100 = day % 100;
+        if (mod10 === 1 && mod100 !== 11) return "st";
+        if (mod10 === 2 && mod100 !== 12) return "nd";
+        if (mod10 === 3 && mod100 !== 13) return "rd";
+        return "th";
+      }
+      return "";
+    }
+  };
+  const regexp = /{{(DD|D|dd|d|MM|M|MMMM|MMM|YYYY|YY|HH|H|hh|h|mm|m|ss|s|A|a|th)}}/g;
+  return format.replace(regexp, (match, token) => replacements[token]?.() ?? match);
+}
 export {
   formatDate
 };

package/agnostic/time/duration/index.d.ts

@@ -1,26 +1,39 @@
-export declare namespace Duration {
-    type DurationType = 'milliseconds' | 'seconds' | 'minutes' | 'hours' | 'days' | 'weeks' | 'months' | 'years';
-    type DurationTypeShort = 'ms' | 's' | 'sec' | 'min' | 'm' | 'h' | 'd' | 'w' | 'mo' | 'mth' | 'y';
-    class Duration {
-        value: number;
-        type: DurationType;
-        constructor(value: number, type: DurationType | DurationTypeShort);
-        toMilliseconds: () => number;
-        toMs(): number;
-        toSeconds(): number;
-        toMinutes(): number;
-        toHours(): number;
-        toDays(): number;
-        toWeeks(): number;
-        toMonths(): number;
-        toYear(): number;
-    }
-    function milliseconds(value: number): Duration;
-    function seconds(value: number): Duration;
-    function minutes(value: number): Duration;
-    function hours(value: number): Duration;
-    function days(value: number): Duration;
-    function weeks(value: number): Duration;
-    function months(value: number): Duration;
-    function years(value: number): Duration;
+/**
+ * Supported duration types (long form).
+ */
+export type DurationType = 'milliseconds' | 'seconds' | 'minutes' | 'hours' | 'days' | 'weeks' | 'months' | 'years';
+/**
+ * Supported duration types (short form aliases).
+ */
+export type DurationTypeShort = 'ms' | 's' | 'sec' | 'min' | 'm' | 'h' | 'd' | 'w' | 'mo' | 'mth' | 'y';
+/**
+ * Represents a duration in a specific unit and allows conversion to other units.
+ */
+export declare class Duration {
+    value: number;
+    type: DurationType;
+    /**
+     * Creates a new Duration instance.
+     *
+     * @param value - The numeric value of the duration.
+     * @param type - The unit of the duration, either long or short form.
+     */
+    constructor(value: number, type: DurationType | DurationTypeShort);
+    toMilliseconds: () => number;
+    toMs(): number;
+    toSeconds(): number;
+    toMinutes(): number;
+    toHours(): number;
+    toDays(): number;
+    toWeeks(): number;
+    toMonths(): number;
+    toYear(): number;
 }
+export declare function milliseconds(value: number): Duration;
+export declare function seconds(value: number): Duration;
+export declare function minutes(value: number): Duration;
+export declare function hours(value: number): Duration;
+export declare function days(value: number): Duration;
+export declare function weeks(value: number): Duration;
+export declare function months(value: number): Duration;
+export declare function years(value: number): Duration;

package/agnostic/time/duration/index.js

@@ -1,7 +1,112 @@
-import {
-  Duration
-} from "../../../chunks/chunk-6NYUQXJT.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
+
+// src/agnostic/time/duration/index.ts
+var Duration = class {
+  value;
+  type;
+  /**
+   * Creates a new Duration instance.
+   *
+   * @param value - The numeric value of the duration.
+   * @param type - The unit of the duration, either long or short form.
+   */
+  constructor(value, type) {
+    this.toMilliseconds = this.toMilliseconds.bind(this);
+    this.toMs = this.toMs.bind(this);
+    this.toSeconds = this.toSeconds.bind(this);
+    this.toMinutes = this.toMinutes.bind(this);
+    this.toHours = this.toHours.bind(this);
+    this.toDays = this.toDays.bind(this);
+    this.toWeeks = this.toWeeks.bind(this);
+    this.toMonths = this.toMonths.bind(this);
+    this.toYear = this.toYear.bind(this);
+    this.value = value;
+    if (type === "ms" || type === "milliseconds") {
+      this.type = "milliseconds";
+    } else if (type === "s" || type === "sec" || type === "seconds") {
+      this.type = "seconds";
+    } else if (type === "m" || type === "min" || type === "minutes") {
+      this.type = "minutes";
+    } else if (type === "h" || type === "hours") {
+      this.type = "hours";
+    } else if (type === "d" || type === "days") {
+      this.type = "days";
+    } else if (type === "w" || type === "weeks") {
+      this.type = "weeks";
+    } else if (type === "mo" || type === "mth" || type === "months") {
+      this.type = "months";
+    } else if (type === "y" || type === "years") {
+      this.type = "years";
+    } else {
+      this.type = "milliseconds";
+    }
+  }
+  toMilliseconds = this.toMs;
+  toMs() {
+    if (this.type === "milliseconds") return this.value;
+    if (this.type === "seconds") return this.value * 1e3;
+    if (this.type === "minutes") return this.value * 1e3 * 60;
+    if (this.type === "hours") return this.value * 1e3 * 60 * 60;
+    if (this.type === "days") return this.value * 1e3 * 60 * 60 * 24;
+    if (this.type === "weeks") return this.value * 1e3 * 60 * 60 * 24 * 7;
+    if (this.type === "months") return this.value * 1e3 * 60 * 60 * 24 * 30;
+    if (this.type === "years") return this.value * 1e3 * 60 * 60 * 24 * 365;
+    return this.value;
+  }
+  toSeconds() {
+    return this.toMs() / 1e3;
+  }
+  toMinutes() {
+    return this.toMs() / (1e3 * 60);
+  }
+  toHours() {
+    return this.toMs() / (1e3 * 60 * 60);
+  }
+  toDays() {
+    return this.toMs() / (1e3 * 60 * 60 * 24);
+  }
+  toWeeks() {
+    return this.toMs() / (1e3 * 60 * 60 * 24 * 7);
+  }
+  toMonths() {
+    return this.toMs() / (1e3 * 60 * 60 * 24 * 30);
+  }
+  toYear() {
+    return this.toMs() / (1e3 * 60 * 60 * 24 * 365);
+  }
+};
+function milliseconds(value) {
+  return new Duration(value, "milliseconds");
+}
+function seconds(value) {
+  return new Duration(value, "seconds");
+}
+function minutes(value) {
+  return new Duration(value, "minutes");
+}
+function hours(value) {
+  return new Duration(value, "hours");
+}
+function days(value) {
+  return new Duration(value, "days");
+}
+function weeks(value) {
+  return new Duration(value, "weeks");
+}
+function months(value) {
+  return new Duration(value, "months");
+}
+function years(value) {
+  return new Duration(value, "years");
+}
 export {
-  Duration
+  Duration,
+  days,
+  hours,
+  milliseconds,
+  minutes,
+  months,
+  seconds,
+  weeks,
+  years
 };

package/agnostic/time/timeout/index.d.ts

@@ -1 +1,9 @@
+/**
+ * Executes a callback and rejects if it does not complete within a specified timeout.
+ *
+ * @template T - The type of the callback's return value.
+ * @param timeoutMs - Maximum time in milliseconds to wait for the callback to complete.
+ * @param callback - The function to execute. Can be synchronous or return a promise.
+ * @returns A promise that resolves with the callback result if completed in time, or rejects with `false` if timed out.
+ */
 export declare function timeout<T>(timeoutMs: number, callback: () => T): Promise<T>;

package/agnostic/time/timeout/index.js

@@ -1,7 +1,19 @@
-import {
-  timeout
-} from "../../../chunks/chunk-Z7ZDDBV5.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
+
+// src/agnostic/time/timeout/index.ts
+function timeout(timeoutMs, callback) {
+  let hasRejected = false;
+  return new Promise(async (resolve, reject) => {
+    const rejectTimeout = setTimeout(() => {
+      reject(false);
+      hasRejected = true;
+    }, timeoutMs);
+    const callbackResult = await callback();
+    if (hasRejected) return;
+    clearTimeout(rejectTimeout);
+    return resolve(callbackResult);
+  });
+}
 export {
   timeout
 };

package/agnostic/time/transitions/index.d.ts

@@ -1,41 +1,74 @@
-export declare namespace Transitions {
-    type Callback = (val: number, timeMs: number) => void;
-    enum Ease {
-        LINEAR = "linear",
-        EASE_IN_QUAD = "ease-in-quad",
-        EASE_OUT_QUAD = "ease-out-quad",
-        EASE_IN_OUT_QUAD = "ease-in-out-quad",
-        EASE_IN_CUBIC = "ease-in-cubic",
-        EASE_OUT_CUBIC = "ease-out-cubic",
-        EASE_IN_OUT_CUBIC = "ease-in-out-cubic",
-        EASE_IN_QUART = "ease-in-quart",
-        EASE_OUT_QUART = "ease-out-quart",
-        EASE_IN_OUT_QUART = "ease-in-out-quart",
-        EASE_IN_QUINT = "ease-in-quint",
-        EASE_OUT_QUINT = "ease-out-quint",
-        EASE_IN_OUT_QUINT = "ease-in-out-quint",
-        EASE_IN_SINE = "ease-in-sine",
-        EASE_OUT_SINE = "ease-out-sine",
-        EASE_IN_OUT_SINE = "ease-in-out-sine",
-        EASE_IN_EXPO = "ease-in-expo",
-        EASE_OUT_EXPO = "ease-out-expo",
-        EASE_IN_OUT_EXPO = "ease-in-out-expo",
-        EASE_IN_CIRC = "ease-in-circ",
-        EASE_OUT_CIRC = "ease-out-circ",
-        EASE_IN_OUT_CIRC = "ease-in-out-circ",
-        EASE_IN_BACK = "ease-in-back",
-        EASE_OUT_BACK = "ease-out-back",
-        EASE_IN_OUT_BACK = "ease-in-out-back",
-        EASE_IN_ELASTIC = "ease-in-elastic",
-        EASE_OUT_ELASTIC = "ease-out-elastic",
-        EASE_IN_OUT_ELASTIC = "ease-in-out-elastic",
-        EASE_IN_BOUNCE = "ease-in-bounce",
-        EASE_OUT_BOUNCE = "ease-out-bounce",
-        EASE_IN_OUT_BOUNCE = "ease-in-out-bounce"
-    }
-    type EasingFunction = (progress: number) => number;
-    type EasingDictionary = Record<string, EasingFunction>;
-    function transition(to: number, durationMs: number, callbackOrEase: Ease | Callback, callback?: Callback): Promise<void>;
-    const easingFunctions: EasingDictionary;
-    const easings: Record<Ease, ((ratio: number) => number) | undefined>;
+/**
+ * Callback function invoked at each step of a transition.
+ *
+ * @param val - The current eased value of the transition.
+ * @param timeMs - The timestamp (in milliseconds) when this step occurs.
+ */
+export type Callback = (val: number, timeMs: number) => void;
+/**
+ * Predefined easing function names for transitions.
+ * Used to control the acceleration pattern of a transition.
+ */
+export declare enum Ease {
+    LINEAR = "linear",
+    EASE_IN_QUAD = "ease-in-quad",
+    EASE_OUT_QUAD = "ease-out-quad",
+    EASE_IN_OUT_QUAD = "ease-in-out-quad",
+    EASE_IN_CUBIC = "ease-in-cubic",
+    EASE_OUT_CUBIC = "ease-out-cubic",
+    EASE_IN_OUT_CUBIC = "ease-in-out-cubic",
+    EASE_IN_QUART = "ease-in-quart",
+    EASE_OUT_QUART = "ease-out-quart",
+    EASE_IN_OUT_QUART = "ease-in-out-quart",
+    EASE_IN_QUINT = "ease-in-quint",
+    EASE_OUT_QUINT = "ease-out-quint",
+    EASE_IN_OUT_QUINT = "ease-in-out-quint",
+    EASE_IN_SINE = "ease-in-sine",
+    EASE_OUT_SINE = "ease-out-sine",
+    EASE_IN_OUT_SINE = "ease-in-out-sine",
+    EASE_IN_EXPO = "ease-in-expo",
+    EASE_OUT_EXPO = "ease-out-expo",
+    EASE_IN_OUT_EXPO = "ease-in-out-expo",
+    EASE_IN_CIRC = "ease-in-circ",
+    EASE_OUT_CIRC = "ease-out-circ",
+    EASE_IN_OUT_CIRC = "ease-in-out-circ",
+    EASE_IN_BACK = "ease-in-back",
+    EASE_OUT_BACK = "ease-out-back",
+    EASE_IN_OUT_BACK = "ease-in-out-back",
+    EASE_IN_ELASTIC = "ease-in-elastic",
+    EASE_OUT_ELASTIC = "ease-out-elastic",
+    EASE_IN_OUT_ELASTIC = "ease-in-out-elastic",
+    EASE_IN_BOUNCE = "ease-in-bounce",
+    EASE_OUT_BOUNCE = "ease-out-bounce",
+    EASE_IN_OUT_BOUNCE = "ease-in-out-bounce"
 }
+/**
+ * A function that maps a progress value between 0 and 1 to an eased progress value.
+ *
+ * @param progress - Progress of the transition from 0 (start) to 1 (end).
+ * @returns The eased progress value.
+ */
+export type EasingFunction = (progress: number) => number;
+/**
+ * Dictionary mapping string keys to easing functions.
+ */
+export type EasingDictionary = Record<string, EasingFunction>;
+/**
+ * Performs a numeric transition from 0 to `to` over `durationMs` milliseconds.
+ * Invokes a callback at each step with the eased value and timestamp.
+ *
+ * @param to - The number of steps or increments for the transition.
+ * @param durationMs - Total duration of the transition in milliseconds.
+ * @param callbackOrEase - Either a callback function for each step or a predefined easing name.
+ * @param callback - Optional callback if `callbackOrEase` is an easing name.
+ * @returns A promise that resolves when the transition is complete.
+ */
+export declare function transition(to: number, durationMs: number, callbackOrEase: Ease | Callback, callback?: Callback): Promise<void>;
+/**
+ * Predefined easing functions used internally by transitions.
+ */
+export declare const easingFunctions: EasingDictionary;
+/**
+ * Mapping from `Ease` enum values to easing functions.
+ */
+export declare const easings: Record<Ease, ((ratio: number) => number) | undefined>;

package/agnostic/time/transitions/index.js

@@ -1,8 +1,161 @@
 import {
-  Transitions
-} from "../../../chunks/chunk-ENMBK6H7.js";
-import "../../../chunks/chunk-4CIS3R7T.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
+  wait
+} from "../../../chunks/chunk-4CIS3R7T.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
+
+// src/agnostic/time/transitions/index.ts
+var Ease = /* @__PURE__ */ ((Ease2) => {
+  Ease2["LINEAR"] = "linear";
+  Ease2["EASE_IN_QUAD"] = "ease-in-quad";
+  Ease2["EASE_OUT_QUAD"] = "ease-out-quad";
+  Ease2["EASE_IN_OUT_QUAD"] = "ease-in-out-quad";
+  Ease2["EASE_IN_CUBIC"] = "ease-in-cubic";
+  Ease2["EASE_OUT_CUBIC"] = "ease-out-cubic";
+  Ease2["EASE_IN_OUT_CUBIC"] = "ease-in-out-cubic";
+  Ease2["EASE_IN_QUART"] = "ease-in-quart";
+  Ease2["EASE_OUT_QUART"] = "ease-out-quart";
+  Ease2["EASE_IN_OUT_QUART"] = "ease-in-out-quart";
+  Ease2["EASE_IN_QUINT"] = "ease-in-quint";
+  Ease2["EASE_OUT_QUINT"] = "ease-out-quint";
+  Ease2["EASE_IN_OUT_QUINT"] = "ease-in-out-quint";
+  Ease2["EASE_IN_SINE"] = "ease-in-sine";
+  Ease2["EASE_OUT_SINE"] = "ease-out-sine";
+  Ease2["EASE_IN_OUT_SINE"] = "ease-in-out-sine";
+  Ease2["EASE_IN_EXPO"] = "ease-in-expo";
+  Ease2["EASE_OUT_EXPO"] = "ease-out-expo";
+  Ease2["EASE_IN_OUT_EXPO"] = "ease-in-out-expo";
+  Ease2["EASE_IN_CIRC"] = "ease-in-circ";
+  Ease2["EASE_OUT_CIRC"] = "ease-out-circ";
+  Ease2["EASE_IN_OUT_CIRC"] = "ease-in-out-circ";
+  Ease2["EASE_IN_BACK"] = "ease-in-back";
+  Ease2["EASE_OUT_BACK"] = "ease-out-back";
+  Ease2["EASE_IN_OUT_BACK"] = "ease-in-out-back";
+  Ease2["EASE_IN_ELASTIC"] = "ease-in-elastic";
+  Ease2["EASE_OUT_ELASTIC"] = "ease-out-elastic";
+  Ease2["EASE_IN_OUT_ELASTIC"] = "ease-in-out-elastic";
+  Ease2["EASE_IN_BOUNCE"] = "ease-in-bounce";
+  Ease2["EASE_OUT_BOUNCE"] = "ease-out-bounce";
+  Ease2["EASE_IN_OUT_BOUNCE"] = "ease-in-out-bounce";
+  return Ease2;
+})(Ease || {});
+async function transition(to, durationMs, callbackOrEase, callback) {
+  const ease = typeof callbackOrEase === "string" ? callbackOrEase : "linear" /* LINEAR */;
+  const easing = easings[ease];
+  if (easing === void 0) return;
+  const actualCallback = callback ?? (typeof callbackOrEase === "function" ? callbackOrEase : void 0);
+  if (actualCallback === void 0) return;
+  const start = Date.now();
+  const timeTable = new Array(to).fill(null).map((_, step) => {
+    const progression = (step + 1) / to;
+    const eased = easing(progression);
+    const time = start + eased * durationMs;
+    return { time, step: eased * to };
+  });
+  for (const { time, step } of timeTable) {
+    const now = Date.now();
+    const delay = time - now;
+    if (delay <= 0) actualCallback(step, time);
+    else {
+      await wait(delay);
+      actualCallback(step, time);
+    }
+  }
+}
+var pow = Math.pow;
+var sqrt = Math.sqrt;
+var sin = Math.sin;
+var cos = Math.cos;
+var PI = Math.PI;
+var c1 = 1.70158;
+var c2 = c1 * 1.525;
+var c3 = c1 + 1;
+var c4 = 2 * PI / 3;
+var c5 = 2 * PI / 4.5;
+var bounceOut = function(x) {
+  const n1 = 7.5625;
+  const d1 = 2.75;
+  if (x < 1 / d1) return n1 * x * x;
+  if (x < 2 / d1) return n1 * (x -= 1.5 / d1) * x + 0.75;
+  if (x < 2.5 / d1) return n1 * (x -= 2.25 / d1) * x + 0.9375;
+  return n1 * (x -= 2.625 / d1) * x + 0.984375;
+};
+var easingFunctions = {
+  linear: (x) => x,
+  easeInQuad: (x) => x * x,
+  easeOutQuad: (x) => 1 - (1 - x) * (1 - x),
+  easeInOutQuad: (x) => x < 0.5 ? 2 * x * x : 1 - pow(-2 * x + 2, 2) / 2,
+  easeInCubic: (x) => x * x * x,
+  easeOutCubic: (x) => 1 - pow(1 - x, 3),
+  easeInOutCubic: (x) => x < 0.5 ? 4 * x * x * x : 1 - pow(-2 * x + 2, 3) / 2,
+  easeInQuart: (x) => x * x * x * x,
+  easeOutQuart: (x) => 1 - pow(1 - x, 4),
+  easeInOutQuart: (x) => x < 0.5 ? 8 * x * x * x * x : 1 - pow(-2 * x + 2, 4) / 2,
+  easeInQuint: (x) => x * x * x * x * x,
+  easeOutQuint: (x) => 1 - pow(1 - x, 5),
+  easeInOutQuint: (x) => x < 0.5 ? 16 * x * x * x * x * x : 1 - pow(-2 * x + 2, 5) / 2,
+  easeInSine: (x) => 1 - cos(x * PI / 2),
+  easeOutSine: (x) => sin(x * PI / 2),
+  easeInOutSine: (x) => -(cos(PI * x) - 1) / 2,
+  easeInExpo: (x) => x === 0 ? 0 : pow(2, 10 * x - 10),
+  easeOutExpo: (x) => x === 1 ? 1 : 1 - pow(2, -10 * x),
+  easeInOutExpo: (x) => {
+    return x === 0 ? 0 : x === 1 ? 1 : x < 0.5 ? pow(2, 20 * x - 10) / 2 : (2 - pow(2, -20 * x + 10)) / 2;
+  },
+  easeInCirc: (x) => 1 - sqrt(1 - pow(x, 2)),
+  easeOutCirc: (x) => sqrt(1 - pow(x - 1, 2)),
+  easeInOutCirc: (x) => x < 0.5 ? (1 - sqrt(1 - pow(2 * x, 2))) / 2 : (sqrt(1 - pow(-2 * x + 2, 2)) + 1) / 2,
+  easeInBack: (x) => c3 * x * x * x - c1 * x * x,
+  easeOutBack: (x) => 1 + c3 * pow(x - 1, 3) + c1 * pow(x - 1, 2),
+  easeInOutBack: (x) => x < 0.5 ? pow(2 * x, 2) * ((c2 + 1) * 2 * x - c2) / 2 : (pow(2 * x - 2, 2) * ((c2 + 1) * (x * 2 - 2) + c2) + 2) / 2,
+  easeInElastic: (x) => {
+    return x === 0 ? 0 : x === 1 ? 1 : -pow(2, 10 * x - 10) * sin((x * 10 - 10.75) * c4);
+  },
+  easeOutElastic: (x) => {
+    return x === 0 ? 0 : x === 1 ? 1 : pow(2, -10 * x) * sin((x * 10 - 0.75) * c4) + 1;
+  },
+  easeInOutElastic: (x) => {
+    return x === 0 ? 0 : x === 1 ? 1 : x < 0.5 ? -(pow(2, 20 * x - 10) * sin((20 * x - 11.125) * c5)) / 2 : pow(2, -20 * x + 10) * sin((20 * x - 11.125) * c5) / 2 + 1;
+  },
+  easeInBounce: (x) => 1 - bounceOut(1 - x),
+  easeOutBounce: bounceOut,
+  easeInOutBounce: (x) => x < 0.5 ? (1 - bounceOut(1 - 2 * x)) / 2 : (1 + bounceOut(2 * x - 1)) / 2
+};
+var easings = {
+  ["linear" /* LINEAR */]: easingFunctions.linear,
+  ["ease-in-quad" /* EASE_IN_QUAD */]: easingFunctions.easeInQuad,
+  ["ease-out-quad" /* EASE_OUT_QUAD */]: easingFunctions.easeOutQuad,
+  ["ease-in-out-quad" /* EASE_IN_OUT_QUAD */]: easingFunctions.easeInOutQuad,
+  ["ease-in-cubic" /* EASE_IN_CUBIC */]: easingFunctions.easeInCubic,
+  ["ease-out-cubic" /* EASE_OUT_CUBIC */]: easingFunctions.easeOutCubic,
+  ["ease-in-out-cubic" /* EASE_IN_OUT_CUBIC */]: easingFunctions.easeInOutCubic,
+  ["ease-in-quart" /* EASE_IN_QUART */]: easingFunctions.easeInQuart,
+  ["ease-out-quart" /* EASE_OUT_QUART */]: easingFunctions.easeOutQuart,
+  ["ease-in-out-quart" /* EASE_IN_OUT_QUART */]: easingFunctions.easeInOutQuart,
+  ["ease-in-quint" /* EASE_IN_QUINT */]: easingFunctions.easeInQuint,
+  ["ease-out-quint" /* EASE_OUT_QUINT */]: easingFunctions.easeOutQuint,
+  ["ease-in-out-quint" /* EASE_IN_OUT_QUINT */]: easingFunctions.easeInOutQuint,
+  ["ease-in-sine" /* EASE_IN_SINE */]: easingFunctions.easeInSine,
+  ["ease-out-sine" /* EASE_OUT_SINE */]: easingFunctions.easeOutSine,
+  ["ease-in-out-sine" /* EASE_IN_OUT_SINE */]: easingFunctions.easeInOutSine,
+  ["ease-in-expo" /* EASE_IN_EXPO */]: easingFunctions.easeInExpo,
+  ["ease-out-expo" /* EASE_OUT_EXPO */]: easingFunctions.easeOutExpo,
+  ["ease-in-out-expo" /* EASE_IN_OUT_EXPO */]: easingFunctions.easeInOutExpo,
+  ["ease-in-circ" /* EASE_IN_CIRC */]: easingFunctions.easeInCirc,
+  ["ease-out-circ" /* EASE_OUT_CIRC */]: easingFunctions.easeOutCirc,
+  ["ease-in-out-circ" /* EASE_IN_OUT_CIRC */]: easingFunctions.easeInOutCirc,
+  ["ease-in-back" /* EASE_IN_BACK */]: easingFunctions.easeInBack,
+  ["ease-out-back" /* EASE_OUT_BACK */]: easingFunctions.easeOutBack,
+  ["ease-in-out-back" /* EASE_IN_OUT_BACK */]: easingFunctions.easeInOutBack,
+  ["ease-in-elastic" /* EASE_IN_ELASTIC */]: easingFunctions.easeInElastic,
+  ["ease-out-elastic" /* EASE_OUT_ELASTIC */]: easingFunctions.easeOutElastic,
+  ["ease-in-out-elastic" /* EASE_IN_OUT_ELASTIC */]: easingFunctions.easeInOutElastic,
+  ["ease-in-bounce" /* EASE_IN_BOUNCE */]: easingFunctions.easeInBounce,
+  ["ease-out-bounce" /* EASE_OUT_BOUNCE */]: easingFunctions.easeOutBounce,
+  ["ease-in-out-bounce" /* EASE_IN_OUT_BOUNCE */]: easingFunctions.easeInOutBounce
+};
 export {
-  Transitions
+  Ease,
+  easingFunctions,
+  easings,
+  transition
 };

package/agnostic/time/wait/index.d.ts

@@ -1 +1,7 @@
+/**
+ * Returns a promise that resolves after the specified duration in milliseconds.
+ *
+ * @param durationMs - Time to wait in milliseconds.
+ * @returns A promise that resolves to `true` after the delay.
+ */
 export declare function wait(durationMs: number): Promise<unknown>;

package/agnostic/time/wait/index.js

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

package/agnostic/typescript/types.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Converts `undefined` to `null` in a type, while preserving other types.
+ *
+ * @template T - The type to transform
+ * @returns If T extends `undefined`, returns `null`, otherwise returns T
+ *
+ * @example
+ * ```ts
+ * type Example1 = NullIfUndefined<string | undefined>; // string | null
+ * type Example2 = NullIfUndefined<number>; // number
+ * type Example3 = NullIfUndefined<undefined>; // null
+ * ```
+ */
+export type NullIfUndefined<T> = T extends undefined ? null : T;
+/**
+ * Makes specific keys of a type required, while keeping other keys optional.
+ *
+ * @template T - The base type
+ * @template K - The keys of T that should be required
+ * @returns A new type where keys K are required and other keys remain as they were
+ *
+ * @example
+ * ```ts
+ * interface User {
+ *   name?: string;
+ *   age?: number;
+ *   email?: string;
+ * }
+ *
+ * type UserWithRequiredName = RequireKeys<User, 'name'>;
+ * // { name: string; age?: number; email?: string; }
+ *
+ * type UserWithRequiredNameAndEmail = RequireKeys<User, 'name' | 'email'>;
+ * // { name: string; age?: number; email: string; }
+ * ```
+ */
+export type RequireKeys<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;