@tempots/beatui 0.87.2 → 0.87.4

package/dist/{stack-BJgsPJ9A.js → stack-Bm-UZosx.js}

@@ -1,5 +1,5 @@
 import { html as n, attr as o } from "@tempots/dom";
-const r = {
+const e = {
   /**
    * Creates a loading state.
    * @param previousValue - The previous value.
@@ -71,53 +71,59 @@ const r = {
     return s.type === "Loading";
   },
   /**
-   * Gets the value if the result is a success; otherwise, returns the alternative value.
+   * Gets the value if the result is a success or loading with a previous value; otherwise, returns the alternative value.
    * @param r - The result.
    * @param alt - The alternative value.
-   * @returns The value if the result is a success; otherwise, the alternative value.
+   * @returns The value if the result is a success or loading with previous value; otherwise, the alternative value.
    * @public
    */
-  getOrElse(s, e) {
-    return r.isSuccess(s) ? s.value : e;
+  getOrElse(s, r) {
+    return e.isSuccess(s) ? s.value : e.isLoading(s) && s.previousValue !== void 0 ? s.previousValue : r;
   },
   /**
-   * Gets the value if the result is a success; otherwise, returns the value from the alternative function.
+   * Gets the value if the result is a success or loading with a previous value; otherwise, returns the value from the alternative function.
    * @param r - The result.
    * @param altf - The alternative function.
-   * @returns The value if the result is a success; otherwise, the value from the alternative
+   * @returns The value if the result is a success or loading with previous value; otherwise, the value from the alternative function.
    * @public
-   * function.
    */
-  getOrElseLazy(s, e) {
-    return r.isSuccess(s) ? s.value : e();
+  getOrElseLazy(s, r) {
+    return e.isSuccess(s) ? s.value : e.isLoading(s) && s.previousValue !== void 0 ? s.previousValue : r();
   },
   /**
-   * Gets the value if the result is a success; otherwise, returns `null`.
+   * Gets the value if the result is a success or loading with a previous value; otherwise, returns `null`.
    * @param r - The result.
-   * @returns The value if the result is a success; otherwise, `null`.
+   * @returns The value if the result is a success or loading with previous value; otherwise, `null`.
    * @public
    */
   getOrNull(s) {
-    return r.isSuccess(s) ? s.value : null;
+    return e.isSuccess(s) ? s.value : e.isLoading(s) && s.previousValue !== void 0 ? s.previousValue : null;
   },
   /**
-   * Gets the value if the result is a success; otherwise, returns `undefined`.
+   * Gets the value if the result is a success or loading with a previous value; otherwise, returns `undefined`.
    * @param r - The result.
-   * @returns The value if the result is a success; otherwise, `undefined`.
+   * @returns The value if the result is a success or loading with previous value; otherwise, `undefined`.
    * @public
    */
   getOrUndefined(s) {
-    return r.isSuccess(s) ? s.value : void 0;
+    if (e.isSuccess(s))
+      return s.value;
+    if (e.isLoading(s) && s.previousValue !== void 0)
+      return s.previousValue;
   },
   /**
-   * Gets the value of a `AsyncResult` if it is a `Success`, otherwise it throws the error contained in the `Failure`.
+   * Gets the value of a `AsyncResult` if it is a `Success` or loading with a previous value, otherwise it throws the error contained in the `Failure`.
    * @param r - The `AsyncResult` to get the value from.
-   * @returns The value of the `AsyncResult` if it is a `Success`.
+   * @returns The value of the `AsyncResult` if it is a `Success` or loading with previous value.
    */
   getUnsafe: (s) => {
-    if (r.isSuccess(s))
+    if (e.isSuccess(s))
       return s.value;
-    throw r.isFailure(s) ? s.error : new Error("Cannot get value from a not-asked or loading result");
+    if (e.isLoading(s) && s.previousValue !== void 0)
+      return s.previousValue;
+    throw e.isFailure(s) ? s.error : new Error(
+      "Cannot get value from a not-asked or loading result without previous value"
+    );
   },
   /**
    * Based on the state of the result, it picks the appropriate function to call and returns the result.
@@ -129,11 +135,11 @@ const r = {
    * @public
    */
   match: (s, {
-    success: e,
+    success: r,
     failure: u,
-    loading: i,
-    notAsked: l = i
-  }) => r.isSuccess(s) ? e(s.value) : r.isFailure(s) ? u(s.error) : r.isNotAsked(s) ? l() : i(s.previousValue),
+    loading: l,
+    notAsked: c = l
+  }) => e.isSuccess(s) ? r(s.value) : e.isFailure(s) ? u(s.error) : e.isNotAsked(s) ? c() : l(s.previousValue),
   /**
    * Executes side effects based on the state of the result.
    * Unlike `match`, all handlers are optional, allowing you to react only to specific states.
@@ -143,19 +149,19 @@ const r = {
    * @returns The result that was passed in, allowing for chaining.
    * @public
    */
-  effect: (s, e) => {
+  effect: (s, r) => {
     switch (s.type) {
       case "AsyncSuccess":
-        e.success ? e.success(s.value) : e.else?.();
+        r.success ? r.success(s.value) : r.else?.();
         break;
       case "AsyncFailure":
-        e.failure ? e.failure(s.error) : e.else?.();
+        r.failure ? r.failure(s.error) : r.else?.();
         break;
       case "Loading":
-        e.loading ? e.loading(s.previousValue) : e.else?.();
+        r.loading ? r.loading(s.previousValue) : r.else?.();
         break;
       case "NotAsked":
-        e.notAsked ? e.notAsked() : e.else?.();
+        r.notAsked ? r.notAsked() : r.else?.();
         break;
     }
     return s;
@@ -168,7 +174,7 @@ const r = {
    * @returns The result that was passed in.
    * @public
    */
-  whenSuccess: (s, e) => (r.isSuccess(s) && e(s.value), s),
+  whenSuccess: (s, r) => (e.isSuccess(s) && r(s.value), s),
   /**
    * When the result is a failure, it applies the function to the error.
    *
@@ -177,7 +183,7 @@ const r = {
    * @returns The result that was passed in.
    * @public
    */
-  whenFailure: (s, e) => (r.isFailure(s) && e(s.error), s),
+  whenFailure: (s, r) => (e.isFailure(s) && r(s.error), s),
   /**
    * Compares two results for equality.
    * @param r1 - The first result.
@@ -185,23 +191,23 @@ const r = {
    * @param options - The options to use for comparison. By default, uses strict equality.
    * @returns `true` if the results are equal, `false` otherwise.
    */
-  equals: (s, e, u = {
-    valueEquals: (i, l) => i === l,
-    errorEquals: (i, l) => i === l
-  }) => s.type === "AsyncSuccess" && e.type === "AsyncSuccess" ? u.valueEquals(s.value, e.value) : s.type === "AsyncFailure" && e.type === "AsyncFailure" ? u.errorEquals(s.error, e.error) : s.type === "Loading" && e.type === "Loading" ? u.valueEquals(s.previousValue, e.previousValue) : s.type === "NotAsked" && e.type === "NotAsked",
+  equals: (s, r, u = {
+    valueEquals: (l, c) => l === c,
+    errorEquals: (l, c) => l === c
+  }) => s.type === "AsyncSuccess" && r.type === "AsyncSuccess" ? u.valueEquals(s.value, r.value) : s.type === "AsyncFailure" && r.type === "AsyncFailure" ? u.errorEquals(s.error, r.error) : s.type === "Loading" && r.type === "Loading" ? u.valueEquals(s.previousValue, r.previousValue) : s.type === "NotAsked" && r.type === "NotAsked",
   /**
    * Combines multiple results into a single result.
    * @param results - The results to combine.
    * @returns A single result that is a success if all the input results are successes, otherwise a failure.
    */
   all: (s) => {
-    const e = [];
+    const r = [];
     for (const u of s)
-      if (r.isSuccess(u))
-        e.push(u.value);
+      if (e.isSuccess(u))
+        r.push(u.value);
       else
         return u;
-    return r.success(e);
+    return e.success(r);
   },
   /**
    * Converts a Promise to an AsyncResult.
@@ -210,10 +216,10 @@ const r = {
    */
   ofPromise: async (s) => {
     try {
-      const e = await s;
-      return r.success(e);
-    } catch (e) {
-      return r.failure(e instanceof Error ? e : new Error(String(e)));
+      const r = await s;
+      return e.success(r);
+    } catch (r) {
+      return e.failure(r instanceof Error ? r : new Error(String(r)));
     }
   },
   /**
@@ -225,17 +231,17 @@ const r = {
    * @returns A new `AsyncResult` with the mapped value if successful, otherwise the original state.
    * @public
    */
-  map: (s, e) => {
+  map: (s, r) => {
     switch (s.type) {
       case "AsyncSuccess":
-        return r.success(e(s.value));
+        return e.success(r(s.value));
       case "NotAsked":
-        return r.notAsked;
+        return e.notAsked;
       case "AsyncFailure":
-        return r.failure(s.error);
+        return e.failure(s.error);
       case "Loading":
-        return r.loading(
-          s.previousValue != null ? e(s.previousValue) : void 0
+        return e.loading(
+          s.previousValue != null ? r(s.previousValue) : void 0
         );
     }
   },
@@ -247,16 +253,16 @@ const r = {
    * @returns The result of the mapping function if successful, otherwise the original state.
    * @public
    */
-  flatMap: (s, e) => {
+  flatMap: (s, r) => {
     switch (s.type) {
       case "AsyncSuccess":
-        return e(s.value);
+        return r(s.value);
       case "NotAsked":
-        return r.notAsked;
+        return e.notAsked;
       case "AsyncFailure":
-        return r.failure(s.error);
+        return e.failure(s.error);
       case "Loading":
-        return r.loading();
+        return e.loading();
     }
   },
   /**
@@ -267,16 +273,16 @@ const r = {
    * @returns A new `AsyncResult` with the mapped error if failed, otherwise the original state.
    * @public
    */
-  mapError: (s, e) => {
+  mapError: (s, r) => {
     switch (s.type) {
       case "AsyncSuccess":
-        return r.success(s.value);
+        return e.success(s.value);
       case "NotAsked":
-        return r.notAsked;
+        return e.notAsked;
       case "AsyncFailure":
-        return r.failure(e(s.error));
+        return e.failure(r(s.error));
       case "Loading":
-        return r.loading(s.previousValue);
+        return e.loading(s.previousValue);
     }
   },
   /**
@@ -287,16 +293,16 @@ const r = {
    * @returns The result of the recovery function if failed, otherwise the original state.
    * @public
    */
-  flatMapError: (s, e) => {
+  flatMapError: (s, r) => {
     switch (s.type) {
       case "AsyncSuccess":
-        return r.success(s.value);
+        return e.success(s.value);
       case "NotAsked":
-        return r.notAsked;
+        return e.notAsked;
       case "AsyncFailure":
-        return e(s.error);
+        return r(s.error);
       case "Loading":
-        return r.loading(s.previousValue);
+        return e.loading(s.previousValue);
     }
   },
   /**
@@ -333,16 +339,16 @@ const r = {
    * @returns A successful `AsyncResult` with the alternative value if failed, otherwise the original state.
    * @public
    */
-  recover: (s, e) => {
+  recover: (s, r) => {
     switch (s.type) {
       case "AsyncSuccess":
-        return r.success(s.value);
+        return e.success(s.value);
       case "NotAsked":
-        return r.notAsked;
+        return e.notAsked;
       case "AsyncFailure":
-        return r.success(e(s.error));
+        return e.success(r(s.error));
       case "Loading":
-        return r.loading(s.previousValue);
+        return e.loading(s.previousValue);
     }
   },
   /**
@@ -353,7 +359,7 @@ const r = {
    * @returns A new `AsyncResult` with the result of applying the function to the value.
    * @public
    */
-  ap: (s, e) => r.isSuccess(s) && r.isSuccess(e) ? r.success(s.value(e.value)) : r.isFailure(s) ? r.failure(s.error) : r.isFailure(e) ? r.failure(e.error) : r.isLoading(s) || r.isLoading(e) ? r.loading() : r.notAsked,
+  ap: (s, r) => e.isSuccess(s) && e.isSuccess(r) ? e.success(s.value(r.value)) : e.isFailure(s) ? e.failure(s.error) : e.isFailure(r) ? e.failure(r.error) : e.isLoading(s) || e.isLoading(r) ? e.loading() : e.notAsked,
   /**
    * Maps two `AsyncResult` values using a function.
    * @param r1 - The first `AsyncResult`.
@@ -362,7 +368,7 @@ const r = {
    * @returns A new `AsyncResult` with the result of applying the function to both values.
    * @public
    */
-  map2: (s, e, u) => r.isSuccess(s) && r.isSuccess(e) ? r.success(u(s.value, e.value)) : r.isFailure(s) ? r.failure(s.error) : r.isFailure(e) ? r.failure(e.error) : r.isLoading(s) || r.isLoading(e) ? r.loading() : r.notAsked,
+  map2: (s, r, u) => e.isSuccess(s) && e.isSuccess(r) ? e.success(u(s.value, r.value)) : e.isFailure(s) ? e.failure(s.error) : e.isFailure(r) ? e.failure(r.error) : e.isLoading(s) || e.isLoading(r) ? e.loading() : e.notAsked,
   /**
    * Maps three `AsyncResult` values using a function.
    * @param r1 - The first `AsyncResult`.
@@ -372,8 +378,8 @@ const r = {
    * @returns A new `AsyncResult` with the result of applying the function to all three values.
    * @public
    */
-  map3: (s, e, u, i) => r.isSuccess(s) && r.isSuccess(e) && r.isSuccess(u) ? r.success(i(s.value, e.value, u.value)) : r.isFailure(s) ? r.failure(s.error) : r.isFailure(e) ? r.failure(e.error) : r.isFailure(u) ? r.failure(u.error) : r.isLoading(s) || r.isLoading(e) || r.isLoading(u) ? r.loading() : r.notAsked
-}, c = {
+  map3: (s, r, u, l) => e.isSuccess(s) && e.isSuccess(r) && e.isSuccess(u) ? e.success(l(s.value, r.value, u.value)) : e.isFailure(s) ? e.failure(s.error) : e.isFailure(r) ? e.failure(r.error) : e.isFailure(u) ? e.failure(u.error) : e.isLoading(s) || e.isLoading(r) || e.isLoading(u) ? e.loading() : e.notAsked
+}, i = {
   /**
    * Creates a valid `Validation`.
    * @returns A `Validation` that is `Valid`.
@@ -411,16 +417,16 @@ const r = {
    * @param invalid - The mapping function for an invalid value.
    * @returns The mapped value.
    */
-  match: (s, e, u) => c.isValid(s) ? e() : u(s.error),
+  match: (s, r, u) => i.isValid(s) ? r() : u(s.error),
   /**
    * Maps the value of a `Validation` to a new `Validation`.
    * @param validation - The `Validation` to map.
    * @param value - The value to map.
    * @returns A new `Validation` with the mapped value.
    */
-  toResult: (s, e) => c.match(
+  toResult: (s, r) => i.match(
     s,
-    () => a.success(e),
+    () => a.success(r),
     (u) => a.failure(u)
   ),
   /**
@@ -432,7 +438,7 @@ const r = {
    * @returns The validation that was passed in, allowing for chaining.
    * @public
    */
-  effect: (s, e) => (s.type === "valid" ? e.valid ? e.valid() : e.else?.() : e.invalid ? e.invalid(s.error) : e.else?.(), s),
+  effect: (s, r) => (s.type === "valid" ? r.valid ? r.valid() : r.else?.() : r.invalid ? r.invalid(s.error) : r.else?.(), s),
   /**
    * Execute a function when the `Validation` is valid.
    *
@@ -440,7 +446,7 @@ const r = {
    * @param apply - The function to execute when the `Validation` is valid.
    * @returns The `Validation` object.
    */
-  whenValid: (s, e) => (c.isValid(s) && e(), s),
+  whenValid: (s, r) => (i.isValid(s) && r(), s),
   /**
    * Execute a function when the `Validation` is invalid.
    *
@@ -448,7 +454,7 @@ const r = {
    * @param apply - The function to execute when the `Validation` is invalid.
    * @returns The `Validation` object.
    */
-  whenInvalid: (s, e) => (c.isInvalid(s) && e(s.error), s),
+  whenInvalid: (s, r) => (i.isInvalid(s) && r(s.error), s),
   /**
    * Maps the error of an invalid `Validation` to a new error using the provided function.
    * For valid validations, the validation is preserved unchanged.
@@ -457,7 +463,7 @@ const r = {
    * @returns A new `Validation` with the mapped error if invalid, otherwise the original valid.
    * @public
    */
-  mapError: (s, e) => s.type === "invalid" ? c.invalid(e(s.error)) : s,
+  mapError: (s, r) => s.type === "invalid" ? i.invalid(r(s.error)) : s,
   /**
    * Maps the error of an invalid `Validation` to a new `Validation` using the provided function.
    * This allows recovery from errors by returning a valid validation.
@@ -466,7 +472,7 @@ const r = {
    * @returns The result of the recovery function if invalid, otherwise the original valid.
    * @public
    */
-  flatMapError: (s, e) => s.type === "invalid" ? e(s.error) : s,
+  flatMapError: (s, r) => s.type === "invalid" ? r(s.error) : s,
   /**
    * Combines two validations. Both must be valid for the result to be valid.
    * If both are invalid, errors are combined using the provided function.
@@ -476,7 +482,7 @@ const r = {
    * @returns A combined validation.
    * @public
    */
-  combine: (s, e, u) => c.isValid(s) && c.isValid(e) ? c.valid : c.isInvalid(s) && c.isInvalid(e) ? c.invalid(u(s.error, e.error)) : c.isInvalid(s) ? s : e,
+  combine: (s, r, u) => i.isValid(s) && i.isValid(r) ? i.valid : i.isInvalid(s) && i.isInvalid(r) ? i.invalid(u(s.error, r.error)) : i.isInvalid(s) ? s : r,
   /**
    * Combines multiple validations into a single validation.
    * All must be valid for the result to be valid.
@@ -486,10 +492,10 @@ const r = {
    * @public
    */
   all: (s) => {
-    for (const e of s)
-      if (c.isInvalid(e))
-        return e;
-    return c.valid;
+    for (const r of s)
+      if (i.isInvalid(r))
+        return r;
+    return i.valid;
   },
   /**
    * Combines multiple validations, accumulating all errors.
@@ -500,10 +506,10 @@ const r = {
    * @public
    */
   allErrors: (s) => {
-    const e = [];
+    const r = [];
     for (const u of s)
-      c.isInvalid(u) && e.push(u.error);
-    return e.length > 0 ? c.invalid(e) : c.valid;
+      i.isInvalid(u) && r.push(u.error);
+    return r.length > 0 ? i.invalid(r) : i.valid;
   },
   /**
    * Compares two validations for equality.
@@ -513,7 +519,7 @@ const r = {
    * @returns `true` if the validations are equal, `false` otherwise.
    * @public
    */
-  equals: (s, e, u = (i, l) => i === l) => s.type === "valid" && e.type === "valid" ? !0 : s.type === "invalid" && e.type === "invalid" ? u(s.error, e.error) : !1,
+  equals: (s, r, u = (l, c) => l === c) => s.type === "valid" && r.type === "valid" ? !0 : s.type === "invalid" && r.type === "invalid" ? u(s.error, r.error) : !1,
   /**
    * Recovers from an invalid validation by returning a valid validation.
    * @param v - The `Validation` to recover from.
@@ -521,7 +527,7 @@ const r = {
    * @public
    */
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  recover: (s) => c.valid,
+  recover: (s) => i.valid,
   /**
    * Gets the error if the validation is invalid, otherwise returns undefined.
    * @param v - The validation to get the error from.
@@ -529,7 +535,7 @@ const r = {
    * @public
    */
   getError: (s) => {
-    if (c.isInvalid(s))
+    if (i.isInvalid(s))
       return s.error;
   },
   /**
@@ -539,7 +545,7 @@ const r = {
    * @returns The error if invalid, otherwise the default error.
    * @public
    */
-  getErrorOrElse: (s, e) => c.isInvalid(s) ? s.error : e
+  getErrorOrElse: (s, r) => i.isInvalid(s) ? s.error : r
 }, a = {
   /**
    * Creates a successful `Result`.
@@ -568,7 +574,7 @@ const r = {
    * @returns A new `Result` with the mapped value.
    * @public
    */
-  map: (s, e) => s.type === "Success" ? a.success(e(s.value)) : s,
+  map: (s, r) => s.type === "Success" ? a.success(r(s.value)) : s,
   /**
    * Maps the value of a `Result` to a new `Result`.
    * @param r - The `Result` to map.
@@ -576,7 +582,7 @@ const r = {
    * @returns A new `Result` with the mapped value.
    * @public
    */
-  flatMap: (s, e) => s.type === "Success" ? e(s.value) : s,
+  flatMap: (s, r) => s.type === "Success" ? r(s.value) : s,
   /**
    * Converts a `Result` to an `AsyncResult`.
    * @param r - The `Result` to convert.
@@ -586,8 +592,8 @@ const r = {
   toAsync(s) {
     return a.match(
       s,
-      (e) => r.success(e),
-      (e) => r.failure(e)
+      (r) => e.success(r),
+      (r) => e.failure(r)
     );
   },
   /**
@@ -599,8 +605,8 @@ const r = {
   toValidation(s) {
     return a.match(
       s,
-      () => c.valid,
-      (e) => c.invalid(e)
+      () => i.valid,
+      (r) => i.invalid(r)
     );
   },
   /**
@@ -628,8 +634,8 @@ const r = {
    * @returns The value of the `Result` if it is a `Success`, otherwise the default value.
    * @public
    */
-  getOrElse(s, e) {
-    return a.isSuccess(s) ? s.value : e;
+  getOrElse(s, r) {
+    return a.isSuccess(s) ? s.value : r;
   },
   /**
    * Gets the value of a `Result` if it is a `Success`, otherwise returns the result of the provided function.
@@ -638,8 +644,8 @@ const r = {
    * @returns The value of the `Result` if it is a `Success`, otherwise the result of the function.
    * @public
    */
-  getOrElseLazy(s, e) {
-    return a.isSuccess(s) ? s.value : e();
+  getOrElseLazy(s, r) {
+    return a.isSuccess(s) ? s.value : r();
   },
   /**
    * Gets the value of a `Result` if it is a `Success`, otherwise returns `null`.
@@ -676,7 +682,7 @@ const r = {
    * @returns The result of calling the appropriate function based on the state of the result.
    * @public
    */
-  match: (s, e, u) => a.isSuccess(s) ? e(s.value) : u(s.error),
+  match: (s, r, u) => a.isSuccess(s) ? r(s.value) : u(s.error),
   /**
    * Executes side effects based on the state of the result.
    * Unlike `match`, all handlers are optional, allowing you to react only to specific states.
@@ -686,21 +692,21 @@ const r = {
    * @returns The result that was passed in, allowing for chaining.
    * @public
    */
-  effect: (s, e) => (s.type === "Success" ? e.success ? e.success(s.value) : e.else?.() : e.failure ? e.failure(s.error) : e.else?.(), s),
+  effect: (s, r) => (s.type === "Success" ? r.success ? r.success(s.value) : r.else?.() : r.failure ? r.failure(s.error) : r.else?.(), s),
   /**
    * Calls the provided function if the result is a success.
    * @param apply - The function to call if the result is a success.
    * @returns A function that takes a `Result` and calls the provided function if the result is a success.
    * @public
    */
-  whenSuccess: (s, e) => (a.isSuccess(s) && e(s.value), s),
+  whenSuccess: (s, r) => (a.isSuccess(s) && r(s.value), s),
   /**
    * Calls the provided function if the result is a failure.
    * @param apply - The function to call if the result is a failure.
    * @returns The result that was passed in.
    * @public
    */
-  whenFailure: (s, e) => (a.isFailure(s) && e(s.error), s),
+  whenFailure: (s, r) => (a.isFailure(s) && r(s.error), s),
   /**
    * Combines two results into a single result.
    * @param r1 - The first result.
@@ -710,18 +716,18 @@ const r = {
    * @returns The combined result.
    * @public
    */
-  combine: (s, e, u, i) => a.match(
+  combine: (s, r, u, l) => a.match(
     s,
-    (l) => a.match(
-      e,
-      (t) => a.success(u(l, t)),
+    (c) => a.match(
+      r,
+      (t) => a.success(u(c, t)),
       (t) => a.failure(t)
     ),
-    (l) => a.match(
-      e,
+    (c) => a.match(
+      r,
       // eslint-disable-next-line @typescript-eslint/no-unused-vars
-      (t) => a.failure(l),
-      (t) => a.failure(i(l, t))
+      (t) => a.failure(c),
+      (t) => a.failure(l(c, t))
     )
   ),
   /**
@@ -731,23 +737,23 @@ const r = {
    * @param options - The options to use for comparison. By default, uses strict equality.
    * @returns `true` if the results are equal, `false` otherwise.
    */
-  equals: (s, e, u = {
-    valueEquals: (i, l) => i === l,
-    errorEquals: (i, l) => i === l
-  }) => s.type === "Success" && e.type === "Success" ? u.valueEquals(s.value, e.value) : s.type === "Failure" && e.type === "Failure" ? u.errorEquals(s.error, e.error) : !1,
+  equals: (s, r, u = {
+    valueEquals: (l, c) => l === c,
+    errorEquals: (l, c) => l === c
+  }) => s.type === "Success" && r.type === "Success" ? u.valueEquals(s.value, r.value) : s.type === "Failure" && r.type === "Failure" ? u.errorEquals(s.error, r.error) : !1,
   /**
    * Combines multiple results into a single result.
    * @param results - The results to combine.
    * @returns A single result that is a success if all the input results are successes, otherwise a failure.
    */
   all: (s) => {
-    const e = [];
+    const r = [];
     for (const u of s)
       if (a.isSuccess(u))
-        e.push(u.value);
+        r.push(u.value);
       else
         return u;
-    return a.success(e);
+    return a.success(r);
   },
   /**
    * Maps the error of a failed `Result` to a new error using the provided function.
@@ -757,7 +763,7 @@ const r = {
    * @returns A new `Result` with the mapped error if failed, otherwise the original success.
    * @public
    */
-  mapError: (s, e) => s.type === "Failure" ? a.failure(e(s.error)) : s,
+  mapError: (s, r) => s.type === "Failure" ? a.failure(r(s.error)) : s,
   /**
    * Maps the error of a failed `Result` to a new `Result` using the provided function.
    * This allows recovery from errors by returning a new successful result.
@@ -766,7 +772,7 @@ const r = {
    * @returns The result of the recovery function if failed, otherwise the original success.
    * @public
    */
-  flatMapError: (s, e) => s.type === "Failure" ? e(s.error) : s,
+  flatMapError: (s, r) => s.type === "Failure" ? r(s.error) : s,
   /**
    * Recovers from a failure by providing an alternative value.
    * @param r - The `Result` to recover from.
@@ -774,7 +780,7 @@ const r = {
    * @returns A successful `Result` with the alternative value if failed, otherwise the original success.
    * @public
    */
-  recover: (s, e) => s.type === "Failure" ? { type: "Success", value: e(s.error) } : s,
+  recover: (s, r) => s.type === "Failure" ? { type: "Success", value: r(s.error) } : s,
   /**
    * Applies a function wrapped in a `Result` to a value wrapped in a `Result`.
    * Useful for applying multiple arguments to a function in a safe way.
@@ -783,7 +789,7 @@ const r = {
    * @returns A new `Result` with the result of applying the function to the value.
    * @public
    */
-  ap: (s, e) => a.isSuccess(s) && a.isSuccess(e) ? a.success(s.value(e.value)) : a.isFailure(s) ? a.failure(s.error) : a.failure(e.error),
+  ap: (s, r) => a.isSuccess(s) && a.isSuccess(r) ? a.success(s.value(r.value)) : a.isFailure(s) ? a.failure(s.error) : a.failure(r.error),
   /**
    * Maps two `Result` values using a function.
    * @param r1 - The first `Result`.
@@ -792,7 +798,7 @@ const r = {
    * @returns A new `Result` with the result of applying the function to both values.
    * @public
    */
-  map2: (s, e, u) => a.isSuccess(s) && a.isSuccess(e) ? a.success(u(s.value, e.value)) : a.isFailure(s) ? a.failure(s.error) : a.failure(e.error),
+  map2: (s, r, u) => a.isSuccess(s) && a.isSuccess(r) ? a.success(u(s.value, r.value)) : a.isFailure(s) ? a.failure(s.error) : a.failure(r.error),
   /**
    * Maps three `Result` values using a function.
    * @param r1 - The first `Result`.
@@ -802,7 +808,7 @@ const r = {
    * @returns A new `Result` with the result of applying the function to all three values.
    * @public
    */
-  map3: (s, e, u, i) => a.isSuccess(s) && a.isSuccess(e) && a.isSuccess(u) ? a.success(i(s.value, e.value, u.value)) : a.isFailure(s) ? a.failure(s.error) : a.isFailure(e) ? a.failure(e.error) : a.failure(u.error),
+  map3: (s, r, u, l) => a.isSuccess(s) && a.isSuccess(r) && a.isSuccess(u) ? a.success(l(s.value, r.value, u.value)) : a.isFailure(s) ? a.failure(s.error) : a.isFailure(r) ? a.failure(r.error) : a.failure(u.error),
   /**
    * Converts a Promise to a Result.
    * @param p - The Promise to convert.
@@ -811,10 +817,10 @@ const r = {
    */
   ofPromise: async (s) => {
     try {
-      const e = await s;
-      return a.success(e);
-    } catch (e) {
-      return a.failure(e instanceof Error ? e : new Error(String(e)));
+      const r = await s;
+      return a.success(r);
+    } catch (r) {
+      return a.failure(r instanceof Error ? r : new Error(String(r)));
     }
   },
   /**
@@ -833,7 +839,7 @@ const r = {
    * @returns A Result containing the value if not null/undefined, otherwise a failure.
    * @public
    */
-  fromNullable: (s, e) => s == null ? a.failure(e) : a.success(s),
+  fromNullable: (s, r) => s == null ? a.failure(r) : a.success(s),
   /**
    * Converts a nullable value to a Result using a lazy error function.
    * @param value - The nullable value.
@@ -841,7 +847,7 @@ const r = {
    * @returns A Result containing the value if not null/undefined, otherwise a failure.
    * @public
    */
-  fromNullableLazy: (s, e) => s == null ? a.failure(e()) : a.success(s),
+  fromNullableLazy: (s, r) => s == null ? a.failure(r()) : a.success(s),
   /**
    * Wraps a function that may throw into a function that returns a Result.
    * @param f - The function that may throw.
@@ -851,15 +857,15 @@ const r = {
   tryCatch: (s) => {
     try {
       return a.success(s());
-    } catch (e) {
-      return a.failure(e instanceof Error ? e : new Error(String(e)));
+    } catch (r) {
+      return a.failure(r instanceof Error ? r : new Error(String(r)));
     }
   }
 };
-function d(s) {
+function v(s) {
   return `bc-label bc-label--${s}`;
 }
-const p = (...s) => n.span(o.class(d("emphasis")), ...s), y = (...s) => n.span(o.class(d("default")), ...s), f = (...s) => n.span(o.class(d("muted")), ...s), S = (...s) => n.span(o.class(d("danger")), ...s);
+const p = (...s) => n.span(o.class(v("emphasis")), ...s), y = (...s) => n.span(o.class(v("default")), ...s), f = (...s) => n.span(o.class(v("muted")), ...s), S = (...s) => n.span(o.class(v("danger")), ...s);
 function g(...s) {
   return n.div(o.class("bc-stack"), ...s);
 }
@@ -869,5 +875,5 @@ export {
   y as L,
   f as M,
   g as S,
-  c as i
+  i
 };