@oscarpalmer/atoms 0.179.0 → 0.180.0

package/dist/internal/array/index-of.mjs

@@ -1,7 +1,7 @@
 import { FIND_VALUE_INDEX, findValue } from "./find.mjs";
 //#region src/internal/array/index-of.ts
 function indexOf(array, ...parameters) {
-	return findValue(FIND_VALUE_INDEX, array, parameters);
+	return findValue(FIND_VALUE_INDEX, array, parameters, false);
 }
 //#endregion
 export { indexOf };

package/dist/internal/function/timer.mjs

@@ -34,7 +34,9 @@ function getAsyncTimer(type, callback, time) {
 		});
 		last = next;
 		if (throttle) run(next);
-		else id = startTimer(() => run(next));
+		else id = startTimer(() => {
+			run(next);
+		});
 		return next.promise;
 	};
 	timer.cancel = () => {

package/dist/internal/value/compare.d.mts

@@ -10,23 +10,27 @@ import { Constructor, GenericCallback } from "../../models.mjs";
 declare function compare(first: unknown, second: unknown): number;
 declare namespace compare {
   var handlers: {
-    register: (constructor: Constructor, handler?: string | GenericCallback) => void;
-    unregister: (constructor: Constructor) => void;
+    deregister(constructor: Constructor): void;
     handle(first: unknown, second: unknown, ...parameters: unknown[]): number;
+    register(constructor: Constructor, handler?: string | GenericCallback): void;
   };
+  var deregister: typeof deregisterComparator;
   var register: typeof registerComparator;
-  var unregister: typeof unregisterComparator;
 }
 /**
- * Register a custom comparison handler for a class
+ * Deregister a custom comparison handler for a class
+ *
+ * Available as `deregisterComparator` and `compare.deregister`
  * @param constructor Class constructor
- * @param handler Method name or comparison function _(defaults to `compare`)_
  */
-declare function registerComparator<Instance>(constructor: Constructor<Instance>, handler?: string | ((first: Instance, second: Instance) => number)): void;
+declare function deregisterComparator<Instance>(constructor: Constructor<Instance>): void;
 /**
- * Unregister a custom comparison handler for a class
+ * Register a custom comparison handler for a class
+ *
+ * Available as `registerComparator` and `compare.register`
  * @param constructor Class constructor
+ * @param handler Method name or comparison function _(defaults to `compare`)_
  */
-declare function unregisterComparator<Instance>(constructor: Constructor<Instance>): void;
+declare function registerComparator<Instance>(constructor: Constructor<Instance>, handler?: string | ((first: Instance, second: Instance) => number)): void;
 //#endregion
-export { compare };
+export { compare, deregisterComparator, registerComparator };

package/dist/internal/value/compare.mjs

@@ -37,8 +37,8 @@ compare.handlers = getCompareHandlers(compare, {
 	},
 	method: COMPARE_NAME
 });
+compare.deregister = deregisterComparator;
 compare.register = registerComparator;
