@design-edito/tools 0.2.39 → 0.2.40

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/chunks/{chunk-CLLJV343.js → chunk-27SSMK5F.js}

@@ -1,16 +1,17 @@
 import {
   zod_default
-} from "./chunk-DZ2T5DTY.js";
+} from "./chunk-LFHDJTZJ.js";
 import {
   isDuckTypedSharpInstance,
   toSharpInstance
-} from "./chunk-D5CCWCEI.js";
+} from "./chunk-ENOTZXFS.js";
 import {
-  Outcome
-} from "./chunk-JMU5PDBD.js";
+  makeFailure,
+  makeSuccess
+} from "./chunk-QEKI6WGQ.js";
 import {
   isColor
-} from "./chunk-67V4BGOB.js";
+} from "./chunk-JDINERKY.js";
 
 // src/node/images/transform/operations/overlay/index.ts
 import sharp from "sharp";
@@ -85,8 +86,8 @@ function isOverlayOperationParams(obj) {
     ]).optional()
   });
   const result = schema.safeParse(obj);
-  if (!result.success) return Outcome.makeFailure(result.error.message);
-  return Outcome.makeSuccess(result.data);
+  if (!result.success) return makeFailure(result.error.message);
+  return makeSuccess(result.data);
 }
 async function overlay(sharpInstance, params) {
   const inputBuffer = params.input instanceof Buffer ? params.input : await (await toSharpInstance(params.input)).toBuffer();

package/chunks/{chunk-FNQAF6CQ.js → chunk-2QDYPY2O.js}

@@ -1,6 +1,3 @@
-import {
-  absoluteModulo
-} from "./chunk-DNIOWD7K.js";
 import {
   clamp
 } from "./chunk-OSAXBA7G.js";
@@ -14,10 +11,13 @@ import {
   isLch,
   isRgb,
   isXyz
-} from "./chunk-67V4BGOB.js";
+} from "./chunk-JDINERKY.js";
+import {
+  absoluteModulo
+} from "./chunk-DNIOWD7K.js";
 import {
   cssColors
-} from "./chunk-7UGMWTP5.js";
+} from "./chunk-KRYJVBO5.js";
 
 // src/agnostic/colors/convert/index.ts
 function _hex2rgb(hex) {

package/chunks/{chunk-ON6LC3HE.js → chunk-2WSVYQ5Q.js}

@@ -1,18 +1,12 @@
 import {
-  Outcome
-} from "./chunk-JMU5PDBD.js";
+  makeFailure,
+  makeSuccess
+} from "./chunk-QEKI6WGQ.js";
 import {
   unknownToString
 } from "./chunk-FENXVJYO.js";
-import {
-  __export
-} from "./chunk-WSFCRVEQ.js";
 
 // src/node/@aws-s3/storage/directory/move-dir/index.ts
-var move_dir_exports = {};
-__export(move_dir_exports, {
-  moveDir: () => moveDir
-});
 import {
   ListObjectsV2Command,
   CopyObjectCommand,
@@ -72,13 +66,12 @@ async function moveDir(client, bucketName, sourceDir, targetDir, options) {
       }
       token = listResp.IsTruncated ? listResp.NextContinuationToken : void 0;
     } while (token);
-    return Outcome.makeSuccess(true);
+    return makeSuccess(true);
   } catch (err) {
-    return Outcome.makeFailure(unknownToString(err));
+    return makeFailure(unknownToString(err));
   }
 }
 
 export {
-  moveDir,
-  move_dir_exports
+  moveDir
 };

package/chunks/chunk-4WE2WEXL.js

@@ -0,0 +1,12 @@
+// node_modules/ansi-regex/index.js
+function ansiRegex({ onlyFirst = false } = {}) {
+  const ST = "(?:\\u0007|\\u001B\\u005C|\\u009C)";
+  const osc = `(?:\\u001B\\][\\s\\S]*?${ST})`;
+  const csi = "[\\u001B\\u009B][[\\]()#;?]*(?:\\d{1,4}(?:[;:]\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]";
+  const pattern = `${osc}|${csi}`;
+  return new RegExp(pattern, onlyFirst ? void 0 : "g");
+}
+
+export {
+  ansiRegex
+};

package/chunks/{chunk-QWNWZBIO.js → chunk-53ILYMIY.js}

@@ -1,15 +1,16 @@
 import {
   zod_default
-} from "./chunk-DZ2T5DTY.js";
+} from "./chunk-LFHDJTZJ.js";
 import {
   toSharpColor
-} from "./chunk-D5CCWCEI.js";
+} from "./chunk-ENOTZXFS.js";
 import {
-  Outcome
-} from "./chunk-JMU5PDBD.js";
+  makeFailure,
+  makeSuccess
+} from "./chunk-QEKI6WGQ.js";
 import {
   isColor
-} from "./chunk-67V4BGOB.js";
+} from "./chunk-JDINERKY.js";
 
 // src/node/images/transform/operations/rotate/index.ts
 function isRotateOperationParams(obj) {
@@ -18,8 +19,8 @@ function isRotateOperationParams(obj) {
     background: zod_default.custom(isColor).optional()
   });
   const result = schema.safeParse(obj);
-  if (!result.success) return Outcome.makeFailure(result.error.message);
-  return Outcome.makeSuccess(result.data);
+  if (!result.success) return makeFailure(result.error.message);
+  return makeSuccess(result.data);
 }
 async function rotate(sharpInstance, params) {
   return sharpInstance.rotate(params.angleDeg, {

package/chunks/{chunk-FF5NURFO.js → chunk-54KPQCVI.js}

@@ -1,32 +1,25 @@
 import {
-  Outcome
-} from "./chunk-JMU5PDBD.js";
+  makeFailure,
+  makeSuccess
+} from "./chunk-QEKI6WGQ.js";
 import {
   unknownToString
 } from "./chunk-FENXVJYO.js";
-import {
-  __export
-} from "./chunk-WSFCRVEQ.js";
 
 // src/node/ftps/file/download/index.ts
-var download_exports = {};
-__export(download_exports, {
-  download: () => download
-});
 import { PassThrough } from "node:stream";
 async function download(ftpClient, sourcePath, options) {
   const { startAt } = options ?? {};
   const stream = new PassThrough();
   try {
     await ftpClient.downloadTo(stream, sourcePath, startAt);
-    return Outcome.makeSuccess(stream);
+    return makeSuccess(stream);
   } catch (err) {
     const errStr = unknownToString(err);
-    return Outcome.makeFailure(errStr);
+    return makeFailure(errStr);
   }
 }
 
 export {
-  download,
-  download_exports
+  download
 };

package/chunks/{chunk-SRXNICSE.js → chunk-5CFQCSKJ.js}

@@ -1,16 +1,17 @@
 import {
   zod_default
-} from "./chunk-DZ2T5DTY.js";
+} from "./chunk-LFHDJTZJ.js";
 import {
-  Outcome
-} from "./chunk-JMU5PDBD.js";
+  makeFailure,
+  makeSuccess
+} from "./chunk-QEKI6WGQ.js";
 
 // src/node/images/transform/operations/brighten/index.ts
 function isBrightenOperationParams(obj) {
   const schema = zod_default.object({ factor: zod_default.number() });
   const result = schema.safeParse(obj);
-  if (!result.success) return Outcome.makeFailure(result.error.message);
-  return Outcome.makeSuccess(result.data);
+  if (!result.success) return makeFailure(result.error.message);
+  return makeSuccess(result.data);
 }
 async function brighten(sharpInstance, params) {
   return sharpInstance.modulate({ brightness: params.factor });