@oscarpalmer/atoms 0.184.1 → 0.185.0

package/dist/internal/number.d.mts

@@ -22,5 +22,6 @@ declare function clamp(value: number, minimum: number, maximum: number, loop?: b
  * @returns Original value as a number, or `NaN` if the value is unable to be parsed
  */
 declare function getNumber(value: unknown): number;
+declare function getNumberOrDefault(value: unknown, defaultValue: number, minimum?: number): number;
 //#endregion
-export { between, clamp, getNumber };
+export { between, clamp, getNumber, getNumberOrDefault };

package/dist/internal/number.mjs

@@ -53,9 +53,12 @@ function getNumber(value) {
 	if (isBinary || EXPRESSION_OCTAL.test(trimmed)) return Number.parseInt(trimmed.slice(2), isBinary ? 2 : OCTAL_VALUE);
 	return Number(trimmed);
 }
+function getNumberOrDefault(value, defaultValue, minimum) {
+	return typeof value === "number" && !Number.isNaN(value) && value >= (minimum ?? 0) ? Math.floor(value) : defaultValue;
+}
 const EXPRESSION_BINARY = /^0b[01]+$/i;
 const EXPRESSION_OCTAL = /^0o[0-7]+$/i;
 const EXPRESSION_ZEROISH = /^\s*0+\s*$/;
 const OCTAL_VALUE = 8;
 //#endregion
-export { between, clamp, getNumber };
+export { between, clamp, getNumber, getNumberOrDefault };

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

@@ -1,6 +1,7 @@
 import { Constructor, GenericCallback } from "../../models.mjs";
 
 //#region src/internal/value/compare.d.ts
+type Comparator<Value = any> = (first: Value, second: Value) => number;
 /**
  * Compare two values _(for sorting purposes)_
  * @param first First value
@@ -31,6 +32,6 @@ declare function deregisterComparator<Instance>(constructor: Constructor<Instanc
  * @param constructor Class constructor
  * @param handler Method name or comparison function _(defaults to `compare`)_
  */
-declare function registerComparator<Instance>(constructor: Constructor<Instance>, handler?: string | ((first: Instance, second: Instance) => number)): void;
+declare function registerComparator<Instance>(constructor: Constructor<Instance>, handler?: string | Comparator<Instance>): void;
 //#endregion
 export { compare, deregisterComparator, registerComparator };

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

@@ -18,6 +18,11 @@ type EqualOptions = {
    */
   relaxedNullish?: boolean;
 };
+/**
+ * An equalizer function for comparing values for equality, with predefined options
+ *
+ * Can be used to compare values, and register or deregister equality comparison handlers for specific classes
+ */
 type Equalizer = {
   /**
    * Are two strings equal?

package/dist/internal/value/equal.mjs

@@ -27,9 +27,9 @@ function equalArray(first, second, options) {
 	const { length } = first;
 	if (length !== second.length) return false;
 	let offset = 0;
-	if (length >= ARRAY_THRESHOLD) {
-		offset = Math.round(length / ARRAY_PEEK_PERCENTAGE);
-		offset = offset > ARRAY_THRESHOLD ? ARRAY_THRESHOLD : offset;
+	if (length >= EQUAL_ARRAY_THRESHOLD) {
+		offset = Math.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;
 	}
 	const end = length - offset;
@@ -164,8 +164,8 @@ function initializeEqualizer(options) {
 function registerEqualizer(constructor, handler) {
 	equal.handlers.register(constructor, handler);
 }
-const ARRAY_PEEK_PERCENTAGE = 10;
-const ARRAY_THRESHOLD = 100;
+const EQUAL_ARRAY_PEEK_PERCENTAGE = 10;
+const EQUAL_ARRAY_THRESHOLD = 100;
 const ERROR_PROPERTIES = ["name", "message"];
 const EXPRESSION_PROPERTIES = ["source", "flags"];
 const MINIMUM_LENGTH_FOR_SET = 16;

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

@@ -1,4 +1,4 @@
-import { NestedKeys, NestedValue, PlainObject, ToString } from "../../models.mjs";
+import { NestedKeys, NestedValue, PlainObject } from "../../models.mjs";
 
 //#region src/internal/value/get.d.ts
 /**
@@ -7,7 +7,7 @@ import { NestedKeys, NestedValue, PlainObject, ToString } from "../../models.mjs
  * @param path Path for value, e.g., `foo.bar.baz`
  * @returns Found value, or `undefined`
  */
-declare function getValue<Data extends PlainObject, Path extends NestedKeys<Data>>(data: Data, path: Path): NestedValue<Data, ToString<Path>>;
+declare function getValue<Data extends PlainObject, Path extends NestedKeys<Data>>(data: Data, path: Path): NestedValue<Data, Path>;
 /**
  * Get the value from an object using an unknown path
  * @param data Object to get value from

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

@@ -29,7 +29,7 @@ declare namespace hasValue {
  * @param ignoreCase If `true`, the path matching is case-insensitive
  * @return Result object
  */
-declare function hasValueResult<Data extends PlainObject, Path extends NestedKeys<Data>>(data: Data, path: Path, ignoreCase?: boolean): Result<NestedValue<Data, ToString<Path>>, undefined>;
+declare function hasValueResult<Data extends PlainObject, Path extends NestedKeys<Data>>(data: Data, path: Path, ignoreCase?: boolean): Result<NestedValue<Data, ToString<Path>>, string>;
 /**
  * Check if a nested property is defined in an object, and get its value if it is
  *
@@ -39,6 +39,6 @@ declare function hasValueResult<Data extends PlainObject, Path extends NestedKey
  * @param ignoreCase If `true`, the path matching is case-insensitive
  * @return Result object
  */
-declare function hasValueResult<Data extends PlainObject>(data: Data, path: string, ignoreCase?: boolean): Result<unknown, undefined>;
+declare function hasValueResult<Data extends PlainObject>(data: Data, path: string, ignoreCase?: boolean): Result<unknown, string>;
 //#endregion
-export { hasValue };
+export { hasValue, hasValueResult };

package/dist/internal/value/has.mjs

@@ -8,4 +8,4 @@ function hasValueResult(data, path, ignoreCase) {
 	return getNestedValue(data, path, ignoreCase === true);
 }
 //#endregion
-export { hasValue };
+export { hasValue, hasValueResult };

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

@@ -2,9 +2,9 @@ import { Result } from "../../result/models.mjs";
 
 //#region src/internal/value/misc.d.ts
 declare function findKey(needle: string, haystack: object): string;
-declare function getNestedValue(data: object, path: string, ignoreCase: boolean): Result<unknown, undefined>;
+declare function getNestedValue(data: object, path: string, ignoreCase: boolean): Result<unknown, string>;
 declare function getPaths(path: string, lowercase: boolean): string | string[];
-declare function handleValue(data: object, path: string, value: unknown, get: true, ignoreCase: boolean): Result<unknown, undefined>;
+declare function handleValue(data: object, path: string, value: unknown, get: true, ignoreCase: boolean): Result<unknown, string>;
 declare function handleValue(data: object, path: string, value: unknown, get: false, ignoreCase: boolean): void;
 //#endregion
 export { findKey, getNestedValue, getPaths, handleValue };

package/dist/internal/value/misc.mjs

@@ -7,7 +7,8 @@ function findKey(needle, haystack) {
 	return index > -1 ? keys[index] : needle;
 }
 function getNestedValue(data, path, ignoreCase) {
-	if (typeof data !== "object" || data === null || typeof path !== "string" || path.trim().length === 0) return error(void 0);
+	if (typeof data !== "object" || data === null) return error(NESTED_MESSAGE_INPUT);
+	if (typeof path !== "string" || path.trim().length === 0) return error(NESTED_MESSAGE_PATH);
 	const shouldIgnoreCase = ignoreCase === true;
 	const paths = getPaths(path, shouldIgnoreCase);
 	if (typeof paths === "string") return handleValue(data, paths, null, true, shouldIgnoreCase);
@@ -27,15 +28,20 @@ function getPaths(path, lowercase) {
 	return normalized.replace(EXPRESSION_BRACKET, ".$1").replace(EXPRESSION_DOTS, "").split(".");
 }
 function handleValue(data, path, value, get, ignoreCase) {
-	if (typeof data === "object" && data !== null && !ignoreKey(path)) {
+	if (typeof data === "object" && data !== null) {
+		if (ignoreKey(path)) return error(NESTED_MESSAGE_UNSAFE);
 		const key = ignoreCase ? findKey(path, data) : path;
-		if (get) return key in data ? ok(data[key]) : error(void 0);
+		if (get) return key in data ? ok(data[key]) : error(NESTED_MESSAGE_MISSING);
 		data[key] = typeof value === "function" ? value(data[key]) : value;
 	}
-	if (get) return error(void 0);
+	if (get) return error(NESTED_MESSAGE_MISSING);
 }
 const EXPRESSION_BRACKET = /\[(\w+)\]/g;
 const EXPRESSION_DOTS = /^\.|\.$/g;
 const EXPRESSION_NESTED = /\.|\[\w+\]/;
+const NESTED_MESSAGE_INPUT = "Expected data to be an object";
+const NESTED_MESSAGE_MISSING = "Expected property to exist in object";
+const NESTED_MESSAGE_PATH = "Expected path to be a string";
+const NESTED_MESSAGE_UNSAFE = "Access to this property is not allowed";
 //#endregion
 export { findKey, getNestedValue, getPaths, handleValue };

package/dist/logger.d.mts

@@ -1,4 +1,9 @@
 //#region src/logger.d.ts
+/**
+ * A logger that can be used to log messages to the console
+ *
+ * _(Logging can be enabled or disabled by setting the `enabled` property)_
+ */
 declare class Logger {
   /**
    * Log any number of values at the "debug" log level
@@ -47,8 +52,14 @@ declare class Logger {
    */
   time(label: string): Time;
 }
+/**
+ * A named timer that can be used to log durations to the console
+ */
 declare class Time {
   #private;
+  /**
+   * Is the timer active? _(i.e. has it been started and not stopped, and is logging enabled?)_
+   */
   get active(): boolean;
   /**
    * Log the current duration of the timer _(ignored if logging is disabled)_

package/dist/logger.mjs

@@ -1,5 +1,10 @@
 import { noop } from "./internal/function/misc.mjs";
 //#region src/logger.ts
+/**
+* A logger that can be used to log messages to the console
+*
+* _(Logging can be enabled or disabled by setting the `enabled` property)_
+*/
 var Logger = class {
 	/**
 	* Log any number of values at the "debug" log level
@@ -70,10 +75,16 @@ var Logger = class {
 		return new Time(label);
 	}
 };
+/**
+* A named timer that can be used to log durations to the console
+*/
 var Time = class {
 	#logger;
 	#stopper;
 	#state;
+	/**
+	* Is the timer active? _(i.e. has it been started and not stopped, and is logging enabled?)_
+	*/
 	get active() {
 		return this.#state.started && !this.#state.stopped && enabled;
 	}

package/dist/models.d.mts

@@ -13,7 +13,7 @@ type AsyncCancelableCallback<Callback extends GenericAsyncCallback | GenericCall
   cancel: () => void;
 };
 /**
- * For mathicng any `void`, `Date`, primitive, or `RegExp` values
+ * For matching any `void`, `Date`, primitive, or `RegExp` values
  *
  * (Thanks, type-fest!)
  */

package/dist/promise/helpers.mjs

@@ -1,11 +1,9 @@
 import { error, ok } from "../result/misc.mjs";
+import { getNumberOrDefault } from "../internal/number.mjs";
 import { PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED } from "./models.mjs";
 //#region src/promise/helpers.ts
-function getNumberOrDefault(value) {
-	return typeof value === "number" && value > 0 ? value : 0;
-}
 function getPromiseOptions(input) {
-	if (typeof input === "number") return { time: getNumberOrDefault(input) };
+	if (typeof input === "number") return { time: getNumberOrDefault(input, 0) };
 	if (input instanceof AbortSignal) return {
 		signal: input,
 		time: 0
@@ -13,7 +11,7 @@ function getPromiseOptions(input) {
 	const options = typeof input === "object" && input !== null ? input : {};
 	return {
 		signal: options.signal instanceof AbortSignal ? options.signal : void 0,
-		time: getNumberOrDefault(options.time)
+		time: getNumberOrDefault(options.time, 0)
 	};
 }
 function getPromisesOptions(input) {

package/dist/promise/index.d.mts

@@ -4,8 +4,6 @@ import { PromiseOptions, PromisesItems, PromisesOptions, PromisesResult, Promise
 //#region src/promise/index.d.ts
 /**
  * Wrap a promise with safety handlers, with optional abort capabilities and timeout
- *
- * Available as `attemptPromise` and `attempt.promise`
  * @param promise Promise to wrap
  * @param options Options for the promise
  * @returns Wrapped promise
@@ -13,8 +11,6 @@ import { PromiseOptions, PromisesItems, PromisesOptions, PromisesResult, Promise
 declare function attemptPromise<Value>(promise: Promise<Value>, options?: PromiseOptions | AbortSignal | number): Promise<Value>;
 /**
  * Wrap a promise-returning callback with safety handlers, with optional abort capabilities and timeout
- *
- * Available as `attemptPromise` and `attempt.promise`
  * @param callback Callback to wrap
  * @param options Options for the promise
  * @returns Promise-wrapped callback
@@ -22,8 +18,6 @@ declare function attemptPromise<Value>(promise: Promise<Value>, options?: Promis
 declare function attemptPromise<Value>(callback: () => Promise<Value>, options?: PromiseOptions | AbortSignal | number): Promise<Value>;
 /**
  * Wrap a callback with a promise and safety handlers, with optional abort capabilities and timeout
- *
- * Available as `attemptPromise` and `attempt.promise`
  * @param callback Callback to wrap
  * @param options Options for the promise
  * @returns Promise-wrapped callback

package/dist/promise/models.d.mts

@@ -2,6 +2,9 @@ import { GenericCallback } from "../models.mjs";
 import { Result } from "../result/models.mjs";
 
 //#region src/promise/models.d.ts
+/**
+ * A promise that can be canceled
+ */
 declare class CancelablePromise<Value = void> extends Promise<Value> {
   #private;
   constructor(executor: (resolve: (value: Value) => void, reject: (reason: unknown) => void) => void);
@@ -11,8 +14,17 @@ declare class CancelablePromise<Value = void> extends Promise<Value> {
    */
   cancel(reason?: unknown): void;
 }
+/**
+ * A promise that was fulfilled
+ */
 type FulfilledPromise<Value> = {
+  /**
+   * Status of the promise
+   */
   status: typeof PROMISE_TYPE_FULFILLED;
+  /**
+   * Value of the promise
+   */
   value: Awaited<Value>;
 };
 type PromiseData = {
@@ -23,6 +35,9 @@ type PromiseHandlers = {
   resolve: (value: unknown[]) => void;
   reject: (reason: unknown) => void;
 };
+/**
+ * Options for a promise-handling function
+ */
 type PromiseOptions = {
   /**
    * AbortSignal for aborting the promise; when aborted, the promise will reject with the reason of the signal
@@ -51,20 +66,41 @@ type PromiseParameters = {
  * 	- Returns an array of values
  */
 type PromiseStrategy = 'complete' | 'first';
+/**
+ * An error thrown when a promise times out
+ */
 declare class PromiseTimeoutError extends Error {
   constructor();
 }
 type PromisesItems<Items extends unknown[]> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends GenericCallback ? ReturnType<Items[ItemsKey]> extends Promise<infer Value> ? Promise<Value> : never : Items[ItemsKey] extends Promise<infer Value> ? Promise<Value> : Promise<Items[ItemsKey]> };
+/**
+ * Options for handling multiple promises
+ */
 type PromisesOptions = {
+  /**
+   * AbortSignal for aborting the promises; when aborted, the promises will reject with the reason of the signal
+   */
   signal?: AbortSignal;
+  /**
+   * Strategy for handling the promises; defaults to `complete`
+   */
   strategy?: PromiseStrategy;
 };
 type PromisesResult<Items extends unknown[]> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends Promise<infer Value> ? Result<Awaited<Value>> : never };
 type PromisesUnwrapped<Items extends unknown[]> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends GenericCallback ? ReturnType<Items[ItemsKey]> extends Promise<infer Value> ? Awaited<Value> : never : Items[ItemsKey] extends Promise<infer Value> ? Awaited<Value> : never };
 type PromisesValue<Value> = FulfilledPromise<Value> | RejectedPromise;
 type PromisesValues<Items extends unknown[]> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends GenericCallback ? ReturnType<Items[ItemsKey]> extends Promise<infer Value> ? PromisesValue<Awaited<Value>> : never : Items[ItemsKey] extends Promise<infer Value> ? PromisesValue<Awaited<Value>> : never };
+/**
+ * A promise that was rejected
+ */
 type RejectedPromise = {
+  /**
+   * Status of the promise
+   */
   status: typeof PROMISE_TYPE_REJECTED;
+  /**
+   * Reason for the rejection
+   */
   reason: unknown;
 };
 declare const PROMISE_ABORT_EVENT = "abort";

package/dist/promise/models.mjs

@@ -1,4 +1,7 @@
 //#region src/promise/models.ts
+/**
+* A promise that can be canceled
+*/
 var CancelablePromise = class extends Promise {
 	#rejector;
 	constructor(executor) {
@@ -17,6 +20,9 @@ var CancelablePromise = class extends Promise {
 		this.#rejector(reason);
 	}
 };
+/**
+* An error thrown when a promise times out
+*/
 var PromiseTimeoutError = class extends Error {
 	constructor() {
 		super(PROMISE_MESSAGE_TIMEOUT);

package/dist/queue.d.mts

@@ -1,6 +1,9 @@
 import { GenericAsyncCallback, GenericCallback } from "./models.mjs";
 
 //#region src/queue.d.ts
+/**
+ * A queue that can be used to manage (a)synchronous tasks with a specific key
+ */
 declare class KeyedQueue<CallbackParameters extends Parameters<GenericAsyncCallback>, CallbackResult> {
   #private;
   /**
@@ -91,6 +94,9 @@ declare class KeyedQueue<CallbackParameters extends Parameters<GenericAsyncCallb
    */
   resume(key?: string): void;
 }
+/**
+ * A queue that can be used to manage (a)synchronous tasks
+ */
 declare class Queue<CallbackParameters extends Parameters<GenericAsyncCallback>, CallbackResult> {
   #private;
   /**
@@ -154,6 +160,9 @@ declare class Queue<CallbackParameters extends Parameters<GenericAsyncCallback>,
    */
   resume(): void;
 }
+/**
+ * An error thrown by the Queue when an operation fails
+ */
 declare class QueueError extends Error {
   constructor(message: string);
 }
@@ -171,9 +180,12 @@ type QueueOptions = {
    */
   maximum?: number;
 };
+/**
+ * A queued item
+ */
 type Queued<Value> = {
   /**
-   * ID of the queued promise _(can be used to remove it from the queue)_
+   * ID of the queued item _(can be used to remove it from the queue)_
    */
   readonly id: number;
   /**

package/dist/queue.mjs

@@ -1,4 +1,8 @@
+import { getNumberOrDefault } from "./internal/number.mjs";
 //#region src/queue.ts
+/**
+* A queue that can be used to manage (a)synchronous tasks with a specific key
+*/
 var KeyedQueue = class {
 	#callback;
 	#options;
@@ -148,6 +152,9 @@ var KeyedQueue = class {
 		for (const queue of queues) queue[type]();
 	}
 };
+/**
+* A queue that can be used to manage (a)synchronous tasks
+*/
 var Queue = class {
 	#callback;
 	#handled = [];
@@ -315,16 +322,19 @@ var Queue = class {
 			if (this.#paused) {
 				const paused = item;
 				this.#handled.push(() => {
-					handleResult(paused, error, result, this.#items.length === 0);
+					handleQueuedResult(paused, error, result, this.#items.length === 0);
 				});
 				break;
 			}
-			handleResult(item, error, result, this.#items.length === 0);
+			handleQueuedResult(item, error, result, this.#items.length === 0);
 			item = this.#items.shift();
 		}
 		this.#runners -= 1;
 	}
 };
+/**
+* An error thrown by the Queue when an operation fails
+*/
 var QueueError = class extends Error {
 	constructor(message) {
 		super(message);
@@ -334,18 +344,15 @@ var QueueError = class extends Error {
 function getBooleanOrDefault(value, defaultValue) {
 	return typeof value === "boolean" ? value : defaultValue;
 }
-function getNumberOrDefault(value, defaultValue) {
-	return typeof value === "number" && value > 0 ? Math.floor(value) : defaultValue;
-}
 function getOptions(input) {
 	const options = typeof input === "object" && input != null ? input : {};
 	return {
 		autostart: getBooleanOrDefault(options.autostart, true),
-		concurrency: getNumberOrDefault(options.concurrency, 1),
+		concurrency: getNumberOrDefault(options.concurrency, 1, 1),
 		maximum: getNumberOrDefault(options.maximum, 0)
 	};
 }
-function handleResult(item, error, result, finished) {
+function handleQueuedResult(item, error, result, finished) {
 	item.signal?.removeEventListener(EVENT_NAME, item.abort);
 	if (item.signal?.aborted ?? false) item.reject();
 	else if (error) item.reject(result);

package/dist/result/index.d.mts

@@ -1,8 +1,4 @@
 import { ExtendedResult, Result } from "./models.mjs";
-import { attemptPromise } from "../promise/index.mjs";
-import { matchResult } from "./match.mjs";
-import { attemptFlow } from "./work/flow.mjs";
-import { attemptPipe } from "./work/pipe.mjs";
 
 //#region src/result/index.d.ts
 /**
@@ -54,10 +50,6 @@ declare function attempt<Value, E>(callback: () => Value, error: E): ExtendedRes
 declare function attempt<Value>(callback: () => Value): Result<Value, Error>;
 declare namespace attempt {
   var async: typeof asyncAttempt;
-  var flow: typeof attemptFlow;
-  var match: typeof matchResult;
-  var pipe: typeof attemptPipe;
-  var promise: typeof attemptPromise;
 }
 //#endregion
 export { asyncAttempt, attempt };

package/dist/result/index.mjs

@@ -1,8 +1,4 @@
 import { getError, ok } from "./misc.mjs";
-import { attemptPromise } from "../promise/index.mjs";
-import { matchResult } from "./match.mjs";
-import { attemptFlow } from "./work/flow.mjs";
-import { attemptPipe } from "./work/pipe.mjs";
 //#region src/result/index.ts
 async function asyncAttempt(value, err) {
 	try {
@@ -21,9 +17,5 @@ function attempt(callback, err) {
 	}
 }
 attempt.async = asyncAttempt;
-attempt.flow = attemptFlow;
-attempt.match = matchResult;
-attempt.pipe = attemptPipe;
-attempt.promise = attemptPromise;
 //#endregion
 export { asyncAttempt, attempt };

package/dist/result/match.d.mts

@@ -3,12 +3,16 @@ import { AnyResult, ResultMatch } from "./models.mjs";
 //#region src/result/match.d.ts
 /**
  * Handles a result with match callbacks
+ *
+ * Available as `asyncMatchResult` and `matchResult.async`
  * @param result Result to handle
  * @param handler Match callbacks
  */
 declare function asyncMatchResult<Value, Returned, E = Error>(result: AnyResult<Value, E> | Promise<AnyResult<Value, E>> | (() => Promise<AnyResult<Value, E>>), handler: ResultMatch<Value, Returned, E>): Promise<Returned>;
 /**
  * Handles a result with match callbacks
+ *
+ * Available as `asyncMatchResult` and `matchResult.async`
  * @param result Result to handle
  * @param ok Ok callback
  * @param error Error callback
@@ -16,16 +20,12 @@ declare function asyncMatchResult<Value, Returned, E = Error>(result: AnyResult<
 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
- *
- * Available as `matchResult` and `attempt.match`
  * @param result Result to handle
  * @param handler Match callbacks
  */
 declare function matchResult<Value, Returned, E = Error>(result: AnyResult<Value, E> | (() => AnyResult<Value, E>), handler: ResultMatch<Value, Returned, E>): Returned;
 /**
  * Handles a result with match callbacks
- *
- * Available as `matchResult` and `attempt.match`
  * @param result Result to handle
  * @param ok Ok callback
  * @param error Error callback