@oscarpalmer/atoms 0.205.0 → 0.207.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/function/work.d.mts

@@ -1,5 +1,5 @@
 import { GenericCallback } from "../../models.mjs";
-import { UnwrapValue } from "../result/models.mjs";
+import { UnwrapValue } from "../models/result.model.mjs";
 //#region src/internal/function/work.d.ts
 /**
  * A synchronous _Flow_, a function that pipe a value through a series of functions

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/models/plan.model.d.mts

@@ -0,0 +1,23 @@
+//#region src/internal/models/plan.model.d.ts
+export type InternalPlan = {
+  [PLAN_SYMBOL]: PlanState;
+} & Plan<never, never>;
+/**
+ * A plan of execution that can yield intermediate results and eventually return a value or an error.
+ */
+export type Plan<out Value, out Error = unknown> = {
+  /**
+   * Run the plan to completion
+   *
+   * @returns Final result, or an error
+   */
+  run: () => Error | Value;
+};
+type PlanState = {
+  generator: () => Generator;
+};
+export declare const GENERATOR_NAME = "GeneratorFunction";
+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_SYMBOL: symbol;
+//#endregion

package/dist/internal/models/plan.model.mjs

@@ -0,0 +1,7 @@
+//#region src/internal/models/plan.model.ts
+const GENERATOR_NAME = "GeneratorFunction";
+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_SYMBOL = Symbol("plan");
+//#endregion
+export { GENERATOR_NAME, PLAN_MESSAGE_PLAN_INPUT, PLAN_MESSAGE_RUN_INPUT, PLAN_SYMBOL };

package/dist/internal/{result/models.d.mts → models/result.model.d.mts}

@@ -1,5 +1,5 @@
 import { GenericCallback } from "../../models.mjs";
-//#region src/internal/result/models.d.ts
+//#region src/internal/models/result.model.d.ts
 /**
  * An unknown result
  */

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/result.model.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/result/misc.d.mts

@@ -1,4 +1,4 @@
-import { Err, ExtendedErr, Ok, Result } from "./models.mjs";
+import { Err, ExtendedErr, Ok, Result } from "../models/result.model.mjs";
 //#region src/internal/result/misc.d.ts
 /**
  * Creates an extended error result

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

@@ -1,5 +1,5 @@
 import { NestedKeys, NestedValue, PlainObject, ToString } from "../../models.mjs";
-import { Result } from "../result/models.mjs";
+import { Result } from "../models/result.model.mjs";
 //#region src/internal/value/has.d.ts
 /**
  * Check if a property is defined in an object

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

@@ -1,4 +1,4 @@
-import { Result } from "../result/models.mjs";
+import { Result } from "../models/result.model.mjs";
 //#region src/internal/value/misc.d.ts
 export declare function findKey(needle: string, haystack: object): string;
 export declare function getNestedValue(data: object, path: string, ignoreCase: boolean): Result<unknown, string>;

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/plan/index.d.mts

@@ -0,0 +1,38 @@
+import { Plan } from "../internal/models/plan.model.mjs";
+//#region src/plan/index.d.ts
+/**
+ * Is the value a generator function?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is a generator function, otherwise `false`
+ */
+export declare function isGenerator(value: unknown): value is () => Generator;
+/**
+ * Is the value a plan?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is a plan, otherwise `false`
+ */
+export declare function isPlan<Value = unknown, Error = unknown>(value: unknown): value is Plan<Value, Error>;
+/**
+ * Create a plan for a generator function
+ *
+ * @param generator Generator to plan for
+ * @returns Generator plan
+ */
+export declare function plan<Value = unknown, Error = unknown>(generator: () => Generator<unknown, Value, Error>): Plan<Value, Error>;
+/**
+ * Run a generator to completion
+ *
+ * @param generator Generator to run
+ * @returns Final result, or an error
+ */
+export declare function run<Value = unknown, Error = unknown>(generator: () => Generator<unknown, Value, unknown>): Error | Value;
+/**
+ * Run a plan to completion
+ *
+ * @param plan Plan to run
+ * @returns Final result, or an error
+ */
+export declare function run<Value = unknown, Error = unknown>(plan: Plan<Value, Error>): Error | Value;
+//#endregion

package/dist/plan/index.mjs

@@ -0,0 +1,61 @@
+import { attempt } from "../internal/result/attempt.mjs";
+import { PLAN_MESSAGE_PLAN_INPUT, PLAN_MESSAGE_RUN_INPUT, PLAN_SYMBOL } from "../internal/models/plan.model.mjs";
+//#region src/plan/index.ts
+function Plan(generator) {
+	this[PLAN_SYMBOL] = { generator };
+}
+Plan.prototype.run = runPlan;
+function execute(callback) {
+	const result = attempt(() => {
+		const generator = callback();
+		let lastValue;
+		while (true) {
+			const next = generator.next();
+			const { done } = next;
+			let { value } = next;
+			if (value instanceof Error) throw value;
+			lastValue = value;
+			if (done === true) break;
+		}
+		return lastValue;
+	});
+	return result.ok ? result.value : result.error;
+}
+/**
+* Is the value a generator function?
+*
+* @param value Value to check
+* @returns `true` if the value is a generator function, otherwise `false`
+*/
+function isGenerator(value) {
+	return typeof value === "function" && value.constructor.name === "GeneratorFunction" && typeof value.prototype.next === "function" && typeof value.prototype.return === "function" && typeof value.prototype.throw === "function";
+}
+/**
+* Is the value a plan?
+*
+* @param value Value to check
+* @returns `true` if the value is a plan, otherwise `false`
+*/
+function isPlan(value) {
+	return typeof value === "object" && value !== null && PLAN_SYMBOL in value;
+}
+/**
+* Create a plan for a generator function
+*
+* @param generator Generator to plan for
+* @returns Generator plan
+*/
+function plan(generator) {
+	if (!isGenerator(generator)) throw new Error(PLAN_MESSAGE_PLAN_INPUT);
+	return new Plan(generator);
+}
+function run(input) {
+	if (isPlan(input)) return input.run();
+	if (!isGenerator(input)) throw new Error(PLAN_MESSAGE_RUN_INPUT);
+	return execute(input);
+}
+function runPlan() {
+	return execute(this[PLAN_SYMBOL].generator);
+}
+//#endregion
+export { isGenerator, isPlan, plan, run };

package/dist/plan/models.d.mts

@@ -0,0 +1,2 @@
+import { Plan } from "../internal/models/plan.model.mjs";
+export type { Plan };

package/dist/plan/models.mjs

@@ -0,0 +1 @@
+export {};

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) {