@oscarpalmer/atoms 0.184.1 → 0.185.0

package/dist/index.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!)
  */
@@ -812,8 +812,11 @@ declare function partition<Item>(array: Item[], filter: (item: Item, index: numb
  */
 declare function partition<Item>(array: Item[], item: Item): Item[][];
 //#endregion
-//#region src/array/position.d.ts
-type ArrayPosition = 'end' | 'inside' | 'invalid' | 'outside' | 'same' | 'start';
+//#region src/array/match.d.ts
+/**
+ * Comparison of an array within another array
+ */
+type ArrayComparison = 'end' | 'inside' | 'invalid' | 'outside' | 'same' | 'start';
 /**
  * Does the needle array end the haystack array?
  * @param haystack Haystack array
@@ -844,7 +847,7 @@ declare function endsWithArray<Item>(haystack: Item[], needle: Item[]): boolean;
  * @param key Key to get an item's value for matching
  * @returns Position of the needle within the haystack
  */
-declare function getArrayPosition<Item extends PlainObject>(haystack: Item[], needle: Item[], key: keyof Item): ArrayPosition;
+declare function getArrayComparison<Item extends PlainObject>(haystack: Item[], needle: Item[], key: keyof Item): ArrayComparison;
 /**
  * Get the position of an array within another array
  * @param haystack Haystack array
@@ -852,14 +855,14 @@ declare function getArrayPosition<Item extends PlainObject>(haystack: Item[], ne
  * @param callback Callback to get an item's value for matching
  * @returns Position of the needle within the haystack
  */
-declare function getArrayPosition<Item>(haystack: Item[], needle: Item[], callback: (item: Item, index: number, array: Item[]) => unknown): ArrayPosition;
+declare function getArrayComparison<Item>(haystack: Item[], needle: Item[], callback: (item: Item, index: number, array: Item[]) => unknown): ArrayComparison;
 /**
  * Get the position of an array within another array
  * @param haystack Haystack array
  * @param needle Needle array
  * @returns Position of the needle within the haystack
  */
-declare function getArrayPosition<Item>(haystack: Item[], needle: Item[]): ArrayPosition;
+declare function getArrayComparison<Item>(haystack: Item[], needle: Item[]): ArrayComparison;
 /**
  * Does the needle array exist within the haystack array?
  * @param haystack Haystack array
@@ -1535,6 +1538,11 @@ type ComparisonSorter<Item> = (first: Item, second: Item) => number;
  * Direction to sort by
  */
 type SortDirection = 'ascending' | 'descending';
+/**
+ * Sorter for an array with predefined sorters
+ *
+ * Can be used to sort an array, get the predicted index for an item, and check if an array is sorted
+ */
 type Sorter<Item> = {
   /**
    * Sort an array of items
@@ -1563,7 +1571,7 @@ type Sorter<Item> = {
  *
  * _(If the array is not sorted, it will be treated as sorted, and the result may be inaccurate)_
  *
- * Available as `getSortedIndex` and `sort.index`
+ * Available as `getSortedIndex` and `sort.getIndex`
  * @param array Array to get the index from
  * @param item Item to get the index for
  * @param sorters Sorters to use to determine sorting
@@ -1576,7 +1584,7 @@ declare function getSortedIndex<Item>(array: Item[], item: Item, sorters: Array<
  *
  * _(If the array is not sorted, it will be treated as sorted, and the result may be inaccurate)_
  *
- * Available as `getSortedIndex` and `sort.index`
+ * Available as `getSortedIndex` and `sort.getIndex`
  * @param array Array to get the index from
  * @param item Item to get the index for
  * @param sorter Sorter to use to determine sorting
@@ -1589,7 +1597,7 @@ declare function getSortedIndex<Item>(array: Item[], item: Item, sorter: ArraySo
  *
  * _(If the array is not sorted, it will be treated as sorted, and the result may be inaccurate)_
  *
- * Available as `getSortedIndex` and `sort.index`
+ * Available as `getSortedIndex` and `sort.getIndex`
  * @param array Array to get the index from
  * @param item Item to get the index for
  * @param descending Sorted in descending order? _(defaults to `false`)_
@@ -1679,7 +1687,7 @@ declare function sort<Item>(array: Item[], sorter: ArraySorter<Item>, descending
  */
 declare function sort<Item>(array: Item[], descending?: boolean): Item[];
 declare namespace sort {
-  var index: typeof getSortedIndex;
+  var getIndex: typeof getSortedIndex;
   var initialize: typeof initializeSorter;
   var is: typeof isSorted;
 }
@@ -2020,12 +2028,20 @@ declare function toRecordArrays<Item, Callback extends (item: Item, index: numbe
 declare function toRecordArrays<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Simplify<Record<KeyedValue<Item, ItemKey>, Item[]>>;
 //#endregion
 //#region src/function/assert.d.ts
+/**
+ * Asserter for a nested property of a value
+ */
+type AssertProperty<Value extends PlainObject, Path extends NestedKeys<Value>, Asserted extends NestedPick<Value, Path> = NestedPick<Value, Path>> = Asserter<Asserted>;
+/**
+ * A function that asserts a value is of a specific type, throwing an error if it is not
+ */
 type Asserter<Value> = (value: unknown) => asserts value is Value;
+type NestedPick<Value, Path extends string> = Value extends PlainObject ? Path extends `${infer Head}.${infer Rest}` ? Head extends keyof Value ? { [Key in Head]: NestedPick<Value[Key], Rest> } : never : Path extends keyof Value ? { [Key in Path]: Value[Key] } : never : never;
 /**
  * Asserts that a condition is true, throwing an error if it is not
  * @param condition Condition to assert
  * @param message Error message
- * @param error Error constructor
+ * @param error Error constructor _(defaults to `Error`)_
  */
 declare function assert<Condition extends () => boolean>(condition: Condition, message: string, error?: ErrorConstructor): asserts condition;
 declare namespace assert {
@@ -2033,6 +2049,7 @@ declare namespace assert {
   var defined: typeof assertDefined;
   var instanceOf: typeof assertInstanceOf;
   var is: typeof assertIs;
+  var property: typeof assertProperty;
 }
 /**
  * Creates an asserter that asserts a condition is true, throwing an error if it is not
@@ -2040,25 +2057,26 @@ declare namespace assert {
  * Available as `assertCondition` and `assert.condition`
  * @param condition Condition to assert
  * @param message Error message
- * @param error Error constructor
+ * @param error Error constructor _(defaults to `Error`)_
  * @returns Asserter
  */
 declare function assertCondition<Value>(condition: (value: unknown) => boolean, message: string, error?: ErrorConstructor): Asserter<Value>;
 /**
- * Asserts that a value is defined throwing an error if it is not
+ * Asserts that a value is defined, throwing an error if it is not
  *
  * Available as `assertDefined` and `assert.defined`
  * @param value Value to assert
  * @param message Error message
+ * @param error Error constructor _(defaults to `Error`)_
  */
-declare function assertDefined<Value>(value: unknown, message?: string): asserts value is Exclude<Value, null | undefined>;
+declare function assertDefined<Value>(value: unknown, message?: string, error?: ErrorConstructor): asserts value is Exclude<Value, null | undefined>;
 /**
  * Creates an asserter that asserts a value is an instance of a constructor, throwing an error if it is not
  *
  * Available as `assertInstanceOf` and `assert.instanceOf`
  * @param constructor Constructor to check against
  * @param message Error message
- * @param error Error constructor
+ * @param error Error constructor _(defaults to `Error`)_
  * @returns Asserter
  */
 declare function assertInstanceOf<Value>(constructor: Constructor<Value>, message: string, error?: ErrorConstructor): Asserter<Value>;
@@ -2068,10 +2086,21 @@ declare function assertInstanceOf<Value>(constructor: Constructor<Value>, messag
  * Available as `assertIs` and `assert.is`
  * @param condition Type guard function to check the value
  * @param message Error message
- * @param error Error constructor
+ * @param error Error constructor _(defaults to `Error`)_
  * @returns Asserter
  */
 declare function assertIs<Value>(condition: (value: unknown) => value is Value, message: string, error?: ErrorConstructor): Asserter<Value>;
+/**
+ * Creates an asserter that asserts a property of a value exists and satisfies a condition, throwing an error if it does not
+ *
+ * Available as `assertProperty` and `assert.property`
+ * @param path Path to the property to check, e.g., `foo.bar.baz` for a nested property
+ * @param condition Condition to assert for the property
+ * @param message Error message
+ * @param error Error constructor _(defaults to `Error`)_
+ * @returns Asserter
+ */
+declare function assertProperty<Value extends PlainObject, Path extends NestedKeys<Value>, Asserted = NestedPick<Value, Path>>(path: Path, condition: (value: NestedValue<Value, Path>) => boolean, message: string, error?: ErrorConstructor): Asserter<Asserted>;
 //#endregion
 //#region src/internal/function/misc.d.ts
 /**
@@ -2080,6 +2109,9 @@ declare function assertIs<Value>(condition: (value: unknown) => value is Value,
 declare function noop(): void;
 //#endregion
 //#region src/function/memoize.d.ts
+/**
+ * A memoized function, caching and retrieving results based on the its parameters _(or a custom cache key)_
+ */
 declare class Memoized<Callback extends GenericCallback> {
   #private;
   /**
@@ -2219,6 +2251,9 @@ declare namespace once {
 }
 //#endregion
 //#region src/function/retry.d.ts
+/**
+ * An error thrown when a retry fails
+ */
 declare class RetryError extends Error {
   readonly original: unknown;
   constructor(message: string, original: unknown);
@@ -2672,6 +2707,7 @@ declare function tryEncode(value: boolean | number | string): unknown;
 declare function words(value: string): string[];
 //#endregion
 //#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
@@ -2702,7 +2738,7 @@ 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
 //#region src/internal/value/equal.d.ts
 /**
@@ -2722,6 +2758,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?
@@ -2807,7 +2848,7 @@ declare function registerEqualizer<Instance>(constructor: Constructor<Instance>,
  * @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
@@ -2845,7 +2886,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
  *
@@ -2855,7 +2896,7 @@ 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
 //#region src/internal/value/set.d.ts
 /**
@@ -3431,6 +3472,9 @@ declare function omit<Value extends PlainObject, ValueKey extends keyof Value>(v
 declare function pick<Value extends PlainObject, ValueKey extends keyof Value>(value: Value, keys: ValueKey[]): Pick<Value, ValueKey>;
 //#endregion
 //#region src/value/shake.d.ts
+/**
+ * A shaken object, without any `undefined` values
+ */
 type Shaken<Value extends PlainObject> = { [Key in keyof Value]: Value[Key] extends undefined ? never : Value[Key] };
 /**
  * Shake an object, removing all keys with `undefined` values
@@ -3440,6 +3484,9 @@ type Shaken<Value extends PlainObject> = { [Key in keyof Value]: Value[Key] exte
 declare function shake<Value extends PlainObject>(value: Value): Shaken<Value>;
 //#endregion
 //#region src/value/smush.d.ts
+/**
+ * A smushed object, with all nested objects flattened into a single level, using dot notation keys
+ */
 type Smushed<Value extends PlainObject> = Simplify<{ [NestedKey in NestedKeys<Value>]: NestedValue<Value, ToString<NestedKey>> }>;
 /**
  * Smush an object into a flat object that uses dot notation keys
@@ -3457,6 +3504,9 @@ type KeysOfUnion<ObjectType> = keyof UnionToIntersection<ObjectType extends unkn
  * Thanks, type-fest!
  */
 type UnionToIntersection<Union> = (Union extends unknown ? (distributedUnion: Union) => void : never) extends ((mergedIntersection: infer Intersection) => void) ? Intersection & Union : never;
+/**
+ * An unsmushed object, with all dot notation keys turned into nested keys
+ */
 type Unsmushed<Value extends PlainObject> = Simplify<Omit<{ [UnionKey in KeysOfUnion<Value>]: Value[UnionKey] }, `${string}.${string}`>>;
 /**
  * Unsmush a smushed object _(turning dot notation keys into nested keys)_
@@ -3558,13 +3608,21 @@ declare function merge<Model extends ArrayOrPlainObject>(values: NestedPartial<M
  */
 declare function merge(values: NestedPartial<ArrayOrPlainObject>[], options?: MergeOptions): ArrayOrPlainObject;
 declare namespace merge {
-  var assign: typeof assign;
   var initialize: typeof initializeMerger;
 }
 //#endregion
 //#region src/value/transform.d.ts
+/**
+ * A callback transform an object's properties
+ */
 type TransformCallback<Value extends PlainObject, Key extends keyof Value> = (key: Key, value: Value[Key]) => Value[Key];
+/**
+ * A collection of keyed callbacks to transform an object's properties
+ */
 type TransformCallbacks<Value extends PlainObject> = Partial<{ [Key in keyof Value]: (value: Value[Key]) => Value[Key] }>;
+/**
+ * A transformer function for an object, with predefined callbacks for transforming its properties
+ */
 type Transformer<Value extends PlainObject> = {
   (value: Value): Value;
 };
@@ -3603,6 +3661,9 @@ declare namespace transform {
 }
 //#endregion
 //#region src/beacon.d.ts
+/**
+ * A beacon is a lighthouse, holding an observable value that can be subscribed to and emitted from
+ */
 declare class Beacon<Value> {
   #private;
   /**
@@ -3652,6 +3713,9 @@ type BeaconOptions<Value> = {
    */
   equal?: (first: Value, second: Value) => boolean;
 };
+/**
+ * An observable holds a value and allows observers to subscribe to changes in that value
+ */
 declare class Observable<Value> {
   #private;
   constructor(instance: Beacon<Value>, observers: Map<Subscription<Value>, Observer<Value>>);
@@ -3679,6 +3743,9 @@ type ObservableState<Value> = {
   closed: boolean;
   observers: Map<Subscription<Value>, Observer<Value>>;
 };
+/**
+ * An observer receives notifications from an observable
+ */
 type Observer<Value> = {
   /**
    * Callback for when the observable is completed
@@ -3693,6 +3760,9 @@ type Observer<Value> = {
    */
   next?: (value: Value) => void;
 };
+/**
+ * A subscription represents an active subscription to an observable, holding its state and allowing it to be destroyed or unsubscribed from
+ */
 declare class Subscription<Value> {
   #private;
   constructor(state: ObservableState<Value>);
@@ -3721,22 +3791,60 @@ declare function beacon<Value>(value: Value, options?: BeaconOptions<Value>): Be
 type ColorWithAlpha = {
   alpha: number;
 };
+/**
+ * An _HSL_-color with an alpha channel
+ */
 type HSLAColor = HSLColor & ColorWithAlpha;
+/**
+ * An _HSL_-color
+ */
 type HSLColor = {
+  /**
+   * Hue of the color _(in degrees; 0-360)_
+   */
   hue: number;
+  /**
+   * Lightness of the color _(in percentage; 0-100)_
+   */
   lightness: number;
+  /**
+   * Saturation of the color _(in percentage; 0-100)_
+   */
   saturation: number;
 };
+/**
+ * An _RGB_-color with an alpha channel
+ */
 type RGBAColor = RGBColor & ColorWithAlpha;
+/**
+ * An _RGB_-color
+ */
 type RGBColor = {
+  /**
+   * Blue channel of the color _(in hexadecimal; 0-255)_
+   */
   blue: number;
+  /**
+   * Green channel of the color _(in hexadecimal; 0-255)_
+   */
   green: number;
+  /**
+   * Red channel of the color _(in hexadecimal; 0-255)_
+   */
   red: number;
 };
 //#endregion
 //#region src/color/instance.d.ts
+/**
+ * A color that is represented in multiple color formats
+ */
 declare class Color {
   #private;
+  /**
+   * A property to identify this as a Color instance, used for type checking
+   *
+   * @internal
+   */
   private readonly $color;
   /**
    * Get the alpha channel
@@ -4136,6 +4244,11 @@ declare function isNumerical(value: unknown): value is number | `${number}`;
 declare function isObject(value: unknown): value is object;
 //#endregion
 //#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
@@ -4184,8 +4297,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)_
@@ -4374,6 +4493,9 @@ declare function clamp(value: number, minimum: number, maximum: number, loop?: b
 declare function getNumber(value: unknown): number;
 //#endregion
 //#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);
@@ -4383,8 +4505,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 = {
@@ -4395,6 +4526,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
@@ -4423,20 +4557,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";
@@ -4470,8 +4625,6 @@ declare function delay(time?: number): Promise<void>;
 //#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
@@ -4479,8 +4632,6 @@ declare function delay(time?: number): Promise<void>;
 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
@@ -4488,8 +4639,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
@@ -4729,6 +4878,9 @@ declare function fromQuery(query: string): PlainObject;
 declare function toQuery(parameters: PlainObject): string;
 //#endregion
 //#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;
   /**
@@ -4819,6 +4971,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;
   /**
@@ -4882,6 +5037,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);
 }
@@ -4899,9 +5057,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;
   /**
@@ -4999,15 +5160,71 @@ declare function getRandomItems<Value>(array: Value[], amount: number): Value[];
  */
 declare function getRandomItems<Value>(array: Value[]): Value[];
 //#endregion
+//#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
+ */
+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
+ */
+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
+ */
+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
+ */
+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
+ */
+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
+ */
+declare function attempt<Value>(callback: () => Value): Result<Value, Error>;
+declare namespace attempt {
+  var async: typeof asyncAttempt;
+}
+//#endregion
 //#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
@@ -5015,16 +5232,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
@@ -5046,168 +5259,144 @@ type AttemptFlowPromise<Callback extends GenericCallback, Value> = (...args: Par
 /**
  * Create an asynchronous Flow, a function that attempts to pipe a value through a series of functions
  *
- * Available as `attemptAsyncFlow` and `attempt.flow.async`
+ * Available as `attemptAsyncFlow` and `attemptFlow.async`
  * @returns Flow function
  */
 declare function attemptAsyncFlow<Fn extends GenericCallback>(fn: Fn): AttemptFlowPromise<Fn, ReturnType<Fn>>;
 /**
  * Create an asynchronous Flow, a function that pipes values through a series of functions
  *
- * Available as `attemptAsyncFlow` and `attempt.flow.async`
+ * Available as `attemptAsyncFlow` and `attemptFlow.async`
  * @returns Flow function
  */
 declare function attemptAsyncFlow<First extends GenericCallback, Second>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second): AttemptFlowPromise<First, Second>;
 /**
  * Create an asynchronous Flow, a function that pipes values through a series of functions
  *
- * Available as `attemptAsyncFlow` and `attempt.flow.async`
+ * Available as `attemptAsyncFlow` and `attemptFlow.async`
  * @returns Flow function
  */
 declare function attemptAsyncFlow<First extends GenericCallback, Second, Third>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third): AttemptFlowPromise<First, Third>;
 /**
  * Create an asynchronous Flow, a function that pipes values through a series of functions
  *
- * Available as `attemptAsyncFlow` and `attempt.flow.async`
+ * Available as `attemptAsyncFlow` and `attemptFlow.async`
  * @returns Flow function
  */
 declare function attemptAsyncFlow<First extends GenericCallback, Second, Third, Fourth>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth): AttemptFlowPromise<First, Fourth>;
 /**
  * Create an asynchronous Flow, a function that pipes values through a series of functions
  *
- * Available as `attemptAsyncFlow` and `attempt.flow.async`
+ * Available as `attemptAsyncFlow` and `attemptFlow.async`
  * @returns Flow function
  */
 declare function attemptAsyncFlow<First extends GenericCallback, Second, Third, Fourth, Fifth>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth, fifth: (value: Awaited<UnwrapValue<Fourth>>) => Fifth): AttemptFlowPromise<First, Fifth>;
 /**
  * Create an asynchronous Flow, a function that pipes values through a series of functions
  *
- * Available as `attemptAsyncFlow` and `attempt.flow.async`
+ * Available as `attemptAsyncFlow` and `attemptFlow.async`
  * @returns Flow function
  */
 declare function attemptAsyncFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth, fifth: (value: Awaited<UnwrapValue<Fourth>>) => Fifth, sixth: (value: Awaited<UnwrapValue<Fifth>>) => Sixth): AttemptFlowPromise<First, Sixth>;
 /**
  * Create an asynchronous Flow, a function that pipes values through a series of functions
  *
- * Available as `attemptAsyncFlow` and `attempt.flow.async`
+ * Available as `attemptAsyncFlow` and `attemptFlow.async`
  * @returns Flow function
  */
 declare function attemptAsyncFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth, Seventh>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth, fifth: (value: Awaited<UnwrapValue<Fourth>>) => Fifth, sixth: (value: Awaited<UnwrapValue<Fifth>>) => Sixth, seventh: (value: Awaited<UnwrapValue<Sixth>>) => Seventh): AttemptFlowPromise<First, Seventh>;
 /**
  * Create an asynchronous Flow, a function that pipes values through a series of functions
  *
- * Available as `attemptAsyncFlow` and `attempt.flow.async`
+ * Available as `attemptAsyncFlow` and `attemptFlow.async`
  * @returns Flow function
  */
 declare function attemptAsyncFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth, fifth: (value: Awaited<UnwrapValue<Fourth>>) => Fifth, sixth: (value: Awaited<UnwrapValue<Fifth>>) => Sixth, seventh: (value: Awaited<UnwrapValue<Sixth>>) => Seventh, eighth: (value: Awaited<UnwrapValue<Seventh>>) => Eighth): AttemptFlowPromise<First, Eighth>;
 /**
  * Create an asynchronous Flow, a function that pipes values through a series of functions
  *
- * Available as `attemptAsyncFlow` and `attempt.flow.async`
+ * Available as `attemptAsyncFlow` and `attemptFlow.async`
  * @returns Flow function
  */
 declare function attemptAsyncFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth, Ninth>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth, fifth: (value: Awaited<UnwrapValue<Fourth>>) => Fifth, sixth: (value: Awaited<UnwrapValue<Fifth>>) => Sixth, seventh: (value: Awaited<UnwrapValue<Sixth>>) => Seventh, eighth: (value: Awaited<UnwrapValue<Seventh>>) => Eighth, ninth: (value: Awaited<UnwrapValue<Eighth>>) => Ninth): AttemptFlowPromise<First, Ninth>;
 /**
  * Create an asynchronous Flow, a function that pipes values through a series of functions
  *
- * Available as `attemptAsyncFlow` and `attempt.flow.async`
+ * Available as `attemptAsyncFlow` and `attemptFlow.async`
  * @returns Flow function
  */
 declare function attemptAsyncFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth, Ninth, Tenth>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth, fifth: (value: Awaited<UnwrapValue<Fourth>>) => Fifth, sixth: (value: Awaited<UnwrapValue<Fifth>>) => Sixth, seventh: (value: Awaited<UnwrapValue<Sixth>>) => Seventh, eighth: (value: Awaited<UnwrapValue<Seventh>>) => Eighth, ninth: (value: Awaited<UnwrapValue<Eighth>>) => Ninth, tenth: (value: Awaited<UnwrapValue<Ninth>>) => Tenth): AttemptFlowPromise<First, Tenth>;
 /**
  * Create an asynchronous Flow, a function that pipes values through a series of functions
  *
- * Available as `attemptAsyncFlow` and `attempt.flow.async`
+ * Available as `attemptAsyncFlow` and `attemptFlow.async`
  * @returns Flow function
  */
 declare function attemptAsyncFlow<Fn extends GenericCallback>(fn: Fn, ...fns: Array<(value: Awaited<UnwrapValue<ReturnType<Fn>>>) => unknown>): AttemptFlowPromise<Fn, ReturnType<Fn>>;
 /**
  * Create an asynchronous Flow, a function that pipes values through a series of functions
  *
- * Available as `attemptAsyncFlow` and `attempt.flow.async`
+ * Available as `attemptAsyncFlow` and `attemptFlow.async`
  * @returns Flow function
  */
 declare function attemptAsyncFlow(...fns: GenericCallback[]): (...args: unknown[]) => Promise<Result<unknown>>;
 /**
  * Create a Flow, a function that attempts to pipe values through a function
- *
- * Available as `attemptFlow` and `attempt.flow`
  * @returns Flow function
  */
 declare function attemptFlow<Fn extends GenericCallback>(fn: Fn): AttemptFlow<Fn, ReturnType<Fn>>;
 /**
  * Create a Flow, a function that attempts to pipe values through a series of functions
- *
- * Available as `attemptFlow` and `attempt.flow`
  * @returns Flow function
  */
 declare function attemptFlow<First extends GenericCallback, Second>(first: First, second: (value: UnwrapValue<ReturnType<First>>) => Second): AttemptFlow<First, Second>;
 /**
  * Create a Flow, a function that attempts to pipe values through a series of functions
- *
- * Available as `attemptFlow` and `attempt.flow`
  * @returns Flow function
  */
 declare function attemptFlow<First extends GenericCallback, Second, Third>(first: First, second: (value: UnwrapValue<ReturnType<First>>) => Second, third: (value: UnwrapValue<Second>) => Third): AttemptFlow<First, Third>;
 /**
  * Create a Flow, a function that attempts to pipe values through a series of functions
- *
- * Available as `attemptFlow` and `attempt.flow`
  * @returns Flow function
  */
 declare function attemptFlow<First extends GenericCallback, Second, Third, Fourth>(first: First, second: (value: UnwrapValue<ReturnType<First>>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth): AttemptFlow<First, Fourth>;
 /**
  * Create a Flow, a function that attempts to pipe values through a series of functions
- *
- * Available as `attemptFlow` and `attempt.flow`
  * @returns Flow function
  */
 declare function attemptFlow<First extends GenericCallback, Second, Third, Fourth, Fifth>(first: First, second: (value: UnwrapValue<ReturnType<First>>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth): AttemptFlow<First, Fifth>;
 /**
  * Create a Flow, a function that attempts to pipe values through a series of functions
- *
- * Available as `attemptFlow` and `attempt.flow`
  * @returns Flow function
  */
 declare function attemptFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth>(first: First, second: (value: UnwrapValue<ReturnType<First>>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth): AttemptFlow<First, Sixth>;
 /**
  * Create a Flow, a function that attempts to pipe values through a series of functions
- *
- * Available as `attemptFlow` and `attempt.flow`
  * @returns Flow function
  */
 declare function attemptFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth, Seventh>(first: First, second: (value: UnwrapValue<ReturnType<First>>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth, seventh: (value: UnwrapValue<Sixth>) => Seventh): AttemptFlow<First, Seventh>;
 /**
  * Create a Flow, a function that attempts to pipe values through a series of functions
- *
- * Available as `attemptFlow` and `attempt.flow`
  * @returns Flow function
  */
 declare function attemptFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth>(first: First, second: (value: UnwrapValue<ReturnType<First>>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth, seventh: (value: UnwrapValue<Sixth>) => Seventh, eighth: (value: UnwrapValue<Seventh>) => Eighth): AttemptFlow<First, Eighth>;
 /**
  * Create a Flow, a function that attempts to pipe values through a series of functions
- *
- * Available as `attemptFlow` and `attempt.flow`
  * @returns Flow function
  */
 declare function attemptFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth, Ninth>(first: First, second: (value: UnwrapValue<ReturnType<First>>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth, seventh: (value: UnwrapValue<Sixth>) => Seventh, eighth: (value: UnwrapValue<Seventh>) => Eighth, ninth: (value: UnwrapValue<Eighth>) => Ninth): AttemptFlow<First, Ninth>;
 /**
  * Create a Flow, a function that attempts to pipe values through a series of functions
- *
- * Available as `attemptFlow` and `attempt.flow`
  * @returns Flow function
  */
 declare function attemptFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth, Ninth, Tenth>(first: First, second: (value: UnwrapValue<ReturnType<First>>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth, seventh: (value: UnwrapValue<Sixth>) => Seventh, eighth: (value: UnwrapValue<Seventh>) => Eighth, ninth: (value: UnwrapValue<Eighth>) => Ninth, tenth: (value: UnwrapValue<Ninth>) => Tenth): AttemptFlow<First, Tenth>;
 /**
  * Create a Flow, a function that attempts to pipe values through a series of functions
- *
- * Available as `attemptFlow` and `attempt.flow`
  * @returns Flow function
  */
 declare function attemptFlow<First extends GenericCallback>(first: First, ...fns: Array<(value: UnwrapValue<ReturnType<First>>) => unknown>): AttemptFlow<First, ReturnType<First>>;
 /**
  * Create a Flow, a function that attempts to pipe values through a series of functions
- *
- * Available as `attemptFlow` and `attempt.flow`
  * @returns Flow function
  */
 declare function attemptFlow(...fns: GenericCallback[]): (...args: unknown[]) => Result<unknown>;
@@ -5220,7 +5409,7 @@ type WrapValue<Value> = Result<UnwrapValue<Value>>;
 /**
  * Attempt to pipe a value through a function
  *
- * Available as `attemptAsyncPipe` and `attempt.pipe.async`
+ * Available as `attemptAsyncPipe` and `attemptPipe.async`
  * @param initial Initial value
  * @returns Piped result
  */
@@ -5228,7 +5417,7 @@ declare function attemptAsyncPipe<Initial, Piped>(initial: GenericCallback | Ini
 /**
  * Attempt to pipe a value through a series of functions
  *
- * Available as `attemptAsyncPipe` and `attempt.pipe.async`
+ * Available as `attemptAsyncPipe` and `attemptPipe.async`
  * @param initial Initial value
  * @returns Piped result
  */
@@ -5236,7 +5425,7 @@ declare function attemptAsyncPipe<Initial, First, Second>(initial: GenericCallba
 /**
  * Attempt to pipe a value through a series of functions
  *
- * Available as `attemptAsyncPipe` and `attempt.pipe.async`
+ * Available as `attemptAsyncPipe` and `attemptPipe.async`
  * @param initial Initial value
  * @returns Piped result
  */
@@ -5244,7 +5433,7 @@ declare function attemptAsyncPipe<Initial, First, Second, Third>(initial: Generi
 /**
  * Attempt to pipe a value through a series of functions
  *
- * Available as `attemptAsyncPipe` and `attempt.pipe.async`
+ * Available as `attemptAsyncPipe` and `attemptPipe.async`
  * @param initial Initial value
  * @returns Piped result
  */
@@ -5252,7 +5441,7 @@ declare function attemptAsyncPipe<Initial, First, Second, Third, Fourth>(initial
 /**
  * Attempt to pipe a value through a series of functions
  *
- * Available as `attemptAsyncPipe` and `attempt.pipe.async`
+ * Available as `attemptAsyncPipe` and `attemptPipe.async`
  * @param initial Initial value
  * @returns Piped result
  */
@@ -5260,7 +5449,7 @@ declare function attemptAsyncPipe<Initial, First, Second, Third, Fourth, Fifth>(
 /**
  * Attempt to pipe a value through a series of functions
  *
- * Available as `attemptAsyncPipe` and `attempt.pipe.async`
+ * Available as `attemptAsyncPipe` and `attemptPipe.async`
  * @param initial Initial value
  * @returns Piped result
  */
@@ -5268,7 +5457,7 @@ declare function attemptAsyncPipe<Initial, First, Second, Third, Fourth, Fifth,
 /**
  * Attempt to pipe a value through a series of functions
  *
- * Available as `attemptAsyncPipe` and `attempt.pipe.async`
+ * Available as `attemptAsyncPipe` and `attemptPipe.async`
  * @param initial Initial value
  * @returns Piped result
  */
@@ -5276,7 +5465,7 @@ declare function attemptAsyncPipe<Initial, First, Second, Third, Fourth, Fifth,
 /**
  * Attempt to pipe a value through a series of functions
  *
- * Available as `attemptAsyncPipe` and `attempt.pipe.async`
+ * Available as `attemptAsyncPipe` and `attemptPipe.async`
  * @param initial Initial value
  * @returns Piped result
  */
@@ -5284,7 +5473,7 @@ declare function attemptAsyncPipe<Initial, First, Second, Third, Fourth, Fifth,
 /**
  * Attempt to pipe a value through a series of functions
  *
- * Available as `attemptAsyncPipe` and `attempt.pipe.async`
+ * Available as `attemptAsyncPipe` and `attemptPipe.async`
  * @param initial Initial value
  * @returns Piped result
  */
@@ -5292,7 +5481,7 @@ declare function attemptAsyncPipe<Initial, First, Second, Third, Fourth, Fifth,
 /**
  * Attempt to pipe a value through a series of functions
  *
- * Available as `attemptAsyncPipe` and `attempt.pipe.async`
+ * Available as `attemptAsyncPipe` and `attemptPipe.async`
  * @param initial Initial value
  * @returns Piped result
  */
@@ -5300,95 +5489,73 @@ declare function attemptAsyncPipe<Initial, First, Second, Third, Fourth, Fifth,
 /**
  * Attempt to pipe a result through a series of functions
  *
- * Available as `attemptAsyncPipe` and `attempt.pipe.async`
+ * Available as `attemptAsyncPipe` and `attemptPipe.async`
  * @param initial Initial result
  * @returns Piped result
  */
 declare function attemptAsyncPipe<Initial>(initial: GenericCallback | Initial | Promise<Initial> | Result<Initial>, first?: (value: UnwrapValue<Initial>) => unknown, ...seconds: Array<(value: unknown) => unknown>): Promise<WrapValue<Initial>>;
 /**
  * Attempt to pipe a value through a function
- *
- * Available as `attemptPipe` and `attempt.pipe`
  * @param initial Initial value
  * @returns Piped result
  */
 declare function attemptPipe<Initial, Pipe>(initial: GenericCallback | Initial | Result<Initial>, pipe: (value: UnwrapValue<Initial>) => Pipe): WrapValue<Pipe>;
 /**
  * Attempt to pipe a value through a series of functions
- *
- * Available as `attemptPipe` and `attempt.pipe`
  * @param initial Initial value
  * @returns Piped result
  */
 declare function attemptPipe<Initial, First, Second>(initial: GenericCallback | Initial | Result<Initial>, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second): WrapValue<Second>;
 /**
  * Attempt to pipe a value through a series of functions
- *
- * Available as `attemptPipe` and `attempt.pipe`
  * @param initial Initial value
  * @returns Piped result
  */
 declare function attemptPipe<Initial, First, Second, Third>(initial: GenericCallback | Initial | Result<Initial>, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third): WrapValue<Third>;
 /**
  * Attempt to pipe a value through a series of functions
- *
- * Available as `attemptPipe` and `attempt.pipe`
  * @param initial Initial value
  * @returns Piped result
  */
 declare function attemptPipe<Initial, First, Second, Third, Fourth>(initial: GenericCallback | Initial | Result<Initial>, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth): WrapValue<Fourth>;
 /**
  * Attempt to pipe a value through a series of functions
- *
- * Available as `attemptPipe` and `attempt.pipe`
  * @param initial Initial value
  * @returns Piped result
  */
 declare function attemptPipe<Initial, First, Second, Third, Fourth, Fifth>(initial: GenericCallback | Initial | Result<Initial>, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth): WrapValue<Fifth>;
 /**
  * Attempt to pipe a value through a series of functions
- *
- * Available as `attemptPipe` and `attempt.pipe`
  * @param initial Initial value
  * @returns Piped result
  */
 declare function attemptPipe<Initial, First, Second, Third, Fourth, Fifth, Sixth>(initial: GenericCallback | Initial | Result<Initial>, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth): WrapValue<Sixth>;
 /**
  * Attempt to pipe a value through a series of functions
- *
- * Available as `attemptPipe` and `attempt.pipe`
  * @param initial Initial value
  * @returns Piped result
  */
 declare function attemptPipe<Initial, First, Second, Third, Fourth, Fifth, Sixth, Seventh>(initial: GenericCallback | Initial | Result<Initial>, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth, seventh: (value: UnwrapValue<Sixth>) => Seventh): WrapValue<Seventh>;
 /**
  * Attempt to pipe a value through a series of functions
- *
- * Available as `attemptPipe` and `attempt.pipe`
  * @param initial Initial value
  * @returns Piped result
  */
 declare function attemptPipe<Initial, First, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth>(initial: GenericCallback | Initial | Result<Initial>, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth, seventh: (value: UnwrapValue<Sixth>) => Seventh, eighth: (value: UnwrapValue<Seventh>) => Eighth): WrapValue<Eighth>;
 /**
  * Attempt to pipe a value through a series of functions
- *
- * Available as `attemptPipe` and `attempt.pipe`
  * @param initial Initial value
  * @returns Piped result
  */
 declare function attemptPipe<Initial, First, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth, Ninth>(initial: GenericCallback | Initial | Result<Initial>, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth, seventh: (value: UnwrapValue<Sixth>) => Seventh, eighth: (value: UnwrapValue<Seventh>) => Eighth, ninth: (value: UnwrapValue<Eighth>) => Ninth): WrapValue<Ninth>;
 /**
  * Attempt to pipe a value through a series of functions
- *
- * Available as `attemptPipe` and `attempt.pipe`
  * @param initial Initial value
  * @returns Piped result
  */
 declare function attemptPipe<Initial, First, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth, Ninth, Tenth>(initial: GenericCallback | Initial | Result<Initial>, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth, seventh: (value: UnwrapValue<Sixth>) => Seventh, eighth: (value: UnwrapValue<Seventh>) => Eighth, ninth: (value: UnwrapValue<Eighth>) => Ninth, tenth: (value: UnwrapValue<Ninth>) => Tenth): WrapValue<Tenth>;
 /**
  * Attempt to pipe a result through a series of functions
- *
- * Available as `attemptPipe` and `attempt.pipe`
  * @param initial Initial result
  * @returns Piped result
  */
@@ -5397,62 +5564,6 @@ declare namespace attemptPipe {
   var async: typeof attemptAsyncPipe;
 }
 //#endregion
-//#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
- */
-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
- */
-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
- */
-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
- */
-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
- */
-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
- */
-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
 //#region src/sized/map.d.ts
 /**
  * A Map with a maximum size
@@ -5500,8 +5611,9 @@ declare class SizedMap<SizedKey = unknown, SizedValue = unknown> extends Map<Siz
 //#endregion
 //#region src/sized/set.d.ts
 /**
- * - A Set with a maximum size
- * - Behavior is similar to a _LRU_-cache, where the oldest values are removed
+ * A Set with a maximum size
+ *
+ * Behavior is similar to a _LRU_-cache, where the oldest values are removed
  */
 declare class SizedSet<Value = unknown> extends Set<Value> {
   #private;
@@ -5542,4 +5654,4 @@ declare class SizedSet<Value = unknown> extends Set<Value> {
   get(value: Value, update?: boolean): Value | undefined;
 }
 //#endregion
-export { AnyResult, ArrayComparisonSorter, ArrayKeySorter, ArrayOrPlainObject, ArrayPosition, ArrayValueSorter, Asserter, AssignOptions, Assigner, AsyncCancelableCallback, AttemptFlow, AttemptFlowPromise, type Beacon, type BeaconOptions, BuiltIns, CancelableCallback, CancelablePromise, type Color, Constructor, DiffOptions, DiffResult, DiffValue, EqualOptions, Err, EventPosition, type Events, ExtendedErr, ExtendedResult, Flow, FlowPromise, Frozen, FulfilledPromise, FuzzyConfiguration, FuzzyOptions, FuzzyResult, FuzzySearchOptions, GenericAsyncCallback, GenericCallback, type HSLAColor, type HSLColor, type Kalas, Key$1 as Key, type KeyedQueue, KeyedValue, type Logger, type Memoized, type MemoizedOptions, MergeOptions, Merger, NestedArray, NestedKeys, NestedPartial, NestedValue, NestedValues, NormalizeOptions, Normalizer, NumericalKeys, NumericalValues, type Observable, type Observer, Ok, OnceAsyncCallback, OnceCallback, PROMISE_ABORT_EVENT, PROMISE_ABORT_OPTIONS, PROMISE_ERROR_NAME, PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_MESSAGE_EXPECTATION_RESULT, PROMISE_MESSAGE_EXPECTATION_TIMED, PROMISE_MESSAGE_TIMEOUT, PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED, PlainObject, Primitive, PromiseData, PromiseHandlers, PromiseOptions, PromiseParameters, PromiseStrategy, PromiseTimeoutError, PromisesItems, PromisesOptions, PromisesResult, PromisesUnwrapped, PromisesValue, PromisesValues, type Queue, type QueueError, type QueueOptions, type Queued, type QueuedResult, type RGBAColor, type RGBColor, RejectedPromise, RequiredKeys, Result, ResultMatch, RetryError, RetryOptions, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, Shaken, Simplify, SizedMap, SizedSet, Smushed, SortDirection, Sorter, type Subscription, TemplateOptions, type Time, ToString, Transformer, TypedArray, Unsmushed, Unsubscriber, UnwrapValue, assert, assertCondition, assertDefined, assertInstanceOf, assertIs, assign, asyncAttempt, asyncDebounce, asyncFlow, asyncMatchResult, asyncOnce, asyncPipe, asyncThrottle, attempt, attemptAsyncFlow, attemptAsyncPipe, attemptFlow, attemptPipe, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, count, debounce, deburr, dedent, delay, deregisterCloner, deregisterComparator, deregisterEqualizer, diff, difference, drop, endsWith, endsWithArray, equal, error, exclude, exists, filter, find, findLast, first, firstOrDefault, flatten, floor, flow, freeze, fromQuery, toPromise as fromResult, toPromise, fuzzy, fuzzyMatch, getArray, getArrayPosition, getColor, getError, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getSortedIndex, getString, getTimedPromise, getUuid, getValue, groupArraysBy, groupBy, handleResult, hasValue, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, ignoreKey, inMap, inSet, includes, includesArray, indexOf, indexOfArray, initializeAssigner, initializeEqualizer, initializeMerger, initializeNormalizer, initializeSorter, initializeTemplater, initializeTransformer, insert, intersection, isArrayOrPlainObject, isColor, isConstructor, isEmpty, isError, isFulfilled, isHexColor, isHslColor, isHslLike, isHslaColor, isInstanceOf, isKey, isNonArrayOrPlainObject, isNonConstructor, isNonEmpty, isNonInstanceOf, isNonKey, isNonNullable, isNonNullableOrEmpty, isNonNullableOrWhitespace, isNonNumber, isNonNumerical, isNonObject, isNonPlainObject, isNonPrimitive, isNonTypedArray, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isRejected, isResult, isRgbColor, isRgbLike, isRgbaColor, isSorted, isTypedArray, join, kalas, kebabCase, keyedQueue, last, lastIndexOf, lastOrDefault, logger, lowerCase, matchResult, max, median, memoize, merge, min, move, moveIndices, moveToIndex, noop, normalize, ok, omit, once, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, registerCloner, registerComparator, registerEqualizer, resultPromises, retry, reverse, rgbToHex, rgbToHsl, rgbToHsla, round, select, setValue, settlePromise, shake, shuffle, single, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toMapArrays, toQuery, toRecord, toRecordArrays, toResult, toSet, toggle, transform, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };
+export { AnyResult, ArrayComparison, ArrayComparisonSorter, ArrayKeySorter, ArrayOrPlainObject, ArrayValueSorter, AssertProperty, Asserter, AssignOptions, Assigner, AsyncCancelableCallback, AttemptFlow, AttemptFlowPromise, type Beacon, type BeaconOptions, BuiltIns, CancelableCallback, CancelablePromise, type Color, Constructor, DiffOptions, DiffResult, DiffValue, EqualOptions, Err, EventPosition, type Events, ExtendedErr, ExtendedResult, Flow, FlowPromise, Frozen, FulfilledPromise, FuzzyConfiguration, FuzzyOptions, FuzzyResult, FuzzySearchOptions, GenericAsyncCallback, GenericCallback, type HSLAColor, type HSLColor, type Kalas, Key$1 as Key, type KeyedQueue, KeyedValue, type Logger, type Memoized, type MemoizedOptions, MergeOptions, Merger, NestedArray, NestedKeys, NestedPartial, NestedValue, NestedValues, NormalizeOptions, Normalizer, NumericalKeys, NumericalValues, type Observable, type Observer, Ok, OnceAsyncCallback, OnceCallback, PROMISE_ABORT_EVENT, PROMISE_ABORT_OPTIONS, PROMISE_ERROR_NAME, PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_MESSAGE_EXPECTATION_RESULT, PROMISE_MESSAGE_EXPECTATION_TIMED, PROMISE_MESSAGE_TIMEOUT, PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED, PlainObject, Primitive, PromiseData, PromiseHandlers, PromiseOptions, PromiseParameters, PromiseStrategy, PromiseTimeoutError, PromisesItems, PromisesOptions, PromisesResult, PromisesUnwrapped, PromisesValue, PromisesValues, type Queue, type QueueError, type QueueOptions, type Queued, type QueuedResult, type RGBAColor, type RGBColor, RejectedPromise, RequiredKeys, Result, ResultMatch, RetryError, RetryOptions, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, Shaken, Simplify, SizedMap, SizedSet, Smushed, SortDirection, Sorter, type Subscription, TemplateOptions, type Time, ToString, Transformer, TypedArray, Unsmushed, Unsubscriber, UnwrapValue, assert, assertCondition, assertDefined, assertInstanceOf, assertIs, assertProperty, assign, asyncAttempt, asyncDebounce, asyncFlow, asyncMatchResult, asyncOnce, asyncPipe, asyncThrottle, attempt, attemptAsyncFlow, attemptAsyncPipe, attemptFlow, attemptPipe, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, count, debounce, deburr, dedent, delay, deregisterCloner, deregisterComparator, deregisterEqualizer, diff, difference, drop, endsWith, endsWithArray, equal, error, exclude, exists, filter, find, findLast, first, firstOrDefault, flatten, floor, flow, freeze, fromQuery, toPromise as fromResult, toPromise, fuzzy, fuzzyMatch, getArray, getArrayComparison, getColor, getError, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getSortedIndex, getString, getTimedPromise, getUuid, getValue, groupArraysBy, groupBy, handleResult, hasValue, hasValueResult, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, ignoreKey, inMap, inSet, includes, includesArray, indexOf, indexOfArray, initializeAssigner, initializeEqualizer, initializeMerger, initializeNormalizer, initializeSorter, initializeTemplater, initializeTransformer, insert, intersection, isArrayOrPlainObject, isColor, isConstructor, isEmpty, isError, isFulfilled, isHexColor, isHslColor, isHslLike, isHslaColor, isInstanceOf, isKey, isNonArrayOrPlainObject, isNonConstructor, isNonEmpty, isNonInstanceOf, isNonKey, isNonNullable, isNonNullableOrEmpty, isNonNullableOrWhitespace, isNonNumber, isNonNumerical, isNonObject, isNonPlainObject, isNonPrimitive, isNonTypedArray, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isRejected, isResult, isRgbColor, isRgbLike, isRgbaColor, isSorted, isTypedArray, join, kalas, kebabCase, keyedQueue, last, lastIndexOf, lastOrDefault, logger, lowerCase, matchResult, max, median, memoize, merge, min, move, moveIndices, moveToIndex, noop, normalize, ok, omit, once, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, registerCloner, registerComparator, registerEqualizer, resultPromises, retry, reverse, rgbToHex, rgbToHsl, rgbToHsla, round, select, setValue, settlePromise, shake, shuffle, single, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toMapArrays, toQuery, toRecord, toRecordArrays, toResult, toSet, toggle, transform, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };