@tempots/std 0.11.0 → 0.13.0

package/object.js

@@ -1,30 +1,30 @@
 function s(e) {
   return Object.keys(e);
 }
-function i(e, t) {
-  const u = s(e), r = s(t);
-  if (u.length !== r.length) return !1;
-  for (const n of u)
+function u(e, t) {
+  const c = s(e), r = s(t);
+  if (c.length !== r.length) return !1;
+  for (const n of c)
     if (!(n in t)) return !1;
   return !0;
 }
-function c(e) {
+function o(e) {
   return e != null && Object.getPrototypeOf(e) === Object.prototype;
 }
-function f(e, ...t) {
+function i(e, ...t) {
   return s(e).reduce((r, n) => (t.includes(n) || (r[n] = e[n]), r), {});
 }
-function o(e, t) {
+function f(e, t) {
   return Object.assign({}, e, t);
 }
-function l(e) {
-  return e == null || c(e) && Object.keys(e).length === 0;
+function O(e) {
+  return Object.keys(e).length === 0;
 }
 export {
-  l as isEmpty,
-  c as isObject,
-  s as keys,
-  o as merge,
-  f as removeFields,
-  i as sameKeys
+  O as isEmptyObject,
+  o as isObject,
+  f as mergeObjects,
+  s as objectKeys,
+  i as removeObjectFields,
+  u as sameObjectKeys
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tempots/std",
-  "version": "0.11.0",
+  "version": "0.13.0",
   "priority": 8,
   "description": "Std library for TypeScript. Natural complement to the Tempo libraries.",
   "keywords": [
@@ -21,6 +21,10 @@
   },
   "type": "module",
   "exports": {
+    ".": {
+      "import": "./index.js",
+      "require": "./index.cjs"
+    },
     "./array": {
       "import": "./array.js",
       "require": "./array.cjs"
@@ -53,10 +57,6 @@
       "import": "./json.js",
       "require": "./json.cjs"
     },
-    "./maybe": {
-      "import": "./maybe.js",
-      "require": "./maybe.cjs"
-    },
     "./number": {
       "import": "./number.js",
       "require": "./number.cjs"
@@ -89,6 +89,9 @@
   },
   "typesVersions": {
     "*": {
+      ".": [
+        "./index.d.ts"
+      ],
       "array": [
         "./array.d.ts"
       ],
@@ -113,9 +116,6 @@
       "json": [
         "./json.d.ts"
       ],
-      "maybe": [
-        "./maybe.d.ts"
-      ],
       "number": [
         "./number.d.ts"
       ],

package/regexp.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function g(i,s,u){const n=[];let l=0,e;if(s.global)for(s.lastIndex=0;(e=s.exec(i))!==null;)n.push(i.substring(l,e.index)),n.push(u(...e)),l=e.index+e[0].length;else for(;(e=s.exec(i.substring(l)))!==null;)n.push(i.substring(l,l+e.index)),n.push(u(...e)),l+=e.index+e[0].length;return n.push(i.substring(l)),n.join("")}exports.map=g;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function g(i,s,u){const n=[];let l=0,e;if(s.global)for(s.lastIndex=0;(e=s.exec(i))!==null;)n.push(i.substring(l,e.index)),n.push(u(...e)),l=e.index+e[0].length;else for(;(e=s.exec(i.substring(l)))!==null;)n.push(i.substring(l,l+e.index)),n.push(u(...e)),l+=e.index+e[0].length;return n.push(i.substring(l)),n.join("")}exports.mapRegExp=g;

package/regexp.d.ts

@@ -3,8 +3,9 @@
  */
 /**
  * Map the function `f` on each occurance matched by the pattern.
- * @param f
- * @param pattern
- * @param subject
+ * @param f - The function to apply to each match.
+ * @param pattern - The pattern to match.
+ * @param subject - The string to search.
+ * @public
  */
-export declare function map(subject: string, pattern: RegExp, f: (...s: string[]) => string): string;
+export declare function mapRegExp(subject: string, pattern: RegExp, f: (...s: string[]) => string): string;

package/regexp.js

@@ -1,14 +1,14 @@
-function h(e, i, u) {
-  const s = [];
+function h(s, i, u) {
+  const e = [];
   let n = 0, l;
   if (i.global)
-    for (i.lastIndex = 0; (l = i.exec(e)) !== null; )
-      s.push(e.substring(n, l.index)), s.push(u(...l)), n = l.index + l[0].length;
+    for (i.lastIndex = 0; (l = i.exec(s)) !== null; )
+      e.push(s.substring(n, l.index)), e.push(u(...l)), n = l.index + l[0].length;
   else
-    for (; (l = i.exec(e.substring(n))) !== null; )
-      s.push(e.substring(n, n + l.index)), s.push(u(...l)), n += l.index + l[0].length;
-  return s.push(e.substring(n)), s.join("");
+    for (; (l = i.exec(s.substring(n))) !== null; )
+      e.push(s.substring(n, n + l.index)), e.push(u(...l)), n += l.index + l[0].length;
+  return e.push(s.substring(n)), e.join("");
 }
 export {
-  h as map
+  h as mapRegExp
 };

package/result-Czm7RKNP.js

@@ -0,0 +1,230 @@
+import { AsyncResult as l } from "./async-result.js";
+const t = {
+  /**
+   * Creates a valid `Validation`.
+   * @returns A `Validation` that is `Valid`.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  valid: { type: "valid" },
+  /**
+   * Creates an invalid `Validation`.
+   * @param error - The error associated with the invalid value.
+   * @returns A `Validation` that is `Invalid`.
+   */
+  invalid(e) {
+    return { type: "invalid", error: e };
+  },
+  /**
+   * Checks if a `Validation` is `Valid`.
+   * @param r - The `Validation` to check.
+   * @returns `true` if the `Validation` is `Valid`, otherwise `false`.
+   */
+  isValid(e) {
+    return e.type === "valid";
+  },
+  /**
+   * Checks if a `Validation` is `Invalid`.
+   * @param r - The `Validation` to check.
+   * @returns `true` if the `Validation` is `Invalid`, otherwise `false`.
+   */
+  isInvalid(e) {
+    return e.type === "invalid";
+  },
+  /**
+   * Maps the value of a `Validation` to a new value.
+   * @param r - The `Validation` to map.
+   * @param valid - The mapping function for a valid value.
+   * @param invalid - The mapping function for an invalid value.
+   * @returns The mapped value.
+   */
+  match: (e, s, r) => t.isValid(e) ? s() : r(e.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: (e, s) => t.match(
+    e,
+    () => u.success(s),
+    (r) => u.failure(r)
+  ),
+  /**
+   * Execute a function when the `Validation` is valid.
+   *
+   * @param r - The `Validation` to check.
+   * @param apply - The function to execute when the `Validation` is valid.
+   * @returns The `Validation` object.
+   */
+  whenValid: (e, s) => (t.isValid(e) && s(), e),
+  /**
+   * Execute a function when the `Validation` is invalid.
+   *
+   * @param r - The `Validation` to check.
+   * @param apply - The function to execute when the `Validation` is invalid.
+   * @returns The `Validation` object.
+   */
+  whenInvalid: (e, s) => (t.isInvalid(e) && s(e.error), e)
+}, u = {
+  /**
+   * Creates a successful `Result`.
+   * @param value - The value to wrap in a `Success` type.
+   * @returns A `Result` that is a `Success`.
+   * @public
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  success(e) {
+    return { type: "Success", value: e };
+  },
+  /**
+   * Creates a failure `Result`.
+   * @param error - The error to wrap in a `Failure` type.
+   * @returns A `Result` that is a `Failure`.
+   * @public
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  failure(e) {
+    return { type: "Failure", error: e };
+  },
+  /**
+   * Maps the value of a `Result` to a new value.
+   * @param r - The `Result` to map.
+   * @param f - The mapping function.
+   * @returns A new `Result` with the mapped value.
+   * @public
+   */
+  map: (e, s) => e.type === "Success" ? u.success(s(e.value)) : e,
+  /**
+   * Maps the value of a `Result` to a new `Result`.
+   * @param r - The `Result` to map.
+   * @param f - The mapping function.
+   * @returns A new `Result` with the mapped value.
+   * @public
+   */
+  flatMap: (e, s) => e.type === "Success" ? s(e.value) : e,
+  /**
+   * Converts a `Result` to an `AsyncResult`.
+   * @param r - The `Result` to convert.
+   * @returns An `AsyncResult` that is equivalent to the input `Result`.
+   * @public
+   */
+  toAsync(e) {
+    return u.match(
+      e,
+      (s) => l.success(s),
+      (s) => l.failure(s)
+    );
+  },
+  /**
+   * Converts a `Result` to a `Validation`.
+   * @param r - The `Result` to convert.
+   * @returns A `Validation` that is equivalent to the input `Result`.
+   * @public
+   */
+  toValidation(e) {
+    return u.match(
+      e,
+      () => t.valid,
+      (s) => t.invalid(s)
+    );
+  },
+  /**
+   * Checks if a `Result` is a success.
+   * @param r - The `Result` to check.
+   * @returns `true` if the `Result` is a `Success`, `false` otherwise.
+   * @public
+   */
+  isSuccess(e) {
+    return e.type === "Success";
+  },
+  /**
+   * Checks if a `Result` is a failure.
+   * @param r - The `Result` to check.
+   * @returns `true` if the `Result` is a `Failure`, `false` otherwise.
+   * @public
+   */
+  isFailure(e) {
+    return e.type === "Failure";
+  },
+  /**
+   * Gets the value of a `Result` if it is a `Success`, otherwise returns the provided default value.
+   * @param r - The `Result` to get the value from.
+   * @param alt - The default value to return if the `Result` is a `Failure`.
+   * @returns The value of the `Result` if it is a `Success`, otherwise the default value.
+   * @public
+   */
+  getOrElse(e, s) {
+    return u.isSuccess(e) ? e.value : s;
+  },
+  /**
+   * Gets the value of a `Result` if it is a `Success`, otherwise returns the result of the provided function.
+   * @param r - The `Result` to get the value from.
+   * @param altf - The function to call if the `Result` is a `Failure`.
+   * @returns The value of the `Result` if it is a `Success`, otherwise the result of the function.
+   * @public
+   */
+  getOrElseLazy(e, s) {
+    return u.isSuccess(e) ? e.value : s();
+  },
+  /**
+   * Gets the value of a `Result` if it is a `Success`, otherwise returns `null`.
+   * @param r - The `Result` to get the value from.
+   * @returns The value of the `Result` if it is a `Success`, otherwise `null`.
+   * @public
+   */
+  getOrNull(e) {
+    return u.isSuccess(e) ? e.value : null;
+  },
+  /**
+   * Gets the value of a `Result` if it is a `Success`, otherwise returns `undefined`.
+   * @param r - The `Result` to get the value from.
+   * @returns The value of the `Result` if it is a `Success`, otherwise `undefined`.
+   * @public
+   */
+  getOrUndefined(e) {
+    return u.isSuccess(e) ? e.value : void 0;
+  },
+  /**
+   * Based on the state of the result, it picks the appropriate function to call and returns the result.
+   * @param success - The function to call if the result is a success.
+   * @param failure - The function to call if the result is a failure.
+   * @returns The result of calling the appropriate function based on the state of the result.
+   * @public
+   */
+  match: (e, s, r) => u.isSuccess(e) ? s(e.value) : r(e.error),
+  /**
+   * 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: (e, s) => (u.isSuccess(e) && s(e.value), e),
+  whenFailure: (e, s) => (u.isFailure(e) && s(e.error), e),
+  /**
+   * Combines two results into a single result.
+   * @param r1 - The first result.
+   * @param r2 - The second result.
+   * @param combineV - The function to combine two values.
+   * @param combineE - The function to combine two errors.
+   * @returns The combined result.
+   * @public
+   */
+  combine: (e, s, r, c) => u.match(
+    e,
+    (a) => u.match(
+      s,
+      (i) => u.success(r(a, i)),
+      (i) => u.failure(i)
+    ),
+    (a) => u.match(
+      s,
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      (i) => u.failure(a),
+      (i) => u.failure(c(a, i))
+    )
+  )
+};
+export {
+  u as R,
+  t as V
+};

package/result-DzdZiQoR.cjs

@@ -0,0 +1 @@
+"use strict";const a=require("./async-result.cjs"),i={valid:{type:"valid"},invalid(e){return{type:"invalid",error:e}},isValid(e){return e.type==="valid"},isInvalid(e){return e.type==="invalid"},match:(e,s,t)=>i.isValid(e)?s():t(e.error),toResult:(e,s)=>i.match(e,()=>u.success(s),t=>u.failure(t)),whenValid:(e,s)=>(i.isValid(e)&&s(),e),whenInvalid:(e,s)=>(i.isInvalid(e)&&s(e.error),e)},u={success(e){return{type:"Success",value:e}},failure(e){return{type:"Failure",error:e}},map:(e,s)=>e.type==="Success"?u.success(s(e.value)):e,flatMap:(e,s)=>e.type==="Success"?s(e.value):e,toAsync(e){return u.match(e,s=>a.AsyncResult.success(s),s=>a.AsyncResult.failure(s))},toValidation(e){return u.match(e,()=>i.valid,s=>i.invalid(s))},isSuccess(e){return e.type==="Success"},isFailure(e){return e.type==="Failure"},getOrElse(e,s){return u.isSuccess(e)?e.value:s},getOrElseLazy(e,s){return u.isSuccess(e)?e.value:s()},getOrNull(e){return u.isSuccess(e)?e.value:null},getOrUndefined(e){return u.isSuccess(e)?e.value:void 0},match:(e,s,t)=>u.isSuccess(e)?s(e.value):t(e.error),whenSuccess:(e,s)=>(u.isSuccess(e)&&s(e.value),e),whenFailure:(e,s)=>(u.isFailure(e)&&s(e.error),e),combine:(e,s,t,c)=>u.match(e,l=>u.match(s,r=>u.success(t(l,r)),r=>u.failure(r)),l=>u.match(s,r=>u.failure(l),r=>u.failure(c(l,r))))};exports.Result=u;exports.Validation=i;

package/result.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const s={success(e){return{type:"Success",value:e}},failure(e){return{type:"Failure",error:e}},cmap:e=>u=>u.type==="Success"?s.success(e(u.value)):u,map:(e,u)=>e.type==="Success"?s.success(u(e.value)):e,cflatMap:e=>u=>u.type==="Success"?e(u.value):u,flatMap:(e,u)=>e.type==="Success"?u(e.value):e,toAsync(e){return e},isSuccess(e){return e.type==="Success"},isFailure(e){return e.type==="Failure"},getOrElse(e,u){return s.isSuccess(e)?e.value:u},getOrElseLazy(e,u){return s.isSuccess(e)?e.value:u()},getOrNull(e){return s.isSuccess(e)?e.value:null},getOrUndefined(e){return s.isSuccess(e)?e.value:void 0},cmatch:(e,u)=>t=>s.isSuccess(t)?e(t.value):u(t.error),match:(e,u,t)=>s.isSuccess(e)?u(e.value):t(e.error),whenSuccess:e=>u=>(s.isSuccess(u)&&e(u.value),u),whenFailure:e=>u=>(s.isFailure(u)&&e(u.error),u),combine:(e,u,t,l)=>s.match(e,r=>s.match(u,c=>s.success(t(r,c)),c=>s.failure(c)),r=>s.match(u,c=>s.failure(r),c=>s.failure(l(r,c))))};exports.Result=s;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});require("./async-result.cjs");const e=require("./result-DzdZiQoR.cjs");exports.Result=e.Result;

package/result.d.ts

@@ -1,32 +1,156 @@
 import { AsyncResult } from './async-result';
+import { Maybe } from './domain';
+import { Validation } from './validation';
 
+/**
+ * Represents a successful result.
+ * @typeParam V - The type of the value.
+ * @public
+ */
 export interface Success<V> {
     type: 'Success';
     value: V;
 }
+/**
+ * Represents a failure result.
+ * @typeParam E - The type of the error.
+ * @public
+ */
 export interface Failure<E> {
     type: 'Failure';
     error: E;
 }
+/**
+ * Represents a result that can either be a success or a failure.
+ * @typeParam V - The type of the value in case of success.
+ * @typeParam E - The type of the error in case of failure.
+ * @public
+ */
 export type Result<V, E> = Success<V> | Failure<E>;
+/**
+ * Represents a promise that resolves to a `Result` type.
+ * @typeParam V - The type of the value contained in the `Result`.
+ * @typeParam E - The type of the error contained in the `Result`.
+ * @public
+ */
 export type PromiseResult<V, E> = PromiseLike<Result<V, E>>;
+/**
+ * Utility functions for working with `Result` types.
+ * @public
+ */
 export declare const Result: {
+    /**
+     * Creates a successful `Result`.
+     * @param value - The value to wrap in a `Success` type.
+     * @returns A `Result` that is a `Success`.
+     * @public
+     */
     success<V>(value: V): Result<V, any>;
+    /**
+     * Creates a failure `Result`.
+     * @param error - The error to wrap in a `Failure` type.
+     * @returns A `Result` that is a `Failure`.
+     * @public
+     */
     failure<E>(error: E): Result<any, E>;
-    cmap: <V1, V2, E>(f: (value: V1) => V2) => (r: Result<V1, E>) => Result<V2, E>;
+    /**
+     * Maps the value of a `Result` to a new value.
+     * @param r - The `Result` to map.
+     * @param f - The mapping function.
+     * @returns A new `Result` with the mapped value.
+     * @public
+     */
     map: <V1, V2, E>(r: Result<V1, E>, f: (value: V1) => V2) => Result<V2, E>;
-    cflatMap: <V1, V2, E>(f: (value: V1) => Result<V2, E>) => (r: Result<V1, E>) => Result<V2, E>;
+    /**
+     * Maps the value of a `Result` to a new `Result`.
+     * @param r - The `Result` to map.
+     * @param f - The mapping function.
+     * @returns A new `Result` with the mapped value.
+     * @public
+     */
     flatMap: <V1, V2, E>(r: Result<V1, E>, f: (value: V1) => Result<V2, E>) => Result<V2, E>;
+    /**
+     * Converts a `Result` to an `AsyncResult`.
+     * @param r - The `Result` to convert.
+     * @returns An `AsyncResult` that is equivalent to the input `Result`.
+     * @public
+     */
     toAsync<V, E>(r: Result<V, E>): AsyncResult<V, E>;
+    /**
+     * Converts a `Result` to a `Validation`.
+     * @param r - The `Result` to convert.
+     * @returns A `Validation` that is equivalent to the input `Result`.
+     * @public
+     */
+    toValidation<V, E>(r: Result<V, E>): Validation<E>;
+    /**
+     * Checks if a `Result` is a success.
+     * @param r - The `Result` to check.
+     * @returns `true` if the `Result` is a `Success`, `false` otherwise.
+     * @public
+     */
     isSuccess<V, E>(r: Result<V, E>): r is Success<V>;
+    /**
+     * Checks if a `Result` is a failure.
+     * @param r - The `Result` to check.
+     * @returns `true` if the `Result` is a `Failure`, `false` otherwise.
+     * @public
+     */
     isFailure<V, E>(r: Result<V, E>): r is Failure<E>;
+    /**
+     * Gets the value of a `Result` if it is a `Success`, otherwise returns the provided default value.
+     * @param r - The `Result` to get the value from.
+     * @param alt - The default value to return if the `Result` is a `Failure`.
+     * @returns The value of the `Result` if it is a `Success`, otherwise the default value.
+     * @public
+     */
     getOrElse<V, E>(r: Result<V, E>, alt: V): V;
+    /**
+     * Gets the value of a `Result` if it is a `Success`, otherwise returns the result of the provided function.
+     * @param r - The `Result` to get the value from.
+     * @param altf - The function to call if the `Result` is a `Failure`.
+     * @returns The value of the `Result` if it is a `Success`, otherwise the result of the function.
+     * @public
+     */
     getOrElseLazy<V, E>(r: Result<V, E>, altf: () => V): V;
+    /**
+     * Gets the value of a `Result` if it is a `Success`, otherwise returns `null`.
+     * @param r - The `Result` to get the value from.
+     * @returns The value of the `Result` if it is a `Success`, otherwise `null`.
+     * @public
+     */
     getOrNull<V, E>(r: Result<V, E>): V | null;
-    getOrUndefined<V, E>(r: Result<V, E>): V | undefined;
-    cmatch: <V1, V2, E>(success: (value: V1) => V2, failure: (error: E) => V2) => (r: Result<V1, E>) => V2;
+    /**
+     * Gets the value of a `Result` if it is a `Success`, otherwise returns `undefined`.
+     * @param r - The `Result` to get the value from.
+     * @returns The value of the `Result` if it is a `Success`, otherwise `undefined`.
+     * @public
+     */
+    getOrUndefined<V, E>(r: Result<V, E>): Maybe<V>;
+    /**
+     * Based on the state of the result, it picks the appropriate function to call and returns the result.
+     * @param success - The function to call if the result is a success.
+     * @param failure - The function to call if the result is a failure.
+     * @returns The result of calling the appropriate function based on the state of the result.
+     * @public
+     */
     match: <V1, V2, E>(r: Result<V1, E>, success: (value: V1) => V2, failure: (error: E) => V2) => V2;
-    whenSuccess: <V, E>(apply: (v: V) => void) => (r: Result<V, E>) => Result<V, E>;
-    whenFailure: <V, E>(apply: (e: E) => void) => (r: Result<V, E>) => Result<V, E>;
+    /**
+     * 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: <V, E>(r: Result<V, E>, apply: (v: V) => void) => Result<V, E>;
+    whenFailure: <V, E>(r: Result<V, E>, apply: (e: E) => void) => Result<V, E>;
+    /**
+     * Combines two results into a single result.
+     * @param r1 - The first result.
+     * @param r2 - The second result.
+     * @param combineV - The function to combine two values.
+     * @param combineE - The function to combine two errors.
+     * @returns The combined result.
+     * @public
+     */
     combine: <V, E>(r1: Result<V, E>, r2: Result<V, E>, combineV: (v1: V, v2: V) => V, combineE: (e1: E, e2: E) => E) => Result<V, E>;
 };

package/result.js

@@ -1,56 +1,5 @@
-const s = {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  success(e) {
-    return { type: "Success", value: e };
-  },
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  failure(e) {
-    return { type: "Failure", error: e };
-  },
-  cmap: (e) => (u) => u.type === "Success" ? s.success(e(u.value)) : u,
-  map: (e, u) => e.type === "Success" ? s.success(u(e.value)) : e,
-  cflatMap: (e) => (u) => u.type === "Success" ? e(u.value) : u,
-  flatMap: (e, u) => e.type === "Success" ? u(e.value) : e,
-  toAsync(e) {
-    return e;
-  },
-  isSuccess(e) {
-    return e.type === "Success";
-  },
-  isFailure(e) {
-    return e.type === "Failure";
-  },
-  getOrElse(e, u) {
-    return s.isSuccess(e) ? e.value : u;
-  },
-  getOrElseLazy(e, u) {
-    return s.isSuccess(e) ? e.value : u();
-  },
-  getOrNull(e) {
-    return s.isSuccess(e) ? e.value : null;
-  },
-  getOrUndefined(e) {
-    return s.isSuccess(e) ? e.value : void 0;
-  },
-  cmatch: (e, u) => (c) => s.isSuccess(c) ? e(c.value) : u(c.error),
-  match: (e, u, c) => s.isSuccess(e) ? u(e.value) : c(e.error),
-  whenSuccess: (e) => (u) => (s.isSuccess(u) && e(u.value), u),
-  whenFailure: (e) => (u) => (s.isFailure(u) && e(u.error), u),
-  combine: (e, u, c, l) => s.match(
-    e,
-    (t) => s.match(
-      u,
-      (r) => s.success(c(t, r)),
-      (r) => s.failure(r)
-    ),
-    (t) => s.match(
-      u,
-      // eslint-disable-next-line @typescript-eslint/no-unused-vars
-      (r) => s.failure(t),
-      (r) => s.failure(l(t, r))
-    )
-  )
-};
+import "./async-result.js";
+import { R as e } from "./result-Czm7RKNP.js";
 export {
-  s as Result
+  e as Result
 };