@oscarpalmer/atoms 0.216.0 → 0.218.0

package/dist/plan/misc.d.mts

@@ -1,17 +1,65 @@
-import { PlanFailure, PlanSuccess } from "../models/plan.model.mjs";
+import { AsyncFailure, AsyncSuccess, Failure, Success } from "../models/plan.model.mjs";
 //#region src/plan/misc.d.ts
+/**
+ * Create an immediately failing plan
+ *
+ * @param callback Failure callback
+ * @returns Plan failure
+ */
+export declare function asyncFail<Value>(callback: () => Value): AsyncFailure<Awaited<Value>>;
+/**
+ * Create an immediately failing plan
+ *
+ * @param value Failure value
+ * @returns Plan failure
+ */
+export declare function asyncFail<Value>(value: Value): AsyncFailure<Awaited<Value>>;
+/**
+ * Create an immediately succeeding plan
+ *
+ * @param callback Success callback
+ * @returns Plan success
+ */
+export declare function asyncSucceed<Value>(callback: () => Value): AsyncSuccess<Awaited<Value>>;
+/**
+ * Create an immediately succeeding plan
+ *
+ * @param value Success value
+ * @returns Plan success
+ */
+export declare function asyncSucceed<Value>(value: Value): AsyncSuccess<Awaited<Value>>;
+/**
+ * Create an immediately failing plan
+ *
+ * @param callback Failure callback
+ * @returns Plan failure
+ */
+export declare function fail<Value>(callback: () => Value): Failure<Value>;
 /**
  * Create an immediately failing plan
  *
  * @param value Failure value
  * @returns Plan failure
  */
-export declare function fail<Value>(value: Value): PlanFailure<Value>;
+export declare function fail<Value>(value: Value): Failure<Value>;
+/**
+ * Create an immediately succeeding plan
+ *
+ * @param callback Success callback
+ * @returns Plan success
+ */
+export declare function succeed<Value>(callback: () => Value): Success<Value>;
 /**
  * Create an immediately succeeding plan
  *
  * @param value Success value
  * @returns Plan success
  */
-export declare function succeed<Value>(value: Value): PlanSuccess<Value>;
+export declare function succeed<Value>(value: Value): Success<Value>;
+export declare namespace fail {
+  export var async: typeof asyncFail;
+}
+export declare namespace succeed {
+  export var async: typeof asyncSucceed;
+}
 //#endregion

package/dist/plan/misc.mjs

@@ -1,39 +1,56 @@
 import { error } from "../internal/result/misc.mjs";
-import { PLAN_SYMBOL } from "../models/plan.model.mjs";
+import { PLAN_FAILURE_ASYNC, PLAN_FAILURE_SYNC, PLAN_SUCCESS_ASYNC, PLAN_SUCCESS_SYNC, PLAN_SYMBOL } from "../models/plan.model.mjs";
+import { getGenerator } from "../internal/plan/index.mjs";
 //#region src/plan/misc.ts
