@oscarpalmer/atoms 0.184.2 → 0.185.0

package/dist/array/index.d.mts

@@ -11,7 +11,7 @@ import { shuffle } from "../internal/array/shuffle.mjs";
 import { insert } from "./insert.mjs";
 import { intersection } from "./intersection.mjs";
 import { partition } from "./partition.mjs";
-import { ArrayPosition, endsWithArray, getArrayPosition, includesArray, indexOfArray, startsWithArray } from "./position.mjs";
+import { ArrayComparison, endsWithArray, getArrayComparison, includesArray, indexOfArray, startsWithArray } from "./match.mjs";
 import { push } from "./push.mjs";
 import { reverse } from "./reverse.mjs";
 import { select } from "./select.mjs";
@@ -23,4 +23,4 @@ import { toggle } from "./toggle.mjs";
 import { union } from "./union.mjs";
 import { unique } from "./unique.mjs";
 import { update } from "./update.mjs";
-export { ArrayPosition, chunk, compact, difference, drop, endsWithArray, exists, find, findLast, flatten, getArray, getArrayPosition, includesArray, indexOf, indexOfArray, insert, intersection, lastIndexOf, partition, push, range, reverse, select, shuffle, single, slice, splice, startsWithArray, take, times, toSet, toggle, union, unique, update };
+export { ArrayComparison, chunk, compact, difference, drop, endsWithArray, exists, find, findLast, flatten, getArray, getArrayComparison, includesArray, indexOf, indexOfArray, insert, intersection, lastIndexOf, partition, push, range, reverse, select, shuffle, single, slice, splice, startsWithArray, take, times, toSet, toggle, union, unique, update };

package/dist/array/index.mjs

@@ -11,7 +11,7 @@ import { getArray } from "./get.mjs";
 import { insert } from "./insert.mjs";
 import { intersection } from "./intersection.mjs";
 import { partition } from "./partition.mjs";
-import { endsWithArray, getArrayPosition, includesArray, indexOfArray, startsWithArray } from "./position.mjs";
+import { endsWithArray, getArrayComparison, includesArray, indexOfArray, startsWithArray } from "./match.mjs";
 import { push } from "./push.mjs";
 import { reverse } from "./reverse.mjs";
 import { select } from "./select.mjs";
@@ -23,4 +23,4 @@ import { toggle } from "./toggle.mjs";
 import { union } from "./union.mjs";
 import { unique } from "./unique.mjs";
 import { update } from "./update.mjs";
-export { chunk, compact, difference, drop, endsWithArray, exists, find, findLast, flatten, getArray, getArrayPosition, includesArray, indexOf, indexOfArray, insert, intersection, lastIndexOf, partition, push, range, reverse, select, shuffle, single, slice, splice, startsWithArray, take, times, toSet, toggle, union, unique, update };
+export { chunk, compact, difference, drop, endsWithArray, exists, find, findLast, flatten, getArray, getArrayComparison, includesArray, indexOf, indexOfArray, insert, intersection, lastIndexOf, partition, push, range, reverse, select, shuffle, single, slice, splice, startsWithArray, take, times, toSet, toggle, union, unique, update };

package/dist/array/{position.d.mts → match.d.mts}

@@ -1,7 +1,10 @@
 import { PlainObject } from "../models.mjs";
 
