@oscarpalmer/atoms 0.205.0 → 0.206.0

package/dist/internal/array/insert.mjs

@@ -1,8 +1,9 @@
 import { chunk } from "./chunk.mjs";
+import { max, min } from "../math/aggregate.mjs";
 //#region src/internal/array/insert.ts
 function insertChunkedValues(type, array, items, start, deleteCount) {
 	const actualDeleteCount = deleteCount < 0 ? 0 : deleteCount;
-	const actualStart = Math.min(Math.max(0, start), array.length);
+	const actualStart = min([max([0, start]), array.length]);
 	const chunked = chunk(items);
 	const lastIndex = chunked.length - 1;
 	let index = chunked.length;

package/dist/internal/function/limit.mjs

@@ -1,3 +1,4 @@
+import { asyncAttempt } from "../result/attempt.mjs";
 import { getNumberOrDefault } from "../defaults.mjs";
 //#region src/internal/function/limit.ts
 const LIMITER_NAME_ASYNC = "asyncLimiter";
@@ -51,15 +52,14 @@ async function handleAsyncLimiter(state, item) {
 	if (state.interval === 0 || now - state.start >= state.interval - LIMITER_OFFSET) {
 		state.start = state.throttle ? now : void 0;
 		item.running = true;
-		try {
-			let result = state.callback(...item.parameters);
-			if (result instanceof Promise) result = await result;
-			item.resolve(result);
-		} catch (error) {
-			item.reject(error);
-		} finally {
-			item.running = false;
-		}
+		const result = await asyncAttempt(async () => {
+			let value = state.callback(...item.parameters);
+			if (value instanceof Promise) value = await value;
+			return value;
+		});
+		if (result.ok) item.resolve(result.value);
+		else item.reject(result.error);
+		item.running = false;
 	} else state.timer = startTimer(() => handleAsyncLimiter(state, item));
 }
 function handleLimiter(state) {

package/dist/internal/math/aggregate.d.mts

@@ -99,6 +99,47 @@ export declare function max<Item extends PlainObject>(items: Item[], key: keyof
  * @returns Maximum value, or `Number.NaN` if no maximum can be found
  */
 export declare function max(values: number[]): number;
+/**
+ * Get the minimum value from a list of items
+ *
+ * @param items List of items
+ * @param callback Callback to get an item's value
+ * @param first Return only the first item with the minimum value
+ * @returns First item with the minimum value, or `undefined` if no minimum can be found
+ */
+export declare function min<Item>(items: Item[], callback: (item: Item, index: number, array: Item[]) => number, first: true): Item | undefined;
+/**
+ * Get the minimum value from a list of items
+ *
+ * @param items List of items
+ * @param key Key to use for value
+ * @param first Return only the first item with the minimum value
+ * @returns First item with the minimum value, or `undefined` if no minimum can be found
+ */
+export declare function min<Item extends PlainObject>(items: Item[], key: keyof NumericalValues<Item>, first: true): Item | undefined;
+/**
+ * Get the minimum value from a list of items
+ *
+ * @param items List of items
+ * @param callback Callback to get an item's value
+ * @returns Items with the minimum value
+ */
+export declare function min<Item>(items: Item[], callback: (item: Item, index: number, array: Item[]) => number): Item[];
+/**
+ * Get the minimum value from a list of items
+ *
+ * @param items List of items
+ * @param key Key to use for value
+ * @returns Items with the minimum value
+ */
+export declare function min<Item extends PlainObject>(items: Item[], key: keyof NumericalValues<Item>): Item[];
+/**
+ * Get the minimum value from a list of numbers
+ *
+ * @param values List of numbers
+ * @returns Minimum value, or `Number.NaN` if no minimum can be found
+ */
+export declare function min(values: number[]): number;
 export declare const AGGREGATION_AVERAGE: AggregationType;
 export declare const AGGREGATION_MAX = "max";
 export declare const AGGREGATION_MIN = "min";

package/dist/internal/math/aggregate.mjs

@@ -59,6 +59,9 @@ function isMinValue(aggregation, value) {
 function max(array, key, first) {
 	return getAggregated("max", array, key, first);
 }
+function min(array, key, first) {
+	return getAggregated("min", array, key, first);
+}
 const AGGREGATION_AVERAGE = "average";
 const AGGREGATION_MAX = "max";
 const AGGREGATION_MIN = "min";
@@ -70,4 +73,4 @@ const aggregators = {
 	sum: calculateSum
 };
 //#endregion
-export { AGGREGATION_AVERAGE, AGGREGATION_MAX, AGGREGATION_MIN, AGGREGATION_SUM, aggregate, getAggregateCallback, getAggregated, max };
+export { AGGREGATION_AVERAGE, AGGREGATION_MAX, AGGREGATION_MIN, AGGREGATION_SUM, aggregate, getAggregateCallback, getAggregated, max, min };

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

@@ -1,4 +1,12 @@
 //#region src/internal/math/misc.d.ts
+/**
+ * Round a number down
+ *
+ * @param value Number to round down
+ * @param decimals Number of decimal places to round to _(defaults to `0`)_
+ * @returns Rounded number, or `Number.NaN` if the value if unable to be rounded
+ */
+export declare function floor(value: number, decimals?: number): number;
 /**
  * Round a number
  *

package/dist/internal/math/misc.mjs

@@ -1,5 +1,15 @@
 //#region src/internal/math/misc.ts
 /**
+* Round a number down
+*
+* @param value Number to round down
+* @param decimals Number of decimal places to round to _(defaults to `0`)_
+* @returns Rounded number, or `Number.NaN` if the value if unable to be rounded
+*/
+function floor(value, decimals) {
+	return roundNumber(Math.floor, value, decimals);
+}
+/**
 * Round a number
 *
 * @param value Number to round
@@ -16,4 +26,4 @@ function roundNumber(callback, value, decimals) {
 	return callback((value + Number.EPSILON) * mod) / mod;
 }
 //#endregion
-export { round, roundNumber };
+export { floor, round, roundNumber };

package/dist/internal/random.mjs

@@ -1,4 +1,5 @@
 import { isNumber } from "./is.mjs";
+import { floor } from "./math/misc.mjs";
 //#region src/internal/random.ts
 function getRandomFloatingNumberValue(inclusive, minimum, maximum) {
 	let maxFloat = isNumber(maximum) && maximum <= Number.MAX_SAFE_INTEGER ? maximum : Number.MAX_SAFE_INTEGER;
@@ -25,7 +26,7 @@ function getRandomFloatingNumber(minimum, maximum) {
 * @returns Random integer
 */
 function getRandomInteger(minimum, maximum) {
-	return Math.floor(getRandomFloatingNumberValue(true, minimum, maximum));
+	return floor(getRandomFloatingNumberValue(true, minimum, maximum));
 }
 //#endregion
 export { getRandomFloatingNumber, getRandomInteger };

package/dist/internal/result/attempt.d.mts

@@ -0,0 +1,59 @@
+import { ExtendedResult, Result } from "./models.mjs";
+//#region src/internal/result/attempt.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
+ */
+export 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
+ */
+export 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
+ */
+export 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
+ */
+export declare function asyncAttempt<Value>(callback: () => Promise<Value>): Promise<Result<Awaited<Value>>>;
+/**
+ * Executes a callback, catching any errors, and returns a result
+ *
+ * @param callback Callback to execute
+ * @param error Error value
+ * @returns Callback result
+ */
+export declare function attempt<Value, E>(callback: () => Value, error: E): ExtendedResult<Value, E>;
+/**
+ * Executes a callback, catching any errors, and returns a result
+ *
+ * @param callback Callback to execute
+ * @returns Callback result
+ */
+export declare function attempt<Value>(callback: () => Value): Result<Value, Error>;
+export declare namespace attempt {
+  export var async: typeof asyncAttempt;
+}
+//#endregion

package/dist/internal/result/attempt.mjs

@@ -0,0 +1,24 @@
+import { getError, ok } from "./misc.mjs";
+//#region src/internal/result/attempt.ts
+async function asyncAttempt(value, err) {
+	try {
+		let result;
+		if (typeof value === "function") result = value();
+		else result = value;
+		if (result instanceof Promise) result = await result;
+		return ok(result);
+	} catch (thrown) {
+		return getError(err ?? thrown, err == null ? void 0 : thrown);
+	}
+}
+function attempt(callback, err) {
+	try {
+		const value = callback();
+		return ok(value);
+	} catch (thrown) {
+		return getError(err ?? thrown, err == null ? void 0 : thrown);
+	}
+}
+attempt.async = asyncAttempt;
+//#endregion
+export { asyncAttempt, attempt };

package/dist/internal/string/misc.mjs

@@ -1,3 +1,6 @@
+import { unwrap } from "../result/misc.mjs";
+import "../../result/misc.mjs";
+import { attempt } from "../result/attempt.mjs";
 //#region src/internal/string/misc.ts
 /**
 * Get the string value from any value
@@ -57,11 +60,7 @@ function join(array, delimiter) {
 	return values.join(typeof delimiter === "string" ? delimiter : "");
 }
 function tryCallback(value, callback) {
-	try {
-		return callback(value);
-	} catch {
-		return value;
-	}
+	return unwrap(attempt(() => callback(value)), value);
 }
 function tryDecode(value) {
 	return tryCallback(value, decodeURIComponent);

package/dist/internal/value/equal.mjs

@@ -1,4 +1,5 @@
 import { isNonPlainObject, isPlainObject, isPrimitive, isTypedArray } from "../is.mjs";
+import { round } from "../math/misc.mjs";
 import { createCompareHandler } from "./handlers.mjs";
 //#region src/internal/value/equal.ts
 function Equalizer(options) {
@@ -60,7 +61,7 @@ function equalArray(first, second, options) {
 	if (length !== second.length) return false;
 	let offset = 0;
 	if (length >= EQUAL_ARRAY_THRESHOLD) {
-		offset = Math.round(length / EQUAL_ARRAY_PEEK_PERCENTAGE);
+		offset = round(length / EQUAL_ARRAY_PEEK_PERCENTAGE);
 		offset = offset > EQUAL_ARRAY_THRESHOLD ? EQUAL_ARRAY_THRESHOLD : offset;
 		for (let index = 0; index < offset; index += 1) if (!(equalValue(first[index], second[index], options) && equalValue(first[length - index - 1], second[length - index - 1], options))) return false;
 	}

package/dist/internal/value/misc.mjs

@@ -1,5 +1,5 @@
-import { ignoreKey } from "../string/misc.mjs";
 import { error, ok } from "../result/misc.mjs";
+import { ignoreKey } from "../string/misc.mjs";
 //#region src/internal/value/misc.ts
 function findKey(needle, haystack) {
 	const keys = Object.keys(haystack);

package/dist/math.d.mts

@@ -1,6 +1,6 @@
 import { NumericalValues, PlainObject } from "./models.mjs";
-import { max } from "./internal/math/aggregate.mjs";
-import { round } from "./internal/math/misc.mjs";
+import { max, min } from "./internal/math/aggregate.mjs";
+import { floor, round } from "./internal/math/misc.mjs";
 //#region src/math.d.ts
 /**
  * Get the average value from a list of items
@@ -58,14 +58,6 @@ export declare function count<Item extends PlainObject, ItemKey extends keyof It
  * @returns Number of items, or `Number.NaN` if no count can be calculated
  */
 export declare function count(values: unknown[]): number;
-/**
- * Round a number down
- *
- * @param value Number to round down
- * @param decimals Number of decimal places to round to _(defaults to `0`)_
- * @returns Rounded number, or `Number.NaN` if the value if unable to be rounded
- */
-export declare function floor(value: number, decimals?: number): number;
 /**
  * Get the median value from a list of items
  *
@@ -89,47 +81,6 @@ export declare function median<Item extends PlainObject>(array: Item[], key: key
  * @returns Median value, or `Number.NaN` if no median can be calculated
  */
 export declare function median(array: number[]): number;
-/**
- * Get the minimum value from a list of items
- *
- * @param items List of items
- * @param callback Callback to get an item's value
- * @param first Return only the first item with the minimum value
- * @returns First item with the minimum value, or `undefined` if no minimum can be found
- */
-export declare function min<Item>(items: Item[], callback: (item: Item, index: number, array: Item[]) => number, first: true): Item | undefined;
-/**
- * Get the minimum value from a list of items
- *
- * @param items List of items
- * @param key Key to use for value
- * @param first Return only the first item with the minimum value
- * @returns First item with the minimum value, or `undefined` if no minimum can be found
- */
-export declare function min<Item extends PlainObject>(items: Item[], key: keyof NumericalValues<Item>, first: true): Item | undefined;
-/**
- * Get the minimum value from a list of items
- *
- * @param items List of items
- * @param callback Callback to get an item's value
- * @returns Items with the minimum value
- */
-export declare function min<Item>(items: Item[], callback: (item: Item, index: number, array: Item[]) => number): Item[];
-/**
- * Get the minimum value from a list of items
- *
- * @param items List of items
- * @param key Key to use for value
- * @returns Items with the minimum value
- */
-export declare function min<Item extends PlainObject>(items: Item[], key: keyof NumericalValues<Item>): Item[];
-/**
- * Get the minimum value from a list of numbers
- *
- * @param values List of numbers
- * @returns Minimum value, or `Number.NaN` if no minimum can be found
- */
-export declare function min(values: number[]): number;
 /**
  * Get the sum of a list of items
  *
@@ -154,4 +105,4 @@ export declare function sum<Item extends PlainObject>(items: Item[], key: keyof
  */
 export declare function sum(values: number[]): number;
 //#endregion
-export { max, round };
+export { floor, max, min, round };

package/dist/math.mjs

@@ -1,6 +1,6 @@
 import { isNumber } from "./internal/is.mjs";
-import { AGGREGATION_AVERAGE, aggregate, getAggregateCallback, getAggregated, max } from "./internal/math/aggregate.mjs";
-import { round, roundNumber } from "./internal/math/misc.mjs";
+import { floor, round, roundNumber } from "./internal/math/misc.mjs";
+import { AGGREGATION_AVERAGE, aggregate, getAggregateCallback, getAggregated, max, min } from "./internal/math/aggregate.mjs";
 //#region src/math.ts
 function average(array, key) {
 	const aggregated = aggregate(AGGREGATION_AVERAGE, array, key);
@@ -28,16 +28,6 @@ function count(array, key, value) {
 	}
 	return counted;
 }
-/**
-* Round a number down
-*
-* @param value Number to round down
-* @param decimals Number of decimal places to round to _(defaults to `0`)_
-* @returns Rounded number, or `Number.NaN` if the value if unable to be rounded
-*/
-function floor(value, decimals) {
-	return roundNumber(Math.floor, value, decimals);
-}
 function median(array, key) {
 	let length = Array.isArray(array) ? array.length : 0;
 	if (!Array.isArray(array) || length === 0) return NaN;
@@ -52,10 +42,7 @@ function median(array, key) {
 		const second = length / 2;
 		return (numbers[first] + numbers[second]) / 2;
 	}
-	return numbers[Math.floor(length / 2)];
-}
-function min(array, key, first) {
-	return getAggregated("min", array, key, first);
+	return numbers[floor(length / 2)];
 }
 function sum(array, key) {
 	return getAggregated("sum", array, key);

package/dist/promise/constants.d.mts

@@ -6,7 +6,6 @@ export declare const PROMISE_ABORT_OPTIONS: {
 };
 export declare const PROMISE_ERROR_NAME = "PromiseTimeoutError";
 export declare const PROMISE_MESSAGE_EXPECTATION_ATTEMPT = "Attempt expected a function or a promise";
-export declare const PROMISE_MESSAGE_EXPECTATION_ITEMS_EMPTY = "promises expected at least one promise-function or promise in the array or object";
 export declare const PROMISE_MESSAGE_EXPECTATION_ITEMS_TYPE = "promises expected an array or object holding promise-functions or promises";
 export declare const PROMISE_MESSAGE_EXPECTATION_RESULT = "toResult expected a Promise";
 export declare const PROMISE_MESSAGE_EXPECTATION_TIMED = "Timed function expected a Promise";

package/dist/promise/constants.mjs

@@ -3,7 +3,6 @@ const PROMISE_ABORT_EVENT = "abort";
 const PROMISE_ABORT_OPTIONS = { once: true };
 const PROMISE_ERROR_NAME = "PromiseTimeoutError";
 const PROMISE_MESSAGE_EXPECTATION_ATTEMPT = "Attempt expected a function or a promise";
-const PROMISE_MESSAGE_EXPECTATION_ITEMS_EMPTY = "promises expected at least one promise-function or promise in the array or object";
 const PROMISE_MESSAGE_EXPECTATION_ITEMS_TYPE = "promises expected an array or object holding promise-functions or promises";
 const PROMISE_MESSAGE_EXPECTATION_RESULT = "toResult expected a Promise";
 const PROMISE_MESSAGE_EXPECTATION_TIMED = "Timed function expected a Promise";
@@ -13,4 +12,4 @@ const PROMISE_STRATEGY_DEFAULT = "complete";
 const PROMISE_TYPE_FULFILLED = "fulfilled";
 const PROMISE_TYPE_REJECTED = "rejected";
 //#endregion
-export { PROMISE_ABORT_EVENT, PROMISE_ABORT_OPTIONS, PROMISE_ERROR_NAME, PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_MESSAGE_EXPECTATION_ITEMS_EMPTY, PROMISE_MESSAGE_EXPECTATION_ITEMS_TYPE, PROMISE_MESSAGE_EXPECTATION_RESULT, PROMISE_MESSAGE_EXPECTATION_TIMED, PROMISE_MESSAGE_TIMEOUT, PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED };
+export { PROMISE_ABORT_EVENT, PROMISE_ABORT_OPTIONS, PROMISE_ERROR_NAME, PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_MESSAGE_EXPECTATION_ITEMS_TYPE, PROMISE_MESSAGE_EXPECTATION_RESULT, PROMISE_MESSAGE_EXPECTATION_TIMED, PROMISE_MESSAGE_TIMEOUT, PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED };

package/dist/promise/helpers.mjs

@@ -1,6 +1,6 @@
 import { isPlainObject } from "../internal/is.mjs";
-import { getNumberOrDefault } from "../internal/defaults.mjs";
 import { error, ok } from "../internal/result/misc.mjs";
+import { getNumberOrDefault } from "../internal/defaults.mjs";
 import { PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED } from "./constants.mjs";
 //#region src/promise/helpers.ts
 function createPromiseOptions(input) {

package/dist/promise/index.mjs

@@ -1,6 +1,7 @@
 import { isArrayOrPlainObject } from "../internal/is.mjs";
 import { createAborter } from "../internal/aborter.mjs";
-import { PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_MESSAGE_EXPECTATION_ITEMS_EMPTY, PROMISE_MESSAGE_EXPECTATION_ITEMS_TYPE, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED } from "./constants.mjs";
+import { asyncAttempt } from "../internal/result/attempt.mjs";
+import { PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_MESSAGE_EXPECTATION_ITEMS_TYPE, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED } from "./constants.mjs";
 import { createPromiseOptions, createPromisesOptions, getResultsFromPromises } from "./helpers.mjs";
 import { handleResult, settlePromise } from "./misc.mjs";
 import { getTimedPromise } from "./timed.mjs";
@@ -14,13 +15,13 @@ async function attemptPromise(value, options) {
 		rejector(signal?.reason);
 	});
 	async function handler(resolve, reject) {
-		try {
+		const result = await asyncAttempt(async () => {
 			let result = isFunction ? value() : await value;
 			if (result instanceof Promise) result = await result;
-			settlePromise(resolve, result, aborter);
-		} catch (error) {
-			settlePromise(reject, error, aborter);
-		}
+			return result;
+		});
+		if (result.ok) settlePromise(resolve, result.value, aborter);
+		else settlePromise(reject, result.error, aborter);
 	}
 	let rejector;
 	const promise = new Promise((resolve, reject) => {
@@ -35,12 +36,11 @@ async function promises(items, options) {
 	if (!isArrayOrPlainObject(items)) return Promise.reject(PROMISE_MESSAGE_EXPECTATION_ITEMS_TYPE);
 	const isArray = Array.isArray(items);
 	const actual = (isArray ? items.map((item, index) => [index, item]) : Object.entries(items)).map(([key, value]) => [key, typeof value === "function" ? value() : value]).filter(([, value]) => value instanceof Promise);
-	const { length } = actual;
-	if (length === 0) return Promise.reject(PROMISE_MESSAGE_EXPECTATION_ITEMS_EMPTY);
-	const complete = strategy === PROMISE_STRATEGY_DEFAULT;
 	const aborter = createAborter(signal, () => {
 		handlers.reject(signal?.reason);
 	});
+	const complete = strategy === PROMISE_STRATEGY_DEFAULT;
+	const { length } = actual;
 	const data = {
 		last: length - 1,
 		result: isArray ? [] : {}

package/dist/promise/misc.mjs

@@ -1,8 +1,8 @@
 import { error, ok } from "../internal/result/misc.mjs";
+import { toPromise } from "../result/misc.mjs";
 import { PROMISE_MESSAGE_EXPECTATION_RESULT } from "./constants.mjs";
 import { CancelablePromise } from "./models.mjs";
 import { isFulfilled, isRejected } from "./helpers.mjs";
-import { toPromise } from "../result/misc.mjs";
 //#region src/promise/misc.ts
 /**
 * Create a cancelable _Promise_

package/dist/queue.mjs

@@ -1,4 +1,6 @@
 import { createAborter } from "./internal/aborter.mjs";
+import { min } from "./internal/math/aggregate.mjs";
+import { asyncAttempt } from "./internal/result/attempt.mjs";
 import { getBooleanOrDefault, getNumberOrDefault } from "./internal/defaults.mjs";
 //#region src/queue.ts
 const QUEUE_NAME_KEYED = "keyedQueue";
@@ -333,7 +335,7 @@ function resumeQueue() {
 		for (let index = 0; index < length; index += 1) handled[index]();
 	}
 	state.paused = false;
-	const length = Math.min(state.options.concurrency, state.items.length);
+	const length = min([state.options.concurrency, state.items.length]);
 	for (let index = 0; index < length; index += 1) run(state);
 }
 function resumeQueues(key) {
@@ -346,14 +348,17 @@ async function run(state) {
 	while (item != null) {
 		let error = false;
 		let result;
-		try {
-			if (!(item.aborter?.signal?.aborted ?? false)) {
+		const attempted = await asyncAttempt(async () => {
+			if (item != null && !(item.aborter?.signal?.aborted ?? false)) {
 				const parameters = item.key == null ? item.parameters : [item.key, ...item.parameters];
-				result = await state.callback(...parameters);
+				return await state.callback(...parameters);
 			}
-		} catch (thrown) {
+			throw new Error();
+		});
+		if (attempted.ok) result = attempted.value;
+		else {
 			error = true;
-			result = thrown;
+			result = attempted.error;
 		}
 		if (state.paused) {
 			const paused = item;

package/dist/result/index.d.mts

@@ -1,59 +1,2 @@
-import { ExtendedResult, Result } from "../internal/result/models.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
- */
-export 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
- */
-export 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
- */
-export 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
- */
-export declare function asyncAttempt<Value>(callback: () => Promise<Value>): Promise<Result<Awaited<Value>>>;
-/**
- * Executes a callback, catching any errors, and returns a result
- *
- * @param callback Callback to execute
- * @param error Error value
- * @returns Callback result
- */
-export declare function attempt<Value, E>(callback: () => Value, error: E): ExtendedResult<Value, E>;
-/**
- * Executes a callback, catching any errors, and returns a result
- *
- * @param callback Callback to execute
- * @returns Callback result
- */
-export declare function attempt<Value>(callback: () => Value): Result<Value, Error>;
-export declare namespace attempt {
-  export var async: typeof asyncAttempt;
-}
-//#endregion
+import { asyncAttempt, attempt } from "../internal/result/attempt.mjs";
+export { asyncAttempt, attempt };

package/dist/result/index.mjs

@@ -1,24 +1,2 @@
-import { getError, ok } from "../internal/result/misc.mjs";
-//#region src/result/index.ts
-async function asyncAttempt(value, err) {
-	try {
-		let result;
-		if (typeof value === "function") result = value();
-		else result = value;
-		if (result instanceof Promise) result = await result;
-		return ok(result);
-	} catch (thrown) {
-		return getError(err ?? thrown, err == null ? void 0 : thrown);
-	}
-}
-function attempt(callback, err) {
-	try {
-		const value = callback();
-		return ok(value);
-	} catch (thrown) {
-		return getError(err ?? thrown, err == null ? void 0 : thrown);
-	}
-}
-attempt.async = asyncAttempt;
-//#endregion
+import { asyncAttempt, attempt } from "../internal/result/attempt.mjs";
 export { asyncAttempt, attempt };

package/dist/result/work/flow.mjs

@@ -1,6 +1,7 @@
 import { isError, isOk } from "../../internal/result/misc.mjs";
+import { asyncAttempt, attempt } from "../../internal/result/attempt.mjs";
 import { asyncFlow, flow } from "../../internal/function/work.mjs";
-import { asyncAttempt, attempt } from "../index.mjs";
+import "../index.mjs";
 //#region src/result/work/flow.ts
 function attemptAsyncFlow(...fns) {
 	let Flow;

package/dist/result/work/pipe.mjs

@@ -1,6 +1,7 @@
 import { isError, isOk } from "../../internal/result/misc.mjs";
+import { asyncAttempt, attempt } from "../../internal/result/attempt.mjs";
 import { asyncPipe, pipe } from "../../internal/function/work.mjs";
-import { asyncAttempt, attempt } from "../index.mjs";
+import "../index.mjs";
 //#region src/result/work/pipe.ts
 async function attemptAsyncPipe(initial, first, ...seconds) {
 	return asyncAttempt(() => {