@oscarpalmer/atoms 0.204.1 → 0.206.0

package/dist/is.d.mts

@@ -27,14 +27,14 @@ export declare function isNonNullable<Value>(value: Value): value is Exclude<Val
  * @param value Value to check
  * @returns `true` if the value is not `undefined`, `null`, or matches an empty string, otherwise `false`
  */
-export declare function isNonNullableOrEmpty<Value>(value: Value): value is Exclude<Value, undefined | null | ''>;
+export declare function isNonNullableOrEmpty<Value>(value: Value): value is Exclude<Value, undefined | null | "">;
 /**
  * Is the value not `undefined`, `null`, or stringified as a whitespace-only string?
  *
  * @param value Value to check
  * @returns `true` if the value is not `undefined`, `null`, or matches a whitespace-only string, otherwise `false`
  */
-export declare function isNonNullableOrWhitespace<Value>(value: Value): value is Exclude<Value, undefined | null | ''>;
+export declare function isNonNullableOrWhitespace<Value>(value: Value): value is Exclude<Value, undefined | null | "">;
 /**
  * Is the value not a number or a number-like string?
  *
@@ -62,14 +62,14 @@ export declare function isNullable(value: unknown): value is undefined | null;
  * @param value Value to check
  * @returns `true` if the value is nullable or matches an empty string, otherwise `false`
  */
-export declare function isNullableOrEmpty(value: unknown): value is undefined | null | '';
+export declare function isNullableOrEmpty(value: unknown): value is undefined | null | "";
 /**
  * Is the value `undefined`, `null`, or stringified as a whitespace-only string?
  *
  * @param value Value to check
  * @returns `true` if the value is nullable or matches a whitespace-only string, otherwise `false`
  */
-export declare function isNullableOrWhitespace(value: unknown): value is undefined | null | '';
+export declare function isNullableOrWhitespace(value: unknown): value is undefined | null | "";
 /**
  * Is the value a number or a number-like string?
  *

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

@@ -1,8 +1,8 @@
 import { RequiredKeys } from "../models.mjs";
 import { FulfilledPromise, PromiseOptions, PromiseStrategy, PromisesOptions, PromisesValue, RejectedPromise } from "./models.mjs";
 //#region src/promise/helpers.d.ts
-export declare function createPromiseOptions(input: unknown): RequiredKeys<PromiseOptions, 'time'>;
-export declare function createPromisesOptions(input: unknown): RequiredKeys<PromisesOptions, 'strategy'>;
+export declare function createPromiseOptions(input: unknown): RequiredKeys<PromiseOptions, "time">;
+export declare function createPromisesOptions(input: unknown): RequiredKeys<PromisesOptions, "strategy">;
 export declare function getResultsFromPromises(promised: Array<PromisesValue<unknown>> | Record<string, PromisesValue<unknown>>): unknown;
 export declare function getStrategyOrDefault(value: unknown): PromiseStrategy;
 /**

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

@@ -34,7 +34,7 @@ export declare function attemptPromise<Value>(callback: () => Value, options?: P
  * @param options Options for handling the _Promises_
  * @returns List of results
  */
-export declare function promises<Items extends unknown[], Options extends PromisesOptions>(items: [...Items], options?: Options): Promise<Options['strategy'] extends 'first' ? PromisesUnwrapped<Items> : PromisesValues<PromisesItems<Items>>>;
+export declare function promises<Items extends unknown[], Options extends PromisesOptions>(items: [...Items], options?: Options): Promise<Options["strategy"] extends "first" ? PromisesUnwrapped<Items> : PromisesValues<PromisesItems<Items>>>;
 /**
  * Handle keyed _Promises_, returning their results in a similarly keyed object
  *
@@ -44,7 +44,7 @@ export declare function promises<Items extends unknown[], Options extends Promis
  * @param options Options for handling the _Promises_
  * @returns Keyed object of results
  */
-export declare function promises<Items extends PlainObject, Options extends PromisesOptions>(items: Items, options?: Options): Promise<Options['strategy'] extends 'first' ? PromisesUnwrapped<Items> : PromisesValues<PromisesItems<Items>>>;
+export declare function promises<Items extends PlainObject, Options extends PromisesOptions>(items: Items, options?: Options): Promise<Options["strategy"] extends "first" ? PromisesUnwrapped<Items> : PromisesValues<PromisesItems<Items>>>;
 /**
  * Handle a list of _Promises_, returning their results in an ordered array
  *
@@ -54,7 +54,7 @@ export declare function promises<Items extends PlainObject, Options extends Prom
  * @param strategy Strategy for handling the _Promises_
  * @returns List of results
  */