-//#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
@@ -32,7 +35,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
@@ -40,14 +43,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
@@ -118,4 +121,4 @@ declare function startsWithArray<Item>(haystack: Item[], needle: Item[], callbac
  */
 declare function startsWithArray<Item>(haystack: Item[], needle: Item[]): boolean;
 //#endregion
-export { ArrayPosition, endsWithArray, getArrayPosition, includesArray, indexOfArray, startsWithArray };
+export { ArrayComparison, endsWithArray, getArrayComparison, includesArray, indexOfArray, startsWithArray };

package/dist/array/{position.mjs → match.mjs}

@@ -1,14 +1,14 @@
 import { getArrayCallback } from "../internal/array/callbacks.mjs";
-//#region src/array/position.ts
+//#region src/array/match.ts
 function endsWithArray(haystack, needle, key) {
 	return endings.has(getPosition(haystack, needle, key)[1]);
 }
-function getArrayPosition(haystack, needle, key) {
+function getArrayComparison(haystack, needle, key) {
 	return getPosition(haystack, needle, key)[1];
 }
 function getName(start, haystack, needle) {
-	if (start === 0) return haystack === needle ? POSITION_SAME : POSITION_START;
-	return start + needle === haystack ? POSITION_END : POSITION_INSIDE;
+	if (start === 0) return haystack === needle ? COMPARISON_SAME : COMPARISON_START;
+	return start + needle === haystack ? COMPARISON_END : COMPARISON_INSIDE;
 }
 function getPosition(haystack, needle, key) {
 	if (!Array.isArray(haystack) || !Array.isArray(needle)) return invalid;
@@ -43,16 +43,16 @@ function indexOfArray(haystack, needle, key) {
 function startsWithArray(haystack, needle, key) {
 	return starts.has(getPosition(haystack, needle, key)[1]);
 }
-const POSITION_END = "end";
-const POSITION_INSIDE = "inside";
-const POSITION_INVALID = "invalid";
-const POSITION_OUTSIDE = "outside";
-const POSITION_SAME = "same";
-const POSITION_START = "start";
-const endings = new Set([POSITION_END, POSITION_SAME]);
-const invalid = [-1, POSITION_INVALID];
-const outside = [-1, POSITION_OUTSIDE];
-const outsides = new Set([POSITION_INVALID, POSITION_OUTSIDE]);
-const starts = new Set([POSITION_START, POSITION_SAME]);
+const COMPARISON_END = "end";
+const COMPARISON_INSIDE = "inside";
+const COMPARISON_INVALID = "invalid";
+const COMPARISON_OUTSIDE = "outside";
+const COMPARISON_SAME = "same";
+const COMPARISON_START = "start";
+const endings = new Set([COMPARISON_END, COMPARISON_SAME]);
+const invalid = [-1, COMPARISON_INVALID];
+const outside = [-1, COMPARISON_OUTSIDE];
+const outsides = new Set([COMPARISON_INVALID, COMPARISON_OUTSIDE]);
+const starts = new Set([COMPARISON_START, COMPARISON_SAME]);
 //#endregion
-export { endsWithArray, getArrayPosition, includesArray, indexOfArray, startsWithArray };
+export { endsWithArray, getArrayComparison, includesArray, indexOfArray, startsWithArray };

package/dist/array/move.mjs

@@ -1,4 +1,4 @@
-import { indexOfArray } from "./position.mjs";
+import { indexOfArray } from "./match.mjs";
 import { arraysOverlap } from "../internal/array/overlap.mjs";
 //#region src/array/move.ts
 function move(array, from, to, key) {

package/dist/array/sort.d.mts

@@ -65,6 +65,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
@@ -93,7 +98,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
@@ -106,7 +111,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
@@ -119,7 +124,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`)_
@@ -209,7 +214,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;
 }

package/dist/array/sort.mjs

@@ -124,7 +124,7 @@ function sortArray(array, sorters) {
 	const { length } = sorters;
 	return array.length > 1 ? array.sort((first, second) => getComparisonValue(first, second, sorters, length)) : array;
 }
-sort.index = getSortedIndex;
+sort.getIndex = getSortedIndex;
 sort.initialize = initializeSorter;
 sort.is = isSorted;
 const SORT_PEEK_PERCENTAGE = 10;

package/dist/array/swap.mjs

@@ -1,6 +1,6 @@
 import { getArrayCallback } from "../internal/array/callbacks.mjs";
 import { indexOf } from "../internal/array/index-of.mjs";
-import { indexOfArray } from "./position.mjs";
+import { indexOfArray } from "./match.mjs";
 import { arraysOverlap } from "../internal/array/overlap.mjs";
 //#region src/array/swap.ts
 function swap(array, first, second, third) {

package/dist/beacon.d.mts

@@ -1,4 +1,7 @@
 //#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;
   /**
@@ -48,6 +51,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>>);
@@ -75,6 +81,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
@@ -89,6 +98,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>);

package/dist/beacon.mjs

@@ -1,6 +1,9 @@
 import { noop } from "./internal/function/misc.mjs";
 import { isPlainObject } from "./internal/is.mjs";
 //#region src/beacon.ts
+/**
+* A beacon is a lighthouse, holding an observable value that can be subscribed to and emitted from
+*/
 var Beacon = class {
 	#options;
 	#state;
@@ -71,6 +74,9 @@ var Beacon = class {
 		if (finish === true) finishBeacon(this.#state, true);
 	}
 };
+/**
+* An observable holds a value and allows observers to subscribe to changes in that value
+*/
 var Observable = class {
 	#state;
 	constructor(instance, observers) {
@@ -95,6 +101,9 @@ var Observable = class {
 		return instance;
 	}
 };
+/**
+* A subscription represents an active subscription to an observable, holding its state and allowing it to be destroyed or unsubscribed from
+*/
 var Subscription = class {
 	#state;
 	constructor(state) {

package/dist/color/instance.d.mts

@@ -1,8 +1,16 @@
 import { HSLAColor, HSLColor, RGBAColor, RGBColor } from "./models.mjs";
 
 //#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

package/dist/color/instance.mjs

@@ -3,6 +3,9 @@ import { formatColor } from "./misc/index.mjs";
 import { getAlpha } from "./misc/alpha.mjs";
 import { getColorState, setHSLColor, setHexColor, setRGBColor } from "./misc/state.mjs";
 //#region src/color/instance.ts
+/**
+* A color that is represented in multiple color formats
+*/
 var Color = class {
 	#state;
 	/**

package/dist/color/models.d.mts

@@ -6,16 +6,46 @@ type Alpha = {
 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;
 };
 type ColorProperty = 'alpha' | 'blue' | 'green' | 'hue' | 'lightness' | 'red' | 'saturation';

package/dist/function/assert.d.mts

@@ -1,12 +1,20 @@
-import { Constructor } from "../models.mjs";
+import { Constructor, NestedKeys, NestedValue, PlainObject } from "../models.mjs";
 
 //#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 {
@@ -14,6 +22,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
@@ -21,25 +30,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>;
@@ -49,9 +59,20 @@ 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
-export { Asserter, assert, assertCondition, assertDefined, assertInstanceOf, assertIs };
+export { AssertProperty, Asserter, assert, assertCondition, assertDefined, assertInstanceOf, assertIs, assertProperty };

package/dist/function/assert.mjs

@@ -1,9 +1,10 @@
+import { hasValueResult } from "../internal/value/has.mjs";
 //#region src/function/assert.ts
 /**
 * 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`)_
 */
 function assert(condition, message, error) {
 	if (!condition()) throw new (error ?? Error)(message);
@@ -12,13 +13,14 @@ assert.condition = assertCondition;
 assert.defined = assertDefined;
 assert.instanceOf = assertInstanceOf;
 assert.is = assertIs;
+assert.property = assertProperty;
 /**
 * Creates an asserter that asserts a condition is true, throwing an error if it is not
 *
 * 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
 */
 function assertCondition(condition, message, error) {
@@ -27,14 +29,15 @@ function assertCondition(condition, message, error) {
 	};
 }
 /**
-* 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`)_
 */
-function assertDefined(value, message) {
-	assert(() => value != null, message ?? MESSAGE_VALUE_DEFINED);
+function assertDefined(value, message, error) {
+	assert(() => value != null, message ?? MESSAGE_VALUE_DEFINED, error);
 }
 /**
 * Creates an asserter that asserts a value is an instance of a constructor, throwing an error if it is not
@@ -42,7 +45,7 @@ function assertDefined(value, message) {
 * 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
 */
 function assertInstanceOf(constructor, message, error) {
@@ -56,7 +59,7 @@ function assertInstanceOf(constructor, message, error) {
 * 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
 */
 function assertIs(condition, message, error) {
@@ -64,6 +67,24 @@ function assertIs(condition, message, error) {
 		assert(() => condition(value), message, error);
 	};
 }
+/**
+* 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
+*/
+function assertProperty(path, condition, message, error) {
+	return (value) => {
+		assert(() => {
+			const result = hasValueResult(value, path, false);
+			return result.ok && condition(result.value);
+		}, message, error);
+	};
+}
 const MESSAGE_VALUE_DEFINED = "Expected value to be defined";
 //#endregion
-export { assert, assertCondition, assertDefined, assertInstanceOf, assertIs };
+export { assert, assertCondition, assertDefined, assertInstanceOf, assertIs, assertProperty };

package/dist/function/memoize.d.mts

@@ -1,6 +1,9 @@
 import { GenericCallback } from "../models.mjs";
 
 //#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;
   /**

package/dist/function/memoize.mjs

@@ -2,6 +2,9 @@ import { isPlainObject } from "../internal/is.mjs";
 import { getString, join } from "../internal/string.mjs";
 import { SizedMap } from "../sized/map.mjs";
 //#region src/function/memoize.ts
+/**
+* A memoized function, caching and retrieving results based on the its parameters _(or a custom cache key)_
+*/
 var Memoized = class {
 	#state;
 	/**

package/dist/function/retry.d.mts

@@ -1,6 +1,9 @@
 import { GenericAsyncCallback, GenericCallback } from "../models.mjs";
 
 //#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);

package/dist/function/retry.mjs

@@ -1,6 +1,9 @@
 import { isPlainObject } from "../internal/is.mjs";
 import { TIMER_WAIT, getTimer } from "../internal/function/timer.mjs";
 //#region src/function/retry.ts
+/**
+* An error thrown when a retry fails
+*/
 var RetryError = class extends Error {
 	constructor(message, original) {
 		super(message);

package/dist/function/work.mjs

@@ -1,5 +1,5 @@
-import { assert } from "./assert.mjs";
 import { isError, isOk } from "../internal/result.mjs";
+import { assert } from "./assert.mjs";
 //#region src/function/work.ts
 function asyncFlow(...fns) {
 	assertFlowFunctions(fns);