-function PlanFailure(generator) {
-	this[PLAN_SYMBOL] = { generator };
-}
-PlanFailure.prototype[Symbol.iterator] = function() {
-	return this[PLAN_SYMBOL].generator();
-};
-function PlanSuccess(generator) {
-	this[PLAN_SYMBOL] = { generator };
-}
-PlanSuccess.prototype[Symbol.iterator] = function() {
-	return this[PLAN_SYMBOL].generator();
-};
-/**
-* Create an immediately failing plan
-*
-* @param value Failure value
-* @returns Plan failure
-*/
+function AsyncFailure(generator) {
+	this[PLAN_SYMBOL] = {
+		generator,
+		type: PLAN_FAILURE_ASYNC
+	};
+}
+AsyncFailure.prototype[Symbol.asyncIterator] = getGenerator;
+function AsyncSuccess(generator) {
+	this[PLAN_SYMBOL] = {
+		generator,
+		type: PLAN_SUCCESS_ASYNC
+	};
+}
+AsyncSuccess.prototype[Symbol.asyncIterator] = getGenerator;
+function Failure(generator) {
+	this[PLAN_SYMBOL] = {
+		generator,
+		type: PLAN_FAILURE_SYNC
+	};
+}
+Failure.prototype[Symbol.iterator] = getGenerator;
+function Success(generator) {
+	this[PLAN_SYMBOL] = {
+		generator,
+		type: PLAN_SUCCESS_SYNC
+	};
+}
+Success.prototype[Symbol.iterator] = getGenerator;
+function asyncFail(value) {
+	return new AsyncFailure(async function* () {
+		yield error(await (typeof value === "function" ? value() : value));
+	});
+}
+function asyncSucceed(value) {
+	return new AsyncSuccess(async function* () {
+		return typeof value === "function" ? value() : value;
+	});
+}
 function fail(value) {
-	return new PlanFailure(function* () {
-		yield error(value);
+	return new Failure(function* () {
+		yield error(typeof value === "function" ? value() : value);
 	});
 }
-/**
-* Create an immediately succeeding plan
-*
-* @param value Success value
-* @returns Plan success
-*/
 function succeed(value) {
-	return new PlanSuccess(function* () {
-		return value;
+	return new Success(function* () {
+		return typeof value === "function" ? value() : value;
 	});
 }
+fail.async = asyncFail;
+succeed.async = asyncSucceed;
 //#endregion
-export { fail, succeed };
+export { asyncFail, asyncSucceed, fail, succeed };

package/dist/plan/models.d.mts

@@ -1,2 +1,2 @@
-import { AsyncPlan, Plan, PlanFailure, PlanResult, PlanSuccess } from "../models/plan.model.mjs";
-export type { AsyncPlan, Plan, PlanFailure, PlanResult, PlanSuccess };
+import { AsyncFailure, AsyncPlan, AsyncPlanned, AsyncStep, AsyncSuccess, Failure, Plan, PlanError, PlanOk, PlanReturned, Planned, Step, Success } from "../models/plan.model.mjs";
+export type { AsyncFailure, AsyncPlan, AsyncPlanned, AsyncStep, AsyncSuccess, Failure, Plan, PlanError, PlanOk, PlanReturned, Planned, Step, Success };

package/dist/plan/result.d.mts

@@ -1,11 +1,14 @@
 import { Result } from "../models/result.model.mjs";
-import { AsyncPlan, InternalPlan, Plan, PlanError, PlanOk } from "../models/plan.model.mjs";
+import { AsyncPlan, Plan, PlanError, PlanOk } from "../models/plan.model.mjs";
 //#region src/plan/result.d.ts
 /**
  * Attempt to run the generator to completion
  *
  * _Returns a promised {@link Result} instead of a raw value or throwing an error_
  *
+ * @param generator Generator to run
+ * @param parameters Parameters for starting the run
+ * @param signal Optional abort signal
  * @returns Promised result
  */
 export declare function asyncAttemptRun<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => AsyncGenerator<Yielded, Returned>, parameters: Parameters, signal?: AbortSignal): Promise<Result<PlanOk<Returned>, PlanError<Yielded, Returned>>>;
@@ -14,6 +17,8 @@ export declare function asyncAttemptRun<Yielded, Returned, Parameters extends un
  *
  * _Returns a promised {@link Result} instead of a raw value or throwing an error_
  *
+ * @param generator Generator to run
+ * @param signal Optional abort signal
  * @returns Promised result
  */
 export declare function asyncAttemptRun<Yielded, Returned>(generator: () => AsyncGenerator<Yielded, Returned>, signal?: AbortSignal): Promise<Result<PlanOk<Returned>, PlanError<Yielded, Returned>>>;
@@ -22,6 +27,9 @@ export declare function asyncAttemptRun<Yielded, Returned>(generator: () => Asyn
  *
  * _Returns a promised {@link Result} instead of a raw value or throwing an error_
  *
+ * @param plan Plan to run
+ * @param parameters Parameters for starting the run
+ * @param signal Optional abort signal
  * @returns Promised result
  */
 export declare function asyncAttemptRun<Yielded, Returned, Parameters extends unknown[]>(plan: AsyncPlan<Yielded, Returned, Parameters>, parameters: Parameters, signal?: AbortSignal): Promise<Result<PlanOk<Returned>, PlanError<Yielded, Returned>>>;
@@ -30,6 +38,8 @@ export declare function asyncAttemptRun<Yielded, Returned, Parameters extends un
  *
  * _Returns a promised {@link Result} instead of a raw value or throwing an error_
  *
+ * @param plan Plan to run
+ * @param signal Optional abort signal
  * @returns Promised result
  */
 export declare function asyncAttemptRun<Yielded, Returned>(plan: AsyncPlan<Yielded, Returned, []>, signal?: AbortSignal): Promise<Result<PlanOk<Returned>, PlanError<Yielded, Returned>>>;
@@ -38,6 +48,8 @@ export declare function asyncAttemptRun<Yielded, Returned>(plan: AsyncPlan<Yield
  *
  * _Returns a {@link Result} instead of a raw value or throwing an error_
  *
+ * @param generator Generator to run
+ * @param parameters Parameters for starting the run
  * @returns Result
  */
 export declare function attemptRun<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => Generator<Yielded, Returned>, ...parameters: Parameters): Result<PlanOk<Returned>, PlanError<Yielded, Returned>>;
@@ -46,11 +58,11 @@ export declare function attemptRun<Yielded, Returned, Parameters extends unknown
  *
  * _Returns a {@link Result} instead of a raw value or throwing an error_
  *
+ * @param plan Plan to run
+ * @param parameters Parameters for starting the run
  * @returns Result
  */
 export declare function attemptRun<Yielded, Returned, Parameters extends unknown[]>(plan: Plan<Yielded, Returned, Parameters>, ...parameters: Parameters): Result<PlanOk<Returned>, PlanError<Yielded, Returned>>;
-export declare function attemptRunAsyncPlan(this: never, first: never, second: never): Promise<unknown>;
-export declare function attemptRunPlan(this: InternalPlan, ...parameters: unknown[]): unknown;
 export declare namespace attemptRun {
   export var async: typeof asyncAttemptRun;
 }

package/dist/plan/result.mjs

@@ -1,28 +1,22 @@
 import { asyncAttempt, attempt } from "../internal/result/attempt.mjs";
 import { PLAN_MESSAGE_RUN_INPUT, PLAN_SYMBOL } from "../models/plan.model.mjs";
-import { isAsyncGenerator, isAsyncPlan, isGenerator, isPlan } from "./is.mjs";
-import { asyncGenerate, generate } from "./generate.mjs";
+import { asyncGenerate, generate } from "../internal/plan/plan.generate.mjs";
+import { isAsyncGeneratorFunction, isAsyncPlan, isGeneratorFunction, isPlan } from "./is.mjs";
 //#region src/plan/result.ts
 function asyncAttemptRun(input, first, second) {
 	let generator;
 	if (isAsyncPlan(input)) generator = input[PLAN_SYMBOL];
-	else if (isAsyncGenerator(input)) generator = input;
+	else if (isAsyncGeneratorFunction(input)) generator = input;
 	if (generator == null) throw new Error(PLAN_MESSAGE_RUN_INPUT);
 	return asyncAttempt(() => asyncGenerate(generator, true, first, second));
 }
 function attemptRun(input, ...parameters) {
 	let generator;
 	if (isPlan(input)) generator = input[PLAN_SYMBOL];
-	else if (isGenerator(input)) generator = input;
+	else if (isGeneratorFunction(input)) generator = input;
 	if (generator == null) throw new Error(PLAN_MESSAGE_RUN_INPUT);
 	return attempt(() => generate(generator, parameters, true));
 }
-function attemptRunAsyncPlan(first, second) {
-	return asyncAttemptRun(this, first, second);
-}
-function attemptRunPlan(...parameters) {
-	return attempt(() => generate(this[PLAN_SYMBOL], parameters, true));
-}
 attemptRun.async = asyncAttemptRun;
 //#endregion
-export { asyncAttemptRun, attemptRun, attemptRunAsyncPlan, attemptRunPlan };
+export { asyncAttemptRun, attemptRun };

package/dist/plan/run.d.mts

@@ -1,4 +1,4 @@
-import { AsyncPlan, InternalAsyncPlan, InternalPlan, Plan, PlanReturned } from "../models/plan.model.mjs";
+import { AsyncPlan, Plan, PlanReturned } from "../models/plan.model.mjs";
 import { asyncAttemptRun, attemptRun } from "./result.mjs";
 //#region src/plan/run.d.ts
 /**
@@ -51,8 +51,6 @@ export declare function run<Yielded, Returned, Parameters extends unknown[]>(gen
  * @returns Result
  */
 export declare function run<Yielded, Returned, Parameters extends unknown[]>(plan: Plan<Yielded, Returned, Parameters>, ...parameters: Parameters): PlanReturned<Returned>;
-export declare function runAsyncPlan(this: InternalAsyncPlan, first: never, second: never): Promise<unknown>;
-export declare function runPlan(this: InternalPlan, ...parameters: unknown[]): unknown;
 export declare namespace asyncRun {
   export var attempt: typeof asyncAttemptRun;
 }

package/dist/plan/run.mjs

@@ -1,26 +1,20 @@
 import { PLAN_MESSAGE_RUN_INPUT, PLAN_SYMBOL } from "../models/plan.model.mjs";
-import { isAsyncGenerator, isAsyncPlan, isGenerator, isPlan } from "./is.mjs";
-import { asyncGenerate, generate } from "./generate.mjs";
+import { asyncGenerate, generate } from "../internal/plan/plan.generate.mjs";
+import { isAsyncGeneratorFunction, isAsyncPlan, isGeneratorFunction, isPlan } from "./is.mjs";
 import { asyncAttemptRun, attemptRun } from "./result.mjs";
 //#region src/plan/run.ts
 function asyncRun(input, first, second) {
 	if (isAsyncPlan(input)) return asyncGenerate(input[PLAN_SYMBOL], false, first, second);
-	if (isAsyncGenerator(input)) return asyncGenerate(input, false, first, second);
+	if (isAsyncGeneratorFunction(input)) return asyncGenerate(input, false, first, second);
 	throw new Error(PLAN_MESSAGE_RUN_INPUT);
 }
 function run(input, ...parameters) {
 	if (isPlan(input)) return input.run(...parameters);
-	if (isGenerator(input)) return generate(input, parameters, false);
+	if (isGeneratorFunction(input)) return generate(input, parameters, false);
 	throw new Error(PLAN_MESSAGE_RUN_INPUT);
 }
-function runAsyncPlan(first, second) {
-	return asyncGenerate(this[PLAN_SYMBOL], false, first, second);
-}
-function runPlan(...parameters) {
-	return generate(this[PLAN_SYMBOL], parameters, false);
-}
 asyncRun.attempt = asyncAttemptRun;
 run.async = asyncRun;
 run.attempt = attemptRun;
 //#endregion
-export { asyncRun, run, runAsyncPlan, runPlan };
+export { asyncRun, run };

package/dist/plan/use.d.mts

@@ -0,0 +1,36 @@
+import { AsyncStep, AsyncStepValue, Step, StepValue } from "../models/plan.model.mjs";
+//#region src/plan/use.d.ts
+/**
+ * Create an asynchronous step from a callback
+ *
+ * @param callback Callback
+ * @returns An asynchronous step
+ */
+export declare function asyncUse<Value>(callback: () => Value & AsyncStepValue<Value>): AsyncStep<Value>;
+/**
+ * Create an asynchronous step from a value
+ *
+ * @param value Value
+ * @returns An asynchronous step
+ */
+export declare function asyncUse<Value>(value: Value & AsyncStepValue<Value>): AsyncStep<Value>;
+/**
+ * Create a step from a callback
+ *
+ * @param callback Callback
+ * @returns A step
+ * @throws Error If the input is invalid
+ */
+export declare function use<Value>(callback: () => Value & StepValue<Value>): Step<Value>;
+/**
+ * Create a step from a value
+ *
+ * @param value Value
+ * @returns A step
+ * @throws Error If the input is invalid
+ */
+export declare function use<Value>(value: Value & StepValue<Value>): Step<Value>;
+export declare namespace use {
+  export var async: typeof asyncUse;
+}
+//#endregion

package/dist/plan/use.mjs

@@ -0,0 +1,69 @@
+import { isError, isOk } from "../internal/result/misc.mjs";
+import { PLAN_MESSAGE_USE_NESTED_FN, PLAN_MESSAGE_USE_SYNC_ASYNC, PLAN_STEP_ASYNC, PLAN_STEP_SYNC, PLAN_SYMBOL } from "../models/plan.model.mjs";
+import { getGenerator } from "../internal/plan/index.mjs";
+import { isAsyncFailure, isAsyncGenerator, isAsyncGeneratorFunction, isAsyncPlan, isAsyncStep, isAsyncSuccess, isGenerator } from "./is.mjs";
+import { fail } from "./misc.mjs";
+//#region src/plan/use.ts
+function AsyncStep(generator) {
+	this[PLAN_SYMBOL] = {
+		generator,
+		type: PLAN_STEP_ASYNC
+	};
+}
+AsyncStep.prototype[Symbol.asyncIterator] = getGenerator;
+function Step(generator) {
+	this[PLAN_SYMBOL] = {
+		generator,
+		type: PLAN_STEP_SYNC
+	};
+}
+Step.prototype[Symbol.iterator] = getGenerator;
+function asyncUse(value) {
+	return new AsyncStep(async function* () {
+		let actual = value;
+		if (typeof actual === "function") actual = actual();
+		actual = await actual;
+		if (typeof actual === "function") throw new TypeError(PLAN_MESSAGE_USE_NESTED_FN);
+		if (typeof actual === "object" && actual !== null && PLAN_SYMBOL in actual) return yield* actual;
+		if (isAsyncGenerator(actual) || isGenerator(actual)) return yield* actual;
+		if (isError(actual)) {
+			yield* fail(actual.error);
+			return;
+		}
+		if (isOk(actual)) return actual.value;
+		if (actual instanceof Error) {
+			yield* fail(actual);
+			return;
+		}
+		return actual;
+	});
+}
+function use(value) {
+	validateUseInput(value, false);
+	return new Step(function* () {
+		let actual = value;
+		if (typeof actual === "function") {
+			actual = actual();
+			validateUseInput(actual, true);
+		}
+		if (typeof actual === "object" && actual !== null && PLAN_SYMBOL in actual) return yield* actual;
+		if (isGenerator(actual)) return yield* actual;
+		if (isError(actual)) {
+			yield* fail(actual.error);
+			return;
+		}
+		if (isOk(actual)) return actual.value;
+		if (actual instanceof Error) {
+			yield* fail(actual);
+			return;
+		}
+		return actual;
+	});
+}
+function validateUseInput(value, resolved) {
+	if (value instanceof Promise || isAsyncFailure(value) || isAsyncGenerator(value) || isAsyncGeneratorFunction(value) || isAsyncPlan(value) || isAsyncStep(value) || isAsyncSuccess(value)) throw new Error(PLAN_MESSAGE_USE_SYNC_ASYNC);
+	if (resolved && typeof value === "function") throw new Error(PLAN_MESSAGE_USE_NESTED_FN);
+}
+use.async = asyncUse;
+//#endregion
+export { asyncUse, use };

package/dist/promise/index.d.mts

@@ -1,6 +1,7 @@
 import { PlainObject } from "../models/index.mjs";
 import { PromiseOptions, PromiseStrategy, PromisesItems, PromisesOptions, PromisesResult, PromisesUnwrapped, PromisesValues } from "../models/promise.model.mjs";
 //#region src/promise/index.d.ts
+type AttemptPromiseOptions = PromiseOptions | AbortSignal | number;
 /**
  * Wrap a _Promise_ with safety handlers
  *
@@ -8,7 +9,7 @@ import { PromiseOptions, PromiseStrategy, PromisesItems, PromisesOptions, Promis
  * @param options Options for the _Promise_
  * @returns Wrapped _Promise_
  */
-export declare function attemptPromise<Value>(promise: Promise<Value>, options?: PromiseOptions | AbortSignal | number): Promise<Value>;
+export declare function attemptPromise<Value>(promise: Promise<Value>, options?: AttemptPromiseOptions): Promise<Value>;
 /**
  * Wrap a _Promise_-returning callback with safety handlers
  *
@@ -16,7 +17,7 @@ export declare function attemptPromise<Value>(promise: Promise<Value>, options?:
  * @param options Options for the _Promise_
  * @returns _Promise_-wrapped callback
  */
-export declare function attemptPromise<Value>(callback: () => Promise<Value>, options?: PromiseOptions | AbortSignal | number): Promise<Value>;
+export declare function attemptPromise<Value>(callback: () => Promise<Value>, options?: AttemptPromiseOptions): Promise<Value>;
 /**
  * Wrap a callback with a _Promise_ and safety handlers
  *
@@ -24,7 +25,7 @@ export declare function attemptPromise<Value>(callback: () => Promise<Value>, op
  * @param options Options for the _Promise_
  * @returns _Promise_-wrapped callback
  */
-export declare function attemptPromise<Value>(callback: () => Value, options?: PromiseOptions | AbortSignal | number): Promise<Value>;
+export declare function attemptPromise<Value>(callback: () => Value, options?: AttemptPromiseOptions): Promise<Value>;
 /**
  * Handle a list of _Promises_, returning their results in an ordered array
  *
@@ -106,4 +107,5 @@ export declare function resultPromises<Items extends PlainObject>(items: Items,
 export declare namespace promises {
   export var result: typeof resultPromises;
 }
-//#endregion
+//#endregion
+export {};

package/dist/promise/index.mjs

@@ -8,9 +8,9 @@ import { getTimedPromise } from "./timed.mjs";
 //#region src/promise/index.ts
 async function attemptPromise(value, options) {
 	const isFunction = typeof value === "function";
-	if (!isFunction && !(value instanceof Promise)) return Promise.reject(new TypeError(PROMISE_MESSAGE_EXPECTATION_ATTEMPT));
+	if (!isFunction && !(value instanceof Promise)) throw new TypeError(PROMISE_MESSAGE_EXPECTATION_ATTEMPT);
 	const { signal, time } = createPromiseOptions(options);
-	if (signal?.aborted ?? false) return Promise.reject(signal?.reason);
+	if (signal?.aborted ?? false) throw signal?.reason;
 	const aborter = createAborter(signal, () => {
 		rejector(signal?.reason);
 	});
@@ -32,8 +32,8 @@ async function attemptPromise(value, options) {
 }
 async function promises(items, options) {
 	const { signal, strategy } = createPromisesOptions(options);
-	if (signal?.aborted ?? false) return Promise.reject(signal?.reason);
-	if (!isArrayOrPlainObject(items)) return Promise.reject(PROMISE_MESSAGE_EXPECTATION_ITEMS_TYPE);
+	if (signal?.aborted ?? false) throw signal?.reason;
+	if (!isArrayOrPlainObject(items)) throw new TypeError(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 aborter = createAborter(signal, () => {

package/dist/promise/misc.mjs

@@ -20,13 +20,16 @@ function handleResult(status, parameters) {
 		handlers.reject(value);
 		return;
 	}
-	data.result[key] = !complete ? value : status === "fulfilled" ? {
+	let resultValue;
+	if (complete) resultValue = status === "fulfilled" ? {
 		status,
 		value
 	} : {
 		status,
 		reason: value
 	};
+	else resultValue = value;
+	data.result[key] = resultValue;
 	if (index === data.last) {
 		aborter?.cancel();
 		handlers.resolve(data.result);
@@ -38,7 +41,7 @@ function settlePromise(settler, value, aborter) {
 }
 async function toResult(value) {
 	const actual = typeof value === "function" ? value() : value;
-	if (!(actual instanceof Promise)) return Promise.reject(new TypeError(PROMISE_MESSAGE_EXPECTATION_RESULT));
+	if (!(actual instanceof Promise)) throw new TypeError(PROMISE_MESSAGE_EXPECTATION_RESULT);
 	return actual.then((result) => ok(result)).catch((reason) => error(reason));
 }
 //#endregion

package/dist/promise/models.mjs

@@ -1,2 +1 @@
-import { CancelablePromise, PromiseTimeoutError } from "../models/promise.model.mjs";
-export { CancelablePromise, PromiseTimeoutError };
+export { CancelablePromise, PromiseTimeoutError } from "../models/promise.model.mjs";

package/dist/promise/timed.mjs

@@ -23,9 +23,9 @@ async function getTimedPromise(promise, time, signal) {
 	});
 }
 async function timed(promise, options) {
-	if (!(promise instanceof Promise)) return Promise.reject(new TypeError(PROMISE_MESSAGE_EXPECTATION_TIMED));
+	if (!(promise instanceof Promise)) throw new TypeError(PROMISE_MESSAGE_EXPECTATION_TIMED);
 	const { signal, time } = createPromiseOptions(options);
-	if (signal?.aborted ?? false) return Promise.reject(signal?.reason);
+	if (signal?.aborted ?? false) throw signal?.reason;
 	return time > 0 ? getTimedPromise(promise, time, signal) : promise;
 }
 //#endregion

package/dist/queue.mjs

@@ -335,14 +335,13 @@ async function run(state) {
 	state.runners += 1;
 	let item = state.items.shift();
 	while (item != null) {
+		const next = item;
 		let error = false;
 		let result;
 		const attempted = await asyncAttempt(async () => {
-			if (item != null && !(item.aborter?.signal?.aborted ?? false)) {
-				const parameters = item.key == null ? item.parameters : [item.key, ...item.parameters];
-				return await state.callback(...parameters);
-			}
-			throw new Error();
+			if (next.aborter?.signal?.aborted) throw next.aborter.signal.reason;
+			const parameters = next.key == null ? next.parameters : [next.key, ...next.parameters];
+			return await state.callback(...parameters);
 		});
 		if (attempted.ok) result = attempted.value;
 		else {

package/dist/random.d.mts

@@ -1,4 +1,4 @@
-import { getRandomFloatingNumber, getRandomInteger } from "./internal/random.mjs";
+import { getRandom, getRandomFloatingNumber, getRandomInteger } from "./internal/random.mjs";
 //#region src/random.d.ts
 /**
  * Get a random boolean
@@ -50,4 +50,4 @@ export declare function getRandomItems<Value>(array: Value[], amount: number): V
  */
 export declare function getRandomItems<Value>(array: Value[]): Value[];
 //#endregion
-export { getRandomFloatingNumber as getRandomFloat, getRandomInteger };
+export { getRandom, getRandomFloatingNumber as getRandomFloat, getRandomInteger };

package/dist/random.mjs

@@ -1,4 +1,4 @@
-import { getRandomFloatingNumber, getRandomInteger } from "./internal/random.mjs";
+import { getRandom, getRandomFloatingNumber, getRandomInteger } from "./internal/random.mjs";
 import { shuffle } from "./internal/array/shuffle.mjs";
 import { join } from "./internal/string/misc.mjs";
 import { RANDOM_ALPHABET, RANDOM_BOOLEAN_MODIFIER, RANDOM_HEX_CHARACTERS } from "./models/random.model.mjs";
@@ -9,7 +9,7 @@ import { RANDOM_ALPHABET, RANDOM_BOOLEAN_MODIFIER, RANDOM_HEX_CHARACTERS } from
 * @returns Random boolean
 */
 function getRandomBoolean() {
-	return Math.random() > RANDOM_BOOLEAN_MODIFIER;
+	return getRandom() > RANDOM_BOOLEAN_MODIFIER;
 }
 /**
 * Get a random string of characters with a specified length
@@ -59,4 +59,4 @@ function getRandomItems(array, amount) {
 	return typeof amount !== "number" || amount <= 0 || amount >= array.length ? shuffle(array) : shuffle(array).slice(0, amount);
 }
 //#endregion
-export { getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloatingNumber as getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems };
+export { getRandom, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloatingNumber as getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems };

package/dist/result/index.mjs

@@ -1,2 +1 @@
-import { asyncAttempt, attempt } from "../internal/result/attempt.mjs";
-export { asyncAttempt, attempt };
+export { asyncAttempt, attempt } from "../internal/result/attempt.mjs";

package/dist/result/match.mjs

@@ -20,10 +20,10 @@ function handleResult(result, first, second) {
 		error = second;
 	}
 	if (isOk(result)) {
-		if (typeof ok !== "function") throw new Error(MATCH_MESSAGE_OK);
+		if (typeof ok !== "function") throw new TypeError(MATCH_MESSAGE_OK);
 		return ok(result.value);
 	}
-	if (typeof error !== "function") throw new Error(MATCH_MESSAGE_ERROR);
+	if (typeof error !== "function") throw new TypeError(MATCH_MESSAGE_ERROR);
 	return error(result.error, result.original);
 }
 function matchResult(result, first, second) {

package/dist/result/misc.mjs

@@ -1,17 +1,10 @@
 import { error, isError, isOk, isResult, ok, unwrap } from "../internal/result/misc.mjs";
 //#region src/result/misc.ts
-/**
-* Converts a _Result_ to a _Promise_
-*
-* Resolves if ok, rejects for error
-*
-* @param result _Result_ to convert
-* @returns Promised result
-*/
 async function toPromise(result) {
 	const actual = typeof result === "function" ? result() : result;
-	if (!isResult(actual)) return Promise.reject(new Error(RESULT_MESSAGE_PROMISE));
-	return isOk(actual) ? Promise.resolve(actual.value) : Promise.reject(actual.error);
+	if (!isResult(actual)) throw new TypeError(RESULT_MESSAGE_PROMISE);
+	if (isOk(actual)) return actual.value;
+	throw actual.error;
 }
 const RESULT_MESSAGE_PROMISE = "toPromise expected to receive a Result";
 //#endregion