-compare.unregister = unregisterComparator;
 function compareNumbers(first, second) {
 	if (Object.is(first, second)) return 0;
 	if (Number.isNaN(first)) return -1;
@@ -54,25 +54,29 @@ function compareValue(first, second, compareStrings) {
 	if (first instanceof Date && second instanceof Date) return compareNumbers(first.getTime(), second.getTime());
 	return compare.handlers.handle(first, second, compareStrings);
 }
+/**
+* Deregister a custom comparison handler for a class
+*
+* Available as `deregisterComparator` and `compare.deregister`
+* @param constructor Class constructor
+*/
+function deregisterComparator(constructor) {
+	compare.handlers.deregister(constructor);
+}
 function getComparisonParts(value) {
 	if (Array.isArray(value)) return value;
 	return typeof value === "object" ? [value] : words(getString(value));
 }
 /**
 * Register a custom comparison handler for a class
+*
+* Available as `registerComparator` and `compare.register`
 * @param constructor Class constructor
 * @param handler Method name or comparison function _(defaults to `compare`)_
 */
 function registerComparator(constructor, handler) {
 	compare.handlers.register(constructor, handler);
 }
-/**
-* Unregister a custom comparison handler for a class
-* @param constructor Class constructor
-*/
-function unregisterComparator(constructor) {
-	compare.handlers.unregister(constructor);
-}
 const comparators = {
 	bigint: compareNumbers,
 	boolean: (first, second) => compareNumbers(first ? 1 : 0, second ? 1 : 0),
@@ -80,4 +84,4 @@ const comparators = {
 	symbol: compareSymbols
 };
 //#endregion
-export { compare };
+export { compare, deregisterComparator, registerComparator };

package/dist/internal/value/equal.d.mts

@@ -19,6 +19,14 @@ type EqualOptions = {
   relaxedNullish?: boolean;
 };
 type Equalizer = {
+  /**
+   * Are two strings equal?
+   * @param first First string
+   * @param second Second string
+   * @param ignoreCase If `true`, comparison will be case-insensitive
+   * @returns `true` if the strings are equal, otherwise `false`
+   */
+  (first: string, second: string, ignoreCase?: boolean): boolean;
   /**
    * Are two values equal?
    * @param first First value
@@ -27,17 +35,24 @@ type Equalizer = {
    */
   (first: unknown, second: unknown): boolean;
   /**
-   * Register a equality comparison function for a specific class
+   * Deregister a equality comparison handler for a specific class
    * @param constructor Class constructor
-   * @param fn Comparison function
    */
-  register: <Instance>(constructor: Constructor<Instance>, handler: (first: Instance, second: Instance) => boolean) => void;
+  deregister: <Instance>(constructor: Constructor<Instance>) => void;
   /**
-   * Unregister a equality comparison handler for a specific class
+   * Register a equality comparison function for a specific class
    * @param constructor Class constructor
+   * @param handler Comparison function
    */
-  unregister: <Instance>(constructor: Constructor<Instance>) => void;
+  register: <Instance>(constructor: Constructor<Instance>, handler: (first: Instance, second: Instance) => boolean) => void;
 };
+/**
+ * Deregister a equality comparison handler for a specific class
+ *
+ * Available as `deregisterEqualizer` and `equal.deregister`
+ * @param constructor Class constructor
+ */
+declare function deregisterEqualizer<Instance>(constructor: Constructor<Instance>): void;
 /**
  * Are two strings equal?
  * @param first First string
@@ -56,30 +71,29 @@ declare function equal(first: string, second: string, ignoreCase?: boolean): boo
 declare function equal(first: unknown, second: unknown, options?: EqualOptions): boolean;
 declare namespace equal {
   var handlers: {
-    register: (constructor: Constructor, handler?: string | GenericCallback) => void;
-    unregister: (constructor: Constructor) => void;
+    deregister(constructor: Constructor): void;
     handle(first: unknown, second: unknown, ...parameters: unknown[]): boolean;
+    register(constructor: Constructor, handler?: string | GenericCallback): void;
   };
+  var deregister: typeof deregisterEqualizer;
   var initialize: typeof initializeEqualizer;
   var register: typeof registerEqualizer;
-  var unregister: typeof unregisterEqualizer;
 }
 /**
  * Create an equalizer with predefined options
+ *
+ * Available as `initializeEqualizer` and `equal.initialize`
  * @param options Comparison options
  * @returns Equalizer function
  */
 declare function initializeEqualizer(options?: EqualOptions): Equalizer;
 /**
  * Register a equality comparison function for a specific class
+ *
+ * Available as `registerEqualizer` and `equal.register`
  * @param constructor Class constructor
- * @param fn Comparison function
+ * @param handler Comparison function
  */
 declare function registerEqualizer<Instance>(constructor: Constructor<Instance>, handler: (first: Instance, second: Instance) => boolean): void;
-/**
- * Unregister a equality comparison handler for a specific class
- * @param constructor Class constructor
- */
-declare function unregisterEqualizer<Instance>(constructor: Constructor<Instance>): void;
 //#endregion
-export { EqualOptions, equal };
+export { EqualOptions, deregisterEqualizer, equal, initializeEqualizer, registerEqualizer };

package/dist/internal/value/equal.mjs

@@ -1,13 +1,28 @@
 import { isPlainObject, isPrimitive, isTypedArray } from "../is.mjs";
 import { getCompareHandlers } from "./handlers.mjs";
 //#region src/internal/value/equal.ts
+/**
+* Deregister a equality comparison handler for a specific class
+*
+* Available as `deregisterEqualizer` and `equal.deregister`
+* @param constructor Class constructor
+*/
+function deregisterEqualizer(constructor) {
+	equal.handlers.deregister(constructor);
+}
+function filterKey(key, options) {
+	if (typeof key !== "string") return true;
+	if (options.ignoreExpressions.enabled && options.ignoreExpressions.values.some((expression) => expression.test(key))) return false;
+	if (options.ignoreKeys.enabled && options.ignoreKeys.values.has(key)) return false;
+	return true;
+}
 function equal(first, second, options) {
 	return equalValue(first, second, getEqualOptions(options));
 }
 equal.handlers = getCompareHandlers(equal, { callback: Object.is });
+equal.deregister = deregisterEqualizer;
 equal.initialize = initializeEqualizer;
 equal.register = registerEqualizer;
-equal.unregister = unregisterEqualizer;
 function equalArray(first, second, options) {
 	const { length } = first;
 	if (length !== second.length) return false;
@@ -99,39 +114,6 @@ function equalValue(first, second, options) {
 		default: return equal.handlers.handle(first, second, options);
 	}
 }
-/**
-* Create an equalizer with predefined options
-* @param options Comparison options
-* @returns Equalizer function
-*/
-function initializeEqualizer(options) {
-	const actual = getEqualOptions(options);
-	const equalizer = (first, second) => equalValue(first, second, actual);
-	equalizer.register = registerEqualizer;
-	equalizer.unregister = unregisterEqualizer;
-	return equalizer;
-}
-/**
-* Register a equality comparison function for a specific class
-* @param constructor Class constructor
-* @param fn Comparison function
-*/
-function registerEqualizer(constructor, handler) {
-	equal.handlers.register(constructor, handler);
-}
-/**
-* Unregister a equality comparison handler for a specific class
-* @param constructor Class constructor
-*/
-function unregisterEqualizer(constructor) {
-	equal.handlers.unregister(constructor);
-}
-function filterKey(key, options) {
-	if (typeof key !== "string") return true;
-	if (options.ignoreExpressions.enabled && options.ignoreExpressions.values.some((expression) => expression.test(key))) return false;
-	if (options.ignoreKeys.enabled && options.ignoreKeys.values.has(key)) return false;
-	return true;
-}
 function getEqualOptions(input) {
 	const options = {
 		ignoreCase: false,
@@ -158,10 +140,34 @@ function getEqualOptions(input) {
 	options.relaxedNullish = input.relaxedNullish === true;
 	return options;
 }
+/**
+* Create an equalizer with predefined options
+*
+* Available as `initializeEqualizer` and `equal.initialize`
+* @param options Comparison options
+* @returns Equalizer function
+*/
+function initializeEqualizer(options) {
+	const actual = getEqualOptions(options);
+	const equalizer = (first, second) => equalValue(first, second, actual);
+	equalizer.deregister = deregisterEqualizer;
+	equalizer.register = registerEqualizer;
+	return equalizer;
+}
+/**
+* Register a equality comparison function for a specific class
+*
+* Available as `registerEqualizer` and `equal.register`
+* @param constructor Class constructor
+* @param handler Comparison function
+*/
+function registerEqualizer(constructor, handler) {
+	equal.handlers.register(constructor, handler);
+}
 const ARRAY_PEEK_PERCENTAGE = 10;
 const ARRAY_THRESHOLD = 100;
 const ERROR_PROPERTIES = ["name", "message"];
 const EXPRESSION_PROPERTIES = ["source", "flags"];
 const MINIMUM_LENGTH_FOR_SET = 16;
 //#endregion
-export { equal };
+export { deregisterEqualizer, equal, initializeEqualizer, registerEqualizer };

package/dist/internal/value/handlers.d.mts

@@ -6,14 +6,14 @@ type Options = {
   method?: string;
 };
 declare function getCompareHandlers<Value>(owner: GenericCallback, options: Options): {
-  register: (constructor: Constructor, handler?: string | GenericCallback) => void;
-  unregister: (constructor: Constructor) => void;
+  deregister(constructor: Constructor): void;
   handle(first: unknown, second: unknown, ...parameters: unknown[]): Value;
+  register(constructor: Constructor, handler?: string | GenericCallback): void;
 };
 declare function getSelfHandlers(owner: GenericCallback, options: Options): {
-  register: (constructor: Constructor, handler?: string | GenericCallback) => void;
-  unregister: (constructor: Constructor) => void;
+  deregister(constructor: Constructor): void;
   handle(value: unknown, ...parameters: unknown[]): any;
+  register(constructor: Constructor, handler?: string | GenericCallback): void;
 };
 //#endregion
 export { getCompareHandlers, getSelfHandlers };

package/dist/internal/value/handlers.mjs

@@ -1,20 +1,27 @@
 import { isConstructor } from "../is.mjs";
 //#region src/internal/value/handlers.ts
 function getCompareHandlers(owner, options) {
-	const { get, register, unregister } = getHandlers(owner, options);
+	const handlers = getHandlers(owner, options);
 	return {
-		register,
-		unregister,
+		deregister(constructor) {
+			handlers.deregister(constructor);
+		},
 		handle(first, second, ...parameters) {
-			const handler = get(first, second);
+			const handler = handlers.get(first, second);
 			if (handler == null) return options.callback(first, second, ...parameters);
 			return typeof handler === "function" ? handler(first, second) : first[handler](second);
+		},
+		register(constructor, handler) {
+			handlers.register(constructor, handler);
 		}
 	};
 }
 function getHandlers(owner, options) {
 	const handlers = /* @__PURE__ */ new WeakMap();
 	return {
+		deregister(constructor) {
+			handlers.delete(constructor);
+		},
 		get(first, second) {
 			if (isConstructable(first) && isConstructable(second) && first.constructor === second.constructor) return handlers.get(first.constructor);
 		},
@@ -24,21 +31,22 @@ function getHandlers(owner, options) {
 			if (typeof actual !== "function" && typeof actual !== "string") return;
 			if (typeof actual === "string") actual = typeof constructor.prototype[actual] === "function" ? actual : void 0;
 			if (actual != null) handlers.set(constructor, actual);
-		},
-		unregister(constructor) {
-			handlers.delete(constructor);
 		}
 	};
 }
 function getSelfHandlers(owner, options) {
-	const { get, register, unregister } = getHandlers(owner, options);
+	const handlers = getHandlers(owner, options);
 	return {
-		register,
-		unregister,
+		deregister(constructor) {
+			handlers.deregister(constructor);
+		},
 		handle(value, ...parameters) {
-			const handler = get(value, value);
+			const handler = handlers.get(value, value);
 			if (handler == null) return options.callback(value, ...parameters);
 			return typeof handler === "function" ? handler(value) : value[handler]();
+		},
+		register(constructor, handler) {
+			handlers.register(constructor, handler);
 		}
 	};
 }

package/dist/internal/value/has.d.mts

@@ -1,10 +1,7 @@
 import { NestedKeys, NestedValue, PlainObject, ToString } from "../../models.mjs";
+import { Result } from "../../result/models.mjs";
 
 //#region src/internal/value/has.d.ts
-type HasValue<Value> = {
-  exists: boolean;
-  value: Value;
-};
 /**
  * Check if a nested property is defined in an object
  * @param data Object to check in
@@ -21,23 +18,27 @@ declare function hasValue<Data extends PlainObject, Path extends NestedKeys<Data
  */
 declare function hasValue<Data extends PlainObject>(data: Data, path: string, ignoreCase?: boolean): boolean;
 declare namespace hasValue {
-  var get: typeof getWithHasValue;
+  var get: typeof hasValueResult;
 }
 /**
  * Check if a nested property is defined in an object, and get its value if it is
+ *
+ * Available as `hasValueResult` and `hasValue.get`
  * @param data Object to check in
  * @param path Path for property
  * @param ignoreCase If `true`, the path matching is case-insensitive
  * @return Result object
  */
-declare function getWithHasValue<Data extends PlainObject, Path extends NestedKeys<Data>>(data: Data, path: Path, ignoreCase?: boolean): HasValue<NestedValue<Data, ToString<Path>>>;
+declare function hasValueResult<Data extends PlainObject, Path extends NestedKeys<Data>>(data: Data, path: Path, ignoreCase?: boolean): Result<NestedValue<Data, ToString<Path>>, undefined>;
 /**
  * Check if a nested property is defined in an object, and get its value if it is
+ *
+ * Available as `hasValueResult` and `hasValue.get`
  * @param data Object to check in
  * @param path Path for property
  * @param ignoreCase If `true`, the path matching is case-insensitive
  * @return Result object
  */
-declare function getWithHasValue<Data extends PlainObject>(data: Data, path: string, ignoreCase?: boolean): HasValue<unknown>;
+declare function hasValueResult<Data extends PlainObject>(data: Data, path: string, ignoreCase?: boolean): Result<unknown, undefined>;
 //#endregion
-export { HasValue, hasValue };
+export { hasValue };

package/dist/internal/value/has.mjs

@@ -1,10 +1,10 @@
 import { getNestedValue } from "./misc.mjs";
 //#region src/internal/value/has.ts
 function hasValue(data, path, ignoreCase) {
-	return getNestedValue(data, path, ignoreCase === true).exists;
+	return getNestedValue(data, path, ignoreCase === true).ok;
 }
-hasValue.get = getWithHasValue;
-function getWithHasValue(data, path, ignoreCase) {
+hasValue.get = hasValueResult;
+function hasValueResult(data, path, ignoreCase) {
 	return getNestedValue(data, path, ignoreCase === true);
 }
 //#endregion

package/dist/internal/value/misc.d.mts

@@ -1,14 +1,10 @@
+import { Result } from "../../result/models.mjs";
+
 //#region src/internal/value/misc.d.ts
 declare function findKey(needle: string, haystack: object): string;
-declare function getNestedValue(data: object, path: string, ignoreCase: boolean): {
-  exists: boolean;
-  value: unknown;
-};
+declare function getNestedValue(data: object, path: string, ignoreCase: boolean): Result<unknown, undefined>;
 declare function getPaths(path: string, lowercase: boolean): string | string[];
-declare function handleValue(data: object, path: string, value: unknown, get: true, ignoreCase: boolean): {
-  exists: boolean;
-  value: unknown;
-};
+declare function handleValue(data: object, path: string, value: unknown, get: true, ignoreCase: boolean): Result<unknown, undefined>;
 declare function handleValue(data: object, path: string, value: unknown, get: false, ignoreCase: boolean): void;
 //#endregion
 export { findKey, getNestedValue, getPaths, handleValue };

package/dist/internal/value/misc.mjs

@@ -1,4 +1,5 @@
 import { ignoreKey } from "../string.mjs";
+import { error, ok } from "../../result/misc.mjs";
 //#region src/internal/value/misc.ts
 function findKey(needle, haystack) {
 	const keys = Object.keys(haystack);
@@ -6,10 +7,7 @@ function findKey(needle, haystack) {
 	return index > -1 ? keys[index] : needle;
 }
 function getNestedValue(data, path, ignoreCase) {
-	if (typeof data !== "object" || data === null || typeof path !== "string" || path.trim().length === 0) return {
-		exists: false,
-		value: void 0
-	};
+	if (typeof data !== "object" || data === null || typeof path !== "string" || path.trim().length === 0) return error(void 0);
 	const shouldIgnoreCase = ignoreCase === true;
 	const paths = getPaths(path, shouldIgnoreCase);
 	if (typeof paths === "string") return handleValue(data, paths, null, true, shouldIgnoreCase);
@@ -18,13 +16,10 @@ function getNestedValue(data, path, ignoreCase) {
 	for (let index = 0; index < length; index += 1) {
 		const part = paths[index];
 		const handled = handleValue(current, part, null, true, shouldIgnoreCase);
-		if (!handled.exists) return handled;
+		if (!handled.ok) return handled;
 		current = handled.value;
 	}
-	return {
-		exists: true,
-		value: current
-	};
+	return ok(current);
 }
 function getPaths(path, lowercase) {
 	const normalized = lowercase ? path.toLowerCase() : path;
@@ -34,16 +29,10 @@ function getPaths(path, lowercase) {
 function handleValue(data, path, value, get, ignoreCase) {
 	if (typeof data === "object" && data !== null && !ignoreKey(path)) {
 		const key = ignoreCase ? findKey(path, data) : path;
-		if (get) return {
-			exists: key in data,
-			value: data[key]
-		};
+		if (get) return key in data ? ok(data[key]) : error(void 0);
 		data[key] = typeof value === "function" ? value(data[key]) : value;
 	}
-	if (get) return {
-		exists: false,
-		value: void 0
-	};
+	if (get) return error(void 0);
 }
 const EXPRESSION_BRACKET = /\[(\w+)\]/g;
 const EXPRESSION_DOTS = /^\.|\.$/g;

package/dist/promise/index.d.mts

@@ -4,6 +4,8 @@ import { PromiseOptions, PromisesItems, PromisesOptions, PromisesResult, Promise
 //#region src/promise/index.d.ts
 /**
  * Wrap a promise with safety handlers, with optional abort capabilities and timeout
+ *
+ * Available as `attemptPromise` and `attempt.promise`
  * @param promise Promise to wrap
  * @param options Options for the promise
  * @returns Wrapped promise
@@ -11,6 +13,8 @@ import { PromiseOptions, PromisesItems, PromisesOptions, PromisesResult, Promise
 declare function attemptPromise<Value>(promise: Promise<Value>, options?: PromiseOptions | AbortSignal | number): Promise<Value>;
 /**
  * Wrap a promise-returning callback with safety handlers, with optional abort capabilities and timeout
+ *
+ * Available as `attemptPromise` and `attempt.promise`
  * @param callback Callback to wrap
  * @param options Options for the promise
  * @returns Promise-wrapped callback
@@ -18,6 +22,8 @@ declare function attemptPromise<Value>(promise: Promise<Value>, options?: Promis
 declare function attemptPromise<Value>(callback: () => Promise<Value>, options?: PromiseOptions | AbortSignal | number): Promise<Value>;
 /**
  * Wrap a callback with a promise and safety handlers, with optional abort capabilities and timeout
+ *
+ * Available as `attemptPromise` and `attempt.promise`
  * @param callback Callback to wrap
  * @param options Options for the promise
  * @returns Promise-wrapped callback
@@ -80,6 +86,8 @@ declare namespace promises {
  * Handle a list of promises, returning their results in an ordered array of results _({@link Result})_.
  *
  * Depending on the strategy, the function will either reject on the first error encountered or return an array of rejected and resolved results
+ *
+ * Available as `resultPromises` and `promises.result`
  * @param items List of promises
  * @param signal AbortSignal for aborting the operation _(when aborted, the promise will reject with the reason of the signal)_
  * @returns List of results
@@ -89,10 +97,12 @@ declare function resultPromises<Items extends unknown[]>(items: [...Items], sign
  * Handle a list of promises, returning their results in an ordered array of results _({@link Result})_.
  *
  * Depending on the strategy, the function will either reject on the first error encountered or return an array of rejected and resolved results
+ *
+ * Available as `resultPromises` and `promises.result`
  * @param items List of promises
  * @param signal AbortSignal for aborting the operation _(when aborted, the promise will reject with the reason of the signal)_
  * @returns List of results
  */
 declare function resultPromises<Value>(items: Promise<Value>[], signal?: AbortSignal): Promise<Result<Awaited<Value>>[]>;
 //#endregion
-export { attemptPromise, promises };
+export { attemptPromise, promises, resultPromises };

package/dist/promise/index.mjs

@@ -74,4 +74,4 @@ async function resultPromises(items, signal) {
 	return promises(items, signal).then(getResultsFromPromises);
 }
 //#endregion
-export { attemptPromise, promises };
+export { attemptPromise, promises, resultPromises };

package/dist/result/index.d.mts

@@ -7,6 +7,8 @@ import { attemptPipe } from "./work/pipe.mjs";
 //#region src/result/index.d.ts
 /**
  * Executes a promise, catching any errors, and returns a result
+ *
+ * Available as `asyncAttempt` and `attempt.async`
  * @param promise Promise to execute
  * @param error Error value
  * @returns Callback result
@@ -14,6 +16,8 @@ import { attemptPipe } from "./work/pipe.mjs";
 declare function asyncAttempt<Value, E>(promise: Promise<Value>, error: E): Promise<ExtendedResult<Awaited<Value>, E>>;
 /**
  * Executes a callback asynchronously, catching any errors, and returns a result
+ *
+ * Available as `asyncAttempt` and `attempt.async`
  * @param callback Callback to execute
  * @param error Error value
  * @returns Callback result
@@ -21,12 +25,16 @@ declare function asyncAttempt<Value, E>(promise: Promise<Value>, error: E): Prom
 declare function asyncAttempt<Value, E>(callback: () => Promise<Value>, error: E): Promise<ExtendedResult<Awaited<Value>, E>>;
 /**
  * Executes a promise, catching any errors, and returns a result
+ *
+ * Available as `asyncAttempt` and `attempt.async`
  * @param promise Promise to execute
  * @returns Callback result
  */
 declare function asyncAttempt<Value>(promise: Promise<Value>): Promise<Result<Awaited<Value>>>;
 /**
  * Executes a callback asynchronously, catching any errors, and returns a result
+ *
+ * Available as `asyncAttempt` and `attempt.async`
  * @param callback Callback to execute
  * @returns Callback result
  */
@@ -52,4 +60,4 @@ declare namespace attempt {
   var promise: typeof attemptPromise;
 }
 //#endregion
-export { attempt };
+export { asyncAttempt, attempt };

package/dist/result/index.mjs

@@ -26,4 +26,4 @@ attempt.match = matchResult;
 attempt.pipe = attemptPipe;
 attempt.promise = attemptPromise;
 //#endregion
-export { attempt };
+export { asyncAttempt, attempt };

package/dist/result/match.d.mts

@@ -16,12 +16,16 @@ declare function asyncMatchResult<Value, Returned, E = Error>(result: AnyResult<
 declare function asyncMatchResult<Value, Returned, E = Error>(result: AnyResult<Value, E> | Promise<AnyResult<Value, E>> | (() => Promise<AnyResult<Value, E>>), ok: ResultMatch<Value, Returned, E>['ok'], error: ResultMatch<Value, Returned, E>['error']): Promise<Returned>;
 /**
  * Handles a result with match callbacks
+ *
+ * Available as `matchResult` and `attempt.match`
  * @param result Result to handle
  * @param handler Match callbacks
  */
 declare function matchResult<Value, Returned, E = Error>(result: AnyResult<Value, E> | (() => AnyResult<Value, E>), handler: ResultMatch<Value, Returned, E>): Returned;
 /**
  * Handles a result with match callbacks
+ *
+ * Available as `matchResult` and `attempt.match`
  * @param result Result to handle
  * @param ok Ok callback
  * @param error Error callback
@@ -31,4 +35,4 @@ declare namespace matchResult {
   var async: typeof asyncMatchResult;
 }
 //#endregion
-export { matchResult };
+export { asyncMatchResult, matchResult };

package/dist/result/match.mjs

@@ -24,4 +24,4 @@ function matchResult(result, first, error) {
 matchResult.async = asyncMatchResult;
 const MESSAGE_RESULT = "`result.match` expected a Result or a function that returns a Result";
 //#endregion
-export { matchResult };
+export { asyncMatchResult, matchResult };