-export declare function promises<Items extends unknown[], Strategy extends PromiseStrategy>(items: [...Items], strategy: Strategy): Promise<Strategy extends 'first' ? PromisesUnwrapped<Items> : PromisesValues<PromisesItems<Items>>>;
+export declare function promises<Items extends unknown[], Strategy extends PromiseStrategy>(items: [...Items], strategy: Strategy): Promise<Strategy extends "first" ? PromisesUnwrapped<Items> : PromisesValues<PromisesItems<Items>>>;
 /**
  * Handle keyed _Promises_, returning their results in a similarly keyed object
  *
@@ -64,7 +64,7 @@ export declare function promises<Items extends unknown[], Strategy extends Promi
  * @param strategy Strategy for handling the _Promises_
  * @returns Keyed object of results
  */
-export declare function promises<Items extends PlainObject, Strategy extends PromiseStrategy>(items: Items, strategy: Strategy): Promise<Strategy extends 'first' ? PromisesUnwrapped<Items> : PromisesValues<PromisesItems<Items>>>;
+export declare function promises<Items extends PlainObject, Strategy extends PromiseStrategy>(items: Items, strategy: Strategy): Promise<Strategy extends "first" ? PromisesUnwrapped<Items> : PromisesValues<PromisesItems<Items>>>;
 /**
  * Handle a list of _Promises_, returning their results in an ordered array
  *
@@ -81,9 +81,6 @@ export declare function promises<Items extends unknown[]>(items: [...Items], sig
  * @returns Keyed object of results
  */
 export declare function promises<Items extends PlainObject>(items: Items, signal?: AbortSignal): Promise<PromisesValues<PromisesItems<Items>>>;
-export declare namespace promises {
-  var result: typeof resultPromises;
-}
 /**
  * Handle a list of _Promises_, returning their results in an ordered array of results _({@link Result})_
  *
@@ -106,4 +103,7 @@ export declare function resultPromises<Items extends unknown[]>(items: [...Items
  * @returns Keyed object of results
  */
 export declare function resultPromises<Items extends PlainObject>(items: Items, signal?: AbortSignal): Promise<PromisesResult<PromisesItems<Items>>>;
+export declare namespace promises {
+  export var result: typeof resultPromises;
+}
 //#endregion

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

@@ -65,7 +65,7 @@ export type PromiseParameters = {
  * - `complete`: wait for all _Promises_ to settle, then return the results, as an array of fulfilled and/or rejected results
  * - `first`: rejects on the first rejected _Promise_, and returns an array of values
  */
-export type PromiseStrategy = 'complete' | 'first';
+export type PromiseStrategy = "complete" | "first";
 /**
  * An error thrown when a promise times out
  */

package/dist/promise/timed.d.mts

@@ -9,7 +9,7 @@ export declare function getTimedPromise<Value>(promise: Promise<Value>, time: nu
  * @param options Timed options
  * @returns Timed _Promise_
  */
-export declare function timed<Value>(promise: Promise<Value>, options: RequiredKeys<PromiseOptions, 'time'>): Promise<Value>;
+export declare function timed<Value>(promise: Promise<Value>, options: RequiredKeys<PromiseOptions, "time">): Promise<Value>;
 /**
  * Create a _Promise_ that should be settled within a certain amount of time
  *

package/dist/queue.d.mts

@@ -248,6 +248,6 @@ export declare function queue<Callback extends GenericAsyncCallback>(callback: C
  */
 export declare function queue<Callback extends GenericCallback>(callback: Callback, options?: QueueOptions): Queue<Callback, Parameters<Callback>>;
 export declare namespace queue {
-  var keyed: typeof keyedQueue;
+  export var keyed: typeof keyedQueue;
 }
 //#endregion

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 {
-  var async: typeof asyncAttempt;
-}
-//#endregion
+import { asyncAttempt, attempt } from "../internal/result/attempt.mjs";
+export { asyncAttempt, attempt };

package/dist/result/index.mjs

@@ -1,22 +1,2 @@
-import { getError, ok } from "../internal/result/misc.mjs";
-//#region src/result/index.ts
-async function asyncAttempt(value, err) {
-	try {
-		let result = typeof value === "function" ? value() : await 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/match.d.mts

@@ -20,7 +20,7 @@ export declare function asyncMatchResult<Value, Returned, E = Error>(result: Any
  * @param error Error callback
  * @returns Matched value-_Promise_
  */
-export declare function asyncMatchResult<Value, Returned, E = Error>(result: AnyResult<Value, E> | Promise<AnyResult<Value, E>> | (() => Promise<AnyResult<Value, E>>), ok: ResultMatch<Value, Returned, E>['ok'], error: ResultMatch<Value, Returned, E>['error']): Promise<Returned>;
+export declare function asyncMatchResult<Value, Returned, E = Error>(result: AnyResult<Value, E> | Promise<AnyResult<Value, E>> | (() => Promise<AnyResult<Value, E>>), ok: ResultMatch<Value, Returned, E>["ok"], error: ResultMatch<Value, Returned, E>["error"]): Promise<Returned>;
 /**
  * Handles a _Result_ with match callbacks
  *
@@ -37,8 +37,8 @@ export declare function matchResult<Value, Returned, E = Error>(result: AnyResul
  * @param error Error callback
  * @returns Matched value
  */
-export declare function matchResult<Value, Returned, E = Error>(result: AnyResult<Value, E> | (() => AnyResult<Value, E>), ok: ResultMatch<Value, Returned, E>['ok'], error: ResultMatch<Value, Returned, E>['error']): Returned;
+export declare function matchResult<Value, Returned, E = Error>(result: AnyResult<Value, E> | (() => AnyResult<Value, E>), ok: ResultMatch<Value, Returned, E>["ok"], error: ResultMatch<Value, Returned, E>["error"]): Returned;
 export declare namespace matchResult {
-  var async: typeof asyncMatchResult;
+  export var async: typeof asyncMatchResult;
 }
 //#endregion

package/dist/result/work/flow.d.mts

@@ -178,6 +178,6 @@ export declare function attemptFlow<First extends GenericCallback>(first: First,
  */
 export declare function attemptFlow(...fns: GenericCallback[]): (...args: unknown[]) => Result<unknown>;
 export declare namespace attemptFlow {
-  var async: typeof attemptAsyncFlow;
+  export var async: typeof attemptAsyncFlow;
 }
 //#endregion

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

@@ -179,6 +179,6 @@ export declare function attemptPipe<Initial, First, Second, Third, Fourth, Fifth
  */
 export declare function attemptPipe<Initial>(initial: GenericCallback | Initial | Result<Initial>, first?: (value: UnwrapValue<Initial>) => unknown, ...seconds: Array<(value: unknown) => unknown>): WrapValue<Initial>;
 export declare namespace attemptPipe {
-  var async: typeof attemptAsyncPipe;
+  export var async: typeof attemptAsyncPipe;
 }
 //#endregion

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

package/dist/sized/set.d.mts

@@ -36,7 +36,7 @@ export declare class SizedSet<Value = unknown> extends Set<Value> {
   /**
    * @inheritdoc
    */
-  add(value: Value): this;
+  override add(value: Value): this;
   /**
    * Get a value from the _SizedSet_, if it exists _(and optionally move it to the end)_
    *

package/dist/string/fuzzy.d.mts

@@ -109,10 +109,6 @@ export declare function fuzzy<Item>(items: Item[], handler?: (item: Item) => str
  * @returns Fuzzy searcher
  */
 export declare function fuzzy<Item>(items: Item[], configuration?: FuzzyConfiguration<Item>): Fuzzy<Item>;
-export declare namespace fuzzy {
-  var is: typeof isFuzzy;
-  var match: typeof fuzzyMatch;
-}
 /**
  * Does the needle match the haystack in a fuzzy way?
  *
@@ -132,4 +128,8 @@ export declare function fuzzyMatch(haystack: string, needle: string): boolean;
  * @returns `true` if the value is a fuzzy searcher, otherwise `false`
  */
 export declare function isFuzzy<Item = unknown>(value: unknown): value is Fuzzy<Item>;
+export declare namespace fuzzy {
+  export var is: typeof isFuzzy;
+  export var match: typeof fuzzyMatch;
+}
 //#endregion

package/dist/string/fuzzy.mjs

@@ -1,4 +1,6 @@
 import { isPlainObject } from "../internal/is.mjs";
+import { floor } from "../internal/math/misc.mjs";
+import { max } from "../internal/math/aggregate.mjs";
 import { getString } from "../internal/string/misc.mjs";
 import { lowerCase } from "../internal/string/case.mjs";
 import { includes } from "./match.mjs";
@@ -27,7 +29,7 @@ function createFuzzyItems(items) {
 function createFuzzyOptions(input, state) {
 	const options = isPlainObject(input) ? input : {};
 	const limit = typeof input === "number" ? input : options.limit;
-	if (typeof limit === "number" && !Number.isNaN(limit) && limit >= 1) options.limit = Math.floor(limit);
+	if (typeof limit === "number" && !Number.isNaN(limit) && limit >= 1) options.limit = floor(limit);
 	else options.limit = state?.limit;
 	options.tolerance = getTolerance(options.tolerance, state);
 	return options;
@@ -92,18 +94,18 @@ function getScore(haystack, needle) {
 			if (haystackIndex === 0) score += 1;
 			if (previousMatchIndex !== -1) {
 				const gap = haystackIndex - previousMatchIndex - 1;
-				score += Math.max(0, FUZZY_PROXIMITY_THRESHOLD - gap);
+				score += max([0, FUZZY_PROXIMITY_THRESHOLD - gap]);
 			}
 			previousMatchIndex = haystackIndex;
 			needleIndex += 1;
 		}
 		if (needleIndex === needleLength) break;
 	}
-	score -= Math.floor(lowerCaseHaystack.length / FUZZY_LENGTH_DIVISOR);
-	return Math.max(0, score);
+	score -= floor(lowerCaseHaystack.length / FUZZY_LENGTH_DIVISOR);
+	return max([0, score]);
 }
 function getTolerance(input, state) {
-	if (typeof input === "number" && !Number.isNaN(input)) return input < 0 ? 0 : Math.floor(input);
+	if (typeof input === "number" && !Number.isNaN(input)) return input < 0 ? 0 : floor(input);
 	return state?.tolerance ?? FUZZY_PROXIMITY_THRESHOLD;
 }
 /**

package/dist/string/index.mjs

@@ -1,4 +1,5 @@
 import { isTemplateStringsArray } from "../internal/is.mjs";
+import { min } from "../internal/math/aggregate.mjs";
 import { getString, interpolate, join, words } from "../internal/string/misc.mjs";
 //#region src/string/index.ts
 function dedent(value, ...values) {
@@ -16,7 +17,7 @@ function dedent(value, ...values) {
 		if (indentation != null) lengths.push(indentation.length);
 	}
 	if (lengths.length === 0) return actual.trim();
-	const minimum = Math.min(...lengths);
+	const minimum = min(lengths);
 	const pattern = new RegExp(`^\\s{0,${minimum}}`);
 	let result = "";
 	for (let index = 0; index < length; index += 1) {

package/dist/string/normalize.d.mts

@@ -65,6 +65,6 @@ export declare function initializeNormalizer(options?: NormalizeOptions): Normal
  */
 export declare function normalize(value: string, options?: NormalizeOptions): string;
 export declare namespace normalize {
-  var initialize: typeof initializeNormalizer;
+  export var initialize: typeof initializeNormalizer;
 }
 //#endregion

package/dist/string/template.d.mts

@@ -41,7 +41,6 @@ type Templater = {
  * Render a template string with variables
  */
 type TemplaterRenderer = (variables?: PlainObject) => string;
-declare function Templater(this: any, options: Required<TemplateOptions>): void;
 /**
  * Create a _Templater_ with predefined options
  *
@@ -67,6 +66,6 @@ export declare function template(strings: TemplateStringsArray, ...values: unkno
  */
 export declare function template(value: string, variables?: PlainObject, options?: Partial<TemplateOptions>): string;
 export declare namespace template {
-  var initialize: typeof initializeTemplater;
+  export var initialize: typeof initializeTemplater;
 }
 //#endregion