@oscarpalmer/atoms 0.217.0 → 0.219.0

package/dist/models/array/array.find.model.d.mts

@@ -1,8 +1,34 @@
+import { GenericCallback } from "../index.mjs";
 //#region src/models/array/array.find.model.d.ts
+export type ArrayFindLimitOptions = {
+  limit?: number;
+  map?: never;
+};
+export type ArrayFindMapOptions = {
+  limit?: never;
+  map?: ArrayFindMapper;
+};
 export type ArrayFindMapper = {
   callback: unknown;
+  flat: boolean;
   reverse: boolean;
 };
+export type ArrayFindOptions = ArrayFindMapOptions | ArrayFindLimitOptions;
+export type ArrayFindParameters = {
+  array: unknown[];
+  arrayLength: number;
+  callback?: GenericCallback;
+  flat: boolean;
+  limit: number;
+  map?: ArrayFindParametersMap;
+  result: ArrayFindValuesResult;
+  type: ArrayFindValuesType;
+  value: unknown;
+};
+export type ArrayFindParametersMap = {
+  after?: GenericCallback;
+  before?: GenericCallback;
+};
 export type ArrayFindValueType = "index" | "item";
 export type ArrayFindValuesResult = {
   matched: unknown[];

package/dist/models/array/array.misc.model.d.mts

@@ -1,4 +1,4 @@
-import { GenericCallback, PlainObject } from "../index.mjs";
+import { GenericCallback } from "../index.mjs";
 //#region src/models/array/array.misc.model.d.ts
 export type ArrayCompareSetsType = "difference" | "intersection" | "union";
 /**
@@ -6,6 +6,7 @@ export type ArrayCompareSetsType = "difference" | "intersection" | "union";
  */
 export type ArrayComparison = "end" | "inside" | "invalid" | "outside" | "same" | "start";
 export type ArrayExtractType = "drop" | "take";
+export type ArrayFlattened<Value> = Value extends ReadonlyArray<infer Inner> ? Inner : Value;
 export type ArrayGetCallbacks = {
   bool?: GenericCallback;
   keyed?: GenericCallback;
@@ -16,9 +17,6 @@ export type ArrayOverlapItem = {
   array: unknown[];
   index: number;
 };
-export type ArrayMapKeyOrCallback<Item> = ((item: Item, index: number, array: Item[]) => unknown) | (Item extends PlainObject ? keyof Item : never);
-export type ArrayMapped<Item, Map extends ArrayMapKeyOrCallback<Item>> = Map extends ((item: Item, index: number, array: Item[]) => unknown) ? ReturnType<Map> : Map extends keyof Item ? Item[Map] : never;
-export type ArrayObjectKeysOf<Item> = { [Key in keyof Item]: Item[Key] extends PlainObject ? Key : never; }[keyof Item];
 export type ArrayOverlapResult = {
   first: ArrayOverlapItem;
   second: ArrayOverlapItem;

package/dist/models/index.d.mts

@@ -49,7 +49,7 @@ export type KeyOrCallbackValue<Item, Arg extends KeyOrCallback<Item>> = Arg exte
 /**
  * A nested array
  */
-export type NestedArray<Value> = Value extends Array<infer NestedValue> ? NestedArray<NestedValue> : Value;
+export type NestedArray<Value> = Value extends ReadonlyArray<infer NestedValue> ? NestedArray<NestedValue> : Value;
 /**
  * All nested keys of an object as dot notation strings _(up to 5 levels deep)_
  */

package/dist/models/plan.model.d.mts

@@ -233,6 +233,8 @@ export declare const PLAN_FAILURE_ASYNC: "asyncFailure";
 export declare const PLAN_FAILURE_SYNC: "failure";
 export declare const PLAN_MESSAGE_PLAN_INPUT = "plan requires a generator function";
 export declare const PLAN_MESSAGE_RUN_INPUT = "run requires a plan or a generator function";
+export declare const PLAN_MESSAGE_USE_NESTED_FN = "Cannot use nested functions with 'use'";
+export declare const PLAN_MESSAGE_USE_SYNC_ASYNC = "Cannot use asynchronous values with 'use'";
 export declare const PLAN_STEP_ASYNC: "asyncStep";
 export declare const PLAN_STEP_SYNC: "step";
 export declare const PLAN_SUCCESS_ASYNC: "asyncSuccess";

package/dist/models/plan.model.mjs

@@ -7,6 +7,8 @@ const PLAN_FAILURE_ASYNC = "asyncFailure";
 const PLAN_FAILURE_SYNC = "failure";
 const PLAN_MESSAGE_PLAN_INPUT = "plan requires a generator function";
 const PLAN_MESSAGE_RUN_INPUT = "run requires a plan or a generator function";
+const PLAN_MESSAGE_USE_NESTED_FN = "Cannot use nested functions with 'use'";
+const PLAN_MESSAGE_USE_SYNC_ASYNC = "Cannot use asynchronous values with 'use'";
 const PLAN_STEP_ASYNC = "asyncStep";
 const PLAN_STEP_SYNC = "step";
 const PLAN_SUCCESS_ASYNC = "asyncSuccess";
@@ -15,4 +17,4 @@ const PLAN_SYMBOL = Symbol("plan");
 const PLAN_TYPE_ASYNC = "asyncPlan";
 const PLAN_TYPE_SYNC = "plan";
 //#endregion
-export { GENERATOR_FUNCTION_TYPE_ASYNC, GENERATOR_FUNCTION_TYPE_SYNC, GENERATOR_TYPE_ASYNC, GENERATOR_TYPE_SYNC, PLAN_FAILURE_ASYNC, PLAN_FAILURE_SYNC, PLAN_MESSAGE_PLAN_INPUT, PLAN_MESSAGE_RUN_INPUT, PLAN_STEP_ASYNC, PLAN_STEP_SYNC, PLAN_SUCCESS_ASYNC, PLAN_SUCCESS_SYNC, PLAN_SYMBOL, PLAN_TYPE_ASYNC, PLAN_TYPE_SYNC };
+export { GENERATOR_FUNCTION_TYPE_ASYNC, GENERATOR_FUNCTION_TYPE_SYNC, GENERATOR_TYPE_ASYNC, GENERATOR_TYPE_SYNC, PLAN_FAILURE_ASYNC, PLAN_FAILURE_SYNC, PLAN_MESSAGE_PLAN_INPUT, PLAN_MESSAGE_RUN_INPUT, PLAN_MESSAGE_USE_NESTED_FN, PLAN_MESSAGE_USE_SYNC_ASYNC, PLAN_STEP_ASYNC, PLAN_STEP_SYNC, PLAN_SUCCESS_ASYNC, PLAN_SUCCESS_SYNC, PLAN_SYMBOL, PLAN_TYPE_ASYNC, PLAN_TYPE_SYNC };

package/dist/models/string/string.fuzzy.model.d.mts

@@ -88,7 +88,7 @@ export type FuzzyResult<Item> = {
 /**
  * Options for fuzzy searching
  */
-export type FuzzySearchOptions = FuzzyOptions;
+export type FuzzySearchOptions = { [Key in keyof FuzzyOptions]: FuzzyOptions[Key]; };
 export type FuzzyState<Item> = {
   handler(item: Item): string;
   items: Item[];

package/dist/models/string/string.misc.model.mjs

@@ -2,7 +2,7 @@
 const STRING_DELIMITER_UUID_DEFAULT = "-";
 const STRING_DELIMITER_UUID_HTML = "_";
 const STRING_EXPRESSION_IGNORED = /(^|\.)(__proto__|constructor|prototype)(\.|$)/i;
-const STRING_EXPRESSION_WORDS = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
+const STRING_EXPRESSION_WORDS = /([^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+)/g;
 const STRING_EXPRESSION_WHITESPACE_PREFIX = /^(\s+)/;
 const STRING_MATCH_ENDS_WITH = "endsWith";
 const STRING_MATCH_INCLUDES = "includes";

package/dist/models/value/value.merge.model.d.mts

@@ -3,12 +3,12 @@ import { ArrayOrPlainObject, NestedPartial, PlainObject, UnionToIntersection } f
 /**
  * Options for assigning values
  */
-export type AssignOptions = BaseOptions;
+export type AssignOptions = { [Key in keyof BaseOptions]: BaseOptions[Key]; };
 type BaseOptions = {
   /**
    * Key _(or key epxressions)_ for values that should be replaced
    *
-   * ```ts
+   * ```typescript
    * merge([{items: [1, 2, 3]}, {items: [99]}]); // => {items: [99]}
    * ```
    */
@@ -16,7 +16,7 @@ type BaseOptions = {
   /**
    * Skip nullable values when merging objects?
    *
-   * ```ts
+   * ```typescript
    * merge({a: 1, b: 2}, {b: null, c: 3}, {d: null}); // => {a: 1, b: 2, c: 3}
    * ```
    */
@@ -24,7 +24,7 @@ type BaseOptions = {
   /**
    * Skip nullable values when merging arrays?
    *
-   * ```ts
+   * ```typescript
    * merge([1, 2, 3], [null, null, 99]); // => [1, 2, 99]
    * ```
    */

package/dist/plan/index.d.mts

@@ -1,6 +1,4 @@
 import { AsyncPlan, Plan } from "../models/plan.model.mjs";
-import { asyncAttemptRun, attemptRun } from "./result.mjs";
-import { asyncRun, run } from "./run.mjs";
 //#region src/plan/index.d.ts
 /**
  * Create a plan for an asynchronous generator function
@@ -16,5 +14,4 @@ export declare function plan<Yielded, Returned, Parameters extends unknown[]>(ge
  * @returns Generator plan
  */
 export declare function plan<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => Generator<Yielded, Returned>): Plan<Yielded, Returned, Parameters>;
-//#endregion
-export { asyncAttemptRun, asyncRun, attemptRun, run };
+//#endregion

package/dist/plan/index.mjs

@@ -1,8 +1,7 @@
 import { PLAN_MESSAGE_PLAN_INPUT, PLAN_SYMBOL, PLAN_TYPE_ASYNC, PLAN_TYPE_SYNC } from "../models/plan.model.mjs";
 import { attemptRunPlan, getGenerator, runAsyncPlan, runPlan } from "../internal/plan/index.mjs";
 import { isAsyncGeneratorFunction, isGeneratorFunction } from "./is.mjs";
-import { asyncAttemptRun, attemptRun } from "./result.mjs";
-import { asyncRun, run } from "./run.mjs";
+import { asyncAttemptRun } from "./result.mjs";
 //#region src/plan/index.ts
 function AsyncPlan(generator) {
 	this[PLAN_SYMBOL] = {
@@ -31,4 +30,4 @@ function plan(generator) {
 	throw new Error(PLAN_MESSAGE_PLAN_INPUT);
 }
 //#endregion
-export { asyncAttemptRun, asyncRun, attemptRun, plan, run };
+export { plan };

package/dist/plan/use.mjs

@@ -1,5 +1,5 @@
 import { isError, isOk } from "../internal/result/misc.mjs";
-import { PLAN_STEP_ASYNC, PLAN_STEP_SYNC, PLAN_SYMBOL } from "../models/plan.model.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";
@@ -23,7 +23,7 @@ function asyncUse(value) {
 		let actual = value;
 		if (typeof actual === "function") actual = actual();
 		actual = await actual;
-		if (typeof actual === "function") throw new Error();
+		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)) {
@@ -61,8 +61,8 @@ function use(value) {
 	});
 }
 function validateUseInput(value, resolved) {
-	if (value instanceof Promise || isAsyncFailure(value) || isAsyncGenerator(value) || isAsyncGeneratorFunction(value) || isAsyncPlan(value) || isAsyncStep(value) || isAsyncSuccess(value)) throw new Error();
-	if (resolved && typeof value === "function") throw new Error();
+	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

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.d.mts

@@ -11,7 +11,13 @@ import { isFulfilled, isRejected } from "./helpers.mjs";
  * @returns Cancelable _Promise_
  */
 export declare function cancelable<Value>(executor: (resolve: (value: Value) => void, reject: (reason: unknown) => void) => void): CancelablePromise<Value>;
+/**
+ * @internal
+ */
 export declare function handleResult(status: string, parameters: PromiseParameters): void;
+/**
+ * @internal
+ */
 export declare function settlePromise(settler: (value: any) => void, value: unknown, aborter?: Aborter): void;
 /**
  * Converts a _Promise_ to a promised result

package/dist/promise/misc.mjs

@@ -12,6 +12,9 @@ import { isFulfilled, isRejected } from "./helpers.mjs";
 function cancelable(executor) {
 	return new CancelablePromise(executor);
 }
+/**
+* @internal
+*/
 function handleResult(status, parameters) {
 	const { aborter, complete, data, handlers, index, key, value } = parameters;
 	if (aborter?.signal.aborted ?? false) return;
@@ -20,25 +23,31 @@ 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);
 	}
 }
+/**
+* @internal
+*/
 function settlePromise(settler, value, aborter) {
 	aborter?.cancel();
 	settler(value);
 }
 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/timed.d.mts

@@ -1,6 +1,9 @@
 import { RequiredKeys } from "../models/index.mjs";
 import { PromiseOptions } from "../models/promise.model.mjs";
 //#region src/promise/timed.d.ts
+/**
+ * @internal
+ */
 export declare function getTimedPromise<Value>(promise: Promise<Value>, time: number, signal?: AbortSignal): Promise<Value>;
 /**
  * Create a _Promise_ that should be settled within a certain amount of time

package/dist/promise/timed.mjs

@@ -5,6 +5,9 @@ import { PROMISE_MESSAGE_EXPECTATION_TIMED, PromiseTimeoutError } from "../model
 import { createPromiseOptions } from "./helpers.mjs";
 import { settlePromise } from "./misc.mjs";
 //#region src/promise/timed.ts
+/**
+* @internal
+*/
 async function getTimedPromise(promise, time, signal) {
 	const aborter = createAborter(signal, () => {
 		limiter.cancel();
@@ -23,9 +26,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.d.mts

@@ -17,7 +17,6 @@ export declare function isKeyedQueue(value: unknown): value is KeyedQueue<Generi
  * @returns `true` if the value is a queue, otherwise `false`
  */
 export declare function isQueue(value: unknown): value is Queue<GenericCallback | GenericAsyncCallback>;
-export declare function isQueueInstance<Instance>(name: string, value: unknown): value is Instance;
 /**
  * Create a keyed queue for an asynchronous callback function, where each key has its own queue
  *

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 {
@@ -361,4 +360,4 @@ async function run(state) {
 }
 queue.keyed = keyedQueue;
 //#endregion
-export { isKeyedQueue, isQueue, isQueueInstance, keyedQueue, queue };
+export { isKeyedQueue, isQueue, keyedQueue, queue };

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/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