@oscarpalmer/atoms 0.202.0 → 0.203.0

package/dist/internal/abort.d.mts

@@ -1,10 +1,9 @@
 import { GenericCallback } from "../models.mjs";
 //#region src/internal/abort.d.ts
-type Aborter = {
+export type Aborter = {
   callback: GenericCallback;
   signal: AbortSignal;
   cancel: () => void;
 };
-declare function createAborter(value: unknown, onAbort: () => void): Aborter | undefined;
-//#endregion
-export { Aborter, createAborter };
+export declare function createAborter(value: unknown, onAbort: () => void): Aborter | undefined;
+//#endregion

package/dist/internal/array/callbacks.d.mts

@@ -1,11 +1,10 @@
 import { GenericCallback } from "../../models.mjs";
 //#region src/internal/array/callbacks.d.ts
-type Callbacks = {
+export type Callbacks = {
   bool?: GenericCallback;
   keyed?: GenericCallback;
   value?: GenericCallback;
 };
-declare function getArrayCallback(value: unknown): GenericCallback | undefined;
-declare function getArrayCallbacks(bool?: unknown, key?: unknown, value?: unknown): Callbacks | undefined;
-//#endregion
-export { Callbacks, getArrayCallback, getArrayCallbacks };
+export declare function getArrayCallback(value: unknown): GenericCallback | undefined;
+export declare function getArrayCallbacks(bool?: unknown, key?: unknown, value?: unknown): Callbacks | undefined;
+//#endregion

package/dist/internal/array/chunk.d.mts

@@ -11,6 +11,5 @@
  * chunk([1, 2, 3, 4, 5], 2); // => [[1, 2], [3, 4], [5]]
  * ```
  */
-declare function chunk<Item>(array: Item[], size?: number): Item[][];
-//#endregion
-export { chunk };
+export declare function chunk<Item>(array: Item[], size?: number): Item[][];
+//#endregion

package/dist/internal/array/compact.d.mts

@@ -11,7 +11,7 @@
  * compact([0, 1, '', 'hello', false, true, null, undefined]); // => [1, 'hello', true]
  * ```
  */
-declare function compact<Item>(array: Item[], strict: true): Array<Exclude<Item, 0 | '' | false | null | undefined>>;
+export declare function compact<Item>(array: Item[], strict: true): Array<Exclude<Item, 0 | '' | false | null | undefined>>;
 /**
  * Compact an array _(removing all `null` and `undefined` values)_
  *
@@ -23,6 +23,5 @@ declare function compact<Item>(array: Item[], strict: true): Array<Exclude<Item,
  * compact([0, 1, '', 'hello', false, true, null, undefined]); // => [0, 1, '', 'hello', false, true]
  * ```
  */
-declare function compact<Item>(array: Item[]): Array<Exclude<Item, null | undefined>>;
-//#endregion
-export { compact };
+export declare function compact<Item>(array: Item[]): Array<Exclude<Item, null | undefined>>;
+//#endregion

package/dist/internal/array/find.d.mts

@@ -14,14 +14,13 @@ type Parameters = {
   key?: unknown;
   value?: unknown;
 };
-declare function createFindParameters(original: unknown[]): Parameters;
-declare function findValue(type: Exclude<FindValueType, 'item'>, array: unknown[], parameters: unknown[], reversed: boolean): number;
-declare function findValue(type: Exclude<FindValueType, 'index'>, array: unknown[], parameters: unknown[], reversed: boolean): unknown;
-declare function findAbsoluteValueOrDefault(array: unknown[], parameters: unknown[], defaultValue: unknown, useDefaultValue: boolean, reversed: boolean): unknown;
-declare function findValues(type: FindValuesType, array: unknown[], parameters: unknown[], mapper?: FindMapper): FindValuesResult;
-declare const FIND_VALUE_INDEX = "index";
-declare const FIND_VALUE_ITEM = "item";
-declare const FIND_VALUES_ALL: FindValuesType;
-declare const FIND_VALUES_UNIQUE: FindValuesType;
-//#endregion
-export { FIND_VALUES_ALL, FIND_VALUES_UNIQUE, FIND_VALUE_INDEX, FIND_VALUE_ITEM, createFindParameters, findAbsoluteValueOrDefault, findValue, findValues };
+export declare function createFindParameters(original: unknown[]): Parameters;
+export declare function findValue(type: Exclude<FindValueType, 'item'>, array: unknown[], parameters: unknown[], reversed: boolean): number;
+export declare function findValue(type: Exclude<FindValueType, 'index'>, array: unknown[], parameters: unknown[], reversed: boolean): unknown;
+export declare function findAbsoluteValueOrDefault(array: unknown[], parameters: unknown[], defaultValue: unknown, useDefaultValue: boolean, reversed: boolean): unknown;
+export declare function findValues(type: FindValuesType, array: unknown[], parameters: unknown[], mapper?: FindMapper): FindValuesResult;
+export declare const FIND_VALUE_INDEX = "index";
+export declare const FIND_VALUE_ITEM = "item";
+export declare const FIND_VALUES_ALL: FindValuesType;
+export declare const FIND_VALUES_UNIQUE: FindValuesType;
+//#endregion

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

@@ -12,7 +12,7 @@ import { NumericalKeys, PlainObject } from "../../models.mjs";
  * getArray({a: 'a', b: 'b', c: 'c', d: 'd'}, true); // => []
  * ```
  */
-declare function getArray<Value extends PlainObject>(value: Value, indiced: true): Value[NumericalKeys<Value>][];
+export declare function getArray<Value extends PlainObject>(value: Value, indiced: true): Value[NumericalKeys<Value>][];
 /**
  * Get an array from a map
  *
@@ -26,7 +26,7 @@ declare function getArray<Value extends PlainObject>(value: Value, indiced: true
  * ); // => [['a', 1], ['b', 2], ['c', 3]]
  * ```
  */
-declare function getArray<Key, Value>(map: Map<Key, Value>): [Key, Value][];
+export declare function getArray<Key, Value>(map: Map<Key, Value>): [Key, Value][];
 /**
  * Get an array from an object
  *
@@ -39,7 +39,7 @@ declare function getArray<Key, Value>(map: Map<Key, Value>): [Key, Value][];
  * getArray({a: 'a', b: 'b', c: 'c', d: 'd'}); // => ['a', 'b', 'c', 'd']
  * ```
  */
-declare function getArray<Value extends PlainObject>(value: Value): [keyof Value, Value[keyof Value]][];
+export declare function getArray<Value extends PlainObject>(value: Value): [keyof Value, Value[keyof Value]][];
 /**
  * Get an array from a set
  *
@@ -51,7 +51,7 @@ declare function getArray<Value extends PlainObject>(value: Value): [keyof Value
  * getArray(new Set([123, 456, 789])); // => [123, 456, 789]
  * ```
  */
-declare function getArray<Value>(set: Set<Value>): Value[];
+export declare function getArray<Value>(set: Set<Value>): Value[];
 /**
  * Get an array from a value
  *
@@ -63,7 +63,7 @@ declare function getArray<Value>(set: Set<Value>): Value[];
  * getArray([123]); // => [123]
  * ```
  */
-declare function getArray<Item>(value: Item[]): Item[];
+export declare function getArray<Item>(value: Item[]): Item[];
 /**
  * Get an array from an unknown value
  *
@@ -75,6 +75,5 @@ declare function getArray<Item>(value: Item[]): Item[];
  * getArray(123); // => [123]
  * ```
  */
-declare function getArray<Value>(value: Value): Value[];
-//#endregion
-export { getArray };
+export declare function getArray<Value>(value: Value): Value[];
+//#endregion

package/dist/internal/array/group.d.mts

@@ -1,5 +1,4 @@
 import { Key } from "../../models.mjs";
 //#region src/internal/array/group.d.ts
-declare function groupValues(array: unknown[], key: unknown, value: unknown, arrays: boolean): Record<Key, unknown>;
-//#endregion
-export { groupValues };
+export declare function groupValues(array: unknown[], key: unknown, value: unknown, arrays: boolean): Record<Key, unknown>;
+//#endregion

package/dist/internal/array/index-of.d.mts

@@ -17,7 +17,7 @@ import { PlainObject } from "../../models.mjs";
  * ); // => 1
  * ```
  */
-declare function indexOf<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): number;
+export declare function indexOf<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): number;
 /**
  * Get the index of the first matching item by key
  *
@@ -35,7 +35,7 @@ declare function indexOf<Item, Callback extends (item: Item, index: number, arra
  * ); // => 1
  * ```
  */
-declare function indexOf<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, value: Item[ItemKey]): number;
+export declare function indexOf<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, value: Item[ItemKey]): number;
 /**
  * Get the index of the first item matching the filter
  *
@@ -51,7 +51,7 @@ declare function indexOf<Item extends PlainObject, ItemKey extends keyof Item>(a
  * ); // => 1
  * ```
  */
-declare function indexOf<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): number;
+export declare function indexOf<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): number;
 /**
  * Get the index of the first item matching the given item
  *
@@ -64,8 +64,8 @@ declare function indexOf<Item>(array: Item[], filter: (item: Item, index: number
  * indexOf([1, 2, 3, 4, 5], 3); // => 2
  * ```
  */
-declare function indexOf<Item>(array: Item[], item: Item): number;
-declare namespace indexOf {
+export declare function indexOf<Item>(array: Item[], item: Item): number;
+export declare namespace indexOf {
   var last: typeof lastIndexOf;
 }
 /**
@@ -87,7 +87,7 @@ declare namespace indexOf {
  * ); // => 3
  * ```
  */
-declare function lastIndexOf<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): number;
+export declare function lastIndexOf<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): number;
 /**
  * Get the index of the last matching item by key
  *
@@ -107,7 +107,7 @@ declare function lastIndexOf<Item, Callback extends (item: Item, index: number,
  * ); // => 3
  * ```
  */
-declare function lastIndexOf<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, value: Item[ItemKey]): number;
+export declare function lastIndexOf<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, value: Item[ItemKey]): number;
 /**
  * Get the index of the last item matching the filter
  *
@@ -125,7 +125,7 @@ declare function lastIndexOf<Item extends PlainObject, ItemKey extends keyof Ite
  * ); // => 3
  * ```
  */
-declare function lastIndexOf<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): number;
+export declare function lastIndexOf<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): number;
 /**
  * Get the index of the last item matching the given item
  *
@@ -140,6 +140,5 @@ declare function lastIndexOf<Item>(array: Item[], filter: (item: Item, index: nu
  * lastIndexOf([1, 2, 3, 2, 1], 2); // => 3
  * ```
  */
-declare function lastIndexOf<Item>(array: Item[], item: Item): number;
-//#endregion
-export { indexOf, lastIndexOf };
+export declare function lastIndexOf<Item>(array: Item[], item: Item): number;
+//#endregion

package/dist/internal/array/insert.d.mts

@@ -1,8 +1,7 @@
 //#region src/internal/array/insert.d.ts
 type InsertType = 'insert' | 'push' | 'splice';
-declare function insertValues(type: InsertType, array: unknown, items: unknown, start: unknown, deleteCount: number): unknown;
-declare const INSERT_TYPE_INSERT: InsertType;
-declare const INSERT_TYPE_PUSH: InsertType;
-declare const INSERT_TYPE_SPLICE: InsertType;
-//#endregion
-export { INSERT_TYPE_INSERT, INSERT_TYPE_PUSH, INSERT_TYPE_SPLICE, insertValues };
+export declare function insertValues(type: InsertType, array: unknown, items: unknown, start: unknown, deleteCount: number): unknown;
+export declare const INSERT_TYPE_INSERT: InsertType;
+export declare const INSERT_TYPE_PUSH: InsertType;
+export declare const INSERT_TYPE_SPLICE: InsertType;
+//#endregion

package/dist/internal/array/match.d.mts

@@ -3,7 +3,7 @@ import { PlainObject } from "../../models.mjs";
 /**
  * Comparison of an array within another array
  */
-type ArrayComparison = 'end' | 'inside' | 'invalid' | 'outside' | 'same' | 'start';
+export type ArrayComparison = 'end' | 'inside' | 'invalid' | 'outside' | 'same' | 'start';
 /**
  * Is the needle array at the end of the haystack array?
  *
@@ -21,7 +21,7 @@ type ArrayComparison = 'end' | 'inside' | 'invalid' | 'outside' | 'same' | 'star
  * ); // => true
  * ```
  */
-declare function endsWithArray<Item>(haystack: Item[], needle: Item[], callback: (item: Item, index: number, array: Item[]) => unknown): boolean;
+export declare function endsWithArray<Item>(haystack: Item[], needle: Item[], callback: (item: Item, index: number, array: Item[]) => unknown): boolean;
 /**
  * Is the needle array at the end of the haystack array?
  *
@@ -39,7 +39,7 @@ declare function endsWithArray<Item>(haystack: Item[], needle: Item[], callback:
  * ); // => true
  * ```
  */
-declare function endsWithArray<Item extends PlainObject>(haystack: Item[], needle: Item[], key: keyof Item): boolean;
+export declare function endsWithArray<Item extends PlainObject>(haystack: Item[], needle: Item[], key: keyof Item): boolean;
 /**
  * Is the needle array at the end of the haystack array?
  *
@@ -52,7 +52,7 @@ declare function endsWithArray<Item extends PlainObject>(haystack: Item[], needl
  * endsWithArray([1, 2, 3], [2, 3]); // => true
  * ```
  */
-declare function endsWithArray<Item>(haystack: Item[], needle: Item[]): boolean;
+export declare function endsWithArray<Item>(haystack: Item[], needle: Item[]): boolean;
 /**
  * Get the position of an array within another array
  *
@@ -70,7 +70,7 @@ declare function endsWithArray<Item>(haystack: Item[], needle: Item[]): boolean;
  * ); // => 'end'
  * ```
  */
-declare function getArrayComparison<Item>(haystack: Item[], needle: Item[], callback: (item: Item, index: number, array: Item[]) => unknown): ArrayComparison;
+export 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
  *
@@ -88,7 +88,7 @@ declare function getArrayComparison<Item>(haystack: Item[], needle: Item[], call
  * ); // => 'end'
  * ```
  */
-declare function getArrayComparison<Item extends PlainObject>(haystack: Item[], needle: Item[], key: keyof Item): ArrayComparison;
+export declare function getArrayComparison<Item extends PlainObject>(haystack: Item[], needle: Item[], key: keyof Item): ArrayComparison;
 /**
  * Get the position of an array within another array
  *
@@ -101,7 +101,7 @@ declare function getArrayComparison<Item extends PlainObject>(haystack: Item[],
  * getArrayComparison([1, 2, 3], [2, 3]); // => 'end'
  * ```
  */
-declare function getArrayComparison<Item>(haystack: Item[], needle: Item[]): ArrayComparison;
+export declare function getArrayComparison<Item>(haystack: Item[], needle: Item[]): ArrayComparison;
 /**
  * Does the needle array exist within the haystack array?
  *
@@ -119,7 +119,7 @@ declare function getArrayComparison<Item>(haystack: Item[], needle: Item[]): Arr
  * ); // => true
  * ```
  */
-declare function includesArray<Item>(haystack: Item[], needle: Item[], callback: (item: Item, index: number, array: Item[]) => unknown): boolean;
+export declare function includesArray<Item>(haystack: Item[], needle: Item[], callback: (item: Item, index: number, array: Item[]) => unknown): boolean;
 /**
  * Does the needle array exist within the haystack array?
  *
@@ -137,7 +137,7 @@ declare function includesArray<Item>(haystack: Item[], needle: Item[], callback:
  * ); // => true
  * ```
  */
-declare function includesArray<Item extends PlainObject>(haystack: Item[], needle: Item[], key: keyof Item): boolean;
+export declare function includesArray<Item extends PlainObject>(haystack: Item[], needle: Item[], key: keyof Item): boolean;
 /**
  * Does the needle array exist within the haystack array?
  *
@@ -150,7 +150,7 @@ declare function includesArray<Item extends PlainObject>(haystack: Item[], needl
  * includesArray([1, 2, 3], [2, 3]); // => true
  * ```
  */
-declare function includesArray<Item>(haystack: Item[], needle: Item[]): boolean;
+export declare function includesArray<Item>(haystack: Item[], needle: Item[]): boolean;
 /**
  * Get the index of an array within another array
  *
@@ -168,7 +168,7 @@ declare function includesArray<Item>(haystack: Item[], needle: Item[]): boolean;
  * ); // => 1
  * ```
  */
-declare function indexOfArray<Item>(haystack: Item[], needle: Item[], callback: (item: Item, index: number, array: Item[]) => unknown): number;
+export declare function indexOfArray<Item>(haystack: Item[], needle: Item[], callback: (item: Item, index: number, array: Item[]) => unknown): number;
 /**
  * Get the index of an array within another array
  *
@@ -186,7 +186,7 @@ declare function indexOfArray<Item>(haystack: Item[], needle: Item[], callback:
  * ); // => 1
  * ```
  */
-declare function indexOfArray<Item extends PlainObject>(haystack: Item[], needle: Item[], key: keyof Item): number;
+export declare function indexOfArray<Item extends PlainObject>(haystack: Item[], needle: Item[], key: keyof Item): number;
 /**
  * Get the index of an array within another array
  *
@@ -199,7 +199,7 @@ declare function indexOfArray<Item extends PlainObject>(haystack: Item[], needle
  * indexOfArray([1, 2, 3], [2, 3]); // => 1
  * ```
  */
-declare function indexOfArray<Item>(haystack: Item[], needle: Item[]): number;
+export declare function indexOfArray<Item>(haystack: Item[], needle: Item[]): number;
 /**
  * Is the needle array at the start of the haystack array?
  *
@@ -217,7 +217,7 @@ declare function indexOfArray<Item>(haystack: Item[], needle: Item[]): number;
  * ); // => true
  * ```
  */
-declare function startsWithArray<Item>(haystack: Item[], needle: Item[], callback: (item: Item, index: number, array: Item[]) => unknown): boolean;
+export declare function startsWithArray<Item>(haystack: Item[], needle: Item[], callback: (item: Item, index: number, array: Item[]) => unknown): boolean;
 /**
  * Is the needle array at the start of the haystack array?
  *
@@ -235,7 +235,7 @@ declare function startsWithArray<Item>(haystack: Item[], needle: Item[], callbac
  * ); // => true
  * ```
  */
-declare function startsWithArray<Item extends PlainObject>(haystack: Item[], needle: Item[], key: keyof Item): boolean;
+export declare function startsWithArray<Item extends PlainObject>(haystack: Item[], needle: Item[], key: keyof Item): boolean;
 /**
  * Is the needle array at the start of the haystack array?
  *
@@ -248,6 +248,5 @@ declare function startsWithArray<Item extends PlainObject>(haystack: Item[], nee
  * startsWithArray([1, 2, 3], [1, 2]); // => true
  * ```
  */
-declare function startsWithArray<Item>(haystack: Item[], needle: Item[]): boolean;
-//#endregion
-export { ArrayComparison, endsWithArray, getArrayComparison, includesArray, indexOfArray, startsWithArray };
+export declare function startsWithArray<Item>(haystack: Item[], needle: Item[]): boolean;
+//#endregion

package/dist/internal/array/overlap.d.mts

@@ -8,6 +8,5 @@ type OverlapResult = {
   second: OverlapItem;
   overlap: boolean;
 };
-declare function arraysOverlap(first: OverlapItem, second: OverlapItem): OverlapResult;
-//#endregion
-export { arraysOverlap };
+export declare function arraysOverlap(first: OverlapItem, second: OverlapItem): OverlapResult;
+//#endregion

package/dist/internal/array/sets.d.mts

@@ -1,8 +1,7 @@
 //#region src/internal/array/sets.d.ts
 type CompareSetsType = 'difference' | 'intersection' | 'union';
-declare function compareSets(type: CompareSetsType, first: unknown[], second: unknown[], key?: unknown): unknown[];
-declare const SETS_COMPARE_DIFFERENCE: CompareSetsType;
-declare const SETS_COMPARE_INTERSECTION: CompareSetsType;
-declare const SETS_COMPARE_UNION: CompareSetsType;
-//#endregion
-export { SETS_COMPARE_DIFFERENCE, SETS_COMPARE_INTERSECTION, SETS_COMPARE_UNION, compareSets };
+export declare function compareSets(type: CompareSetsType, first: unknown[], second: unknown[], key?: unknown): unknown[];
+export declare const SETS_COMPARE_DIFFERENCE: CompareSetsType;
+export declare const SETS_COMPARE_INTERSECTION: CompareSetsType;
+export declare const SETS_COMPARE_UNION: CompareSetsType;
+//#endregion

package/dist/internal/array/shuffle.d.mts

@@ -5,6 +5,5 @@
  * @param array Original array
  * @returns Shuffled array
  */
-declare function shuffle<Item>(array: Item[]): Item[];
-//#endregion
-export { shuffle };
+export declare function shuffle<Item>(array: Item[]): Item[];
+//#endregion

package/dist/internal/array/update.d.mts

@@ -1,4 +1,3 @@
 //#region src/internal/array/update.d.ts
-declare function updateInArray(array: unknown[], items: unknown[], key: unknown, replace: boolean): unknown[];
-//#endregion
-export { updateInArray };
+export declare function updateInArray(array: unknown[], items: unknown[], key: unknown, replace: boolean): unknown[];
+//#endregion

package/dist/internal/defaults.d.mts

@@ -1,5 +1,4 @@
 //#region src/internal/defaults.d.ts
-declare function getBooleanOrDefault(value: unknown, defaultValue: boolean): boolean;
-declare function getNumberOrDefault(value: unknown, defaultValue: number, minimum?: number): number;
-//#endregion
-export { getBooleanOrDefault, getNumberOrDefault };
+export declare function getBooleanOrDefault(value: unknown, defaultValue: boolean): boolean;
+export declare function getNumberOrDefault(value: unknown, defaultValue: number, minimum?: number): number;
+//#endregion

package/dist/internal/function/assert.d.mts

@@ -3,11 +3,11 @@ import { Constructor, NestedKeys, NestedValue, PlainObject } from "../../models.
 /**
  * Asserter for a property of a value
  */
-type AssertProperty<Value extends PlainObject, Path extends NestedKeys<Value>, Asserted extends NestedPick<Value, Path> = NestedPick<Value, Path>> = Asserter<Asserted>;
+export 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;
+export 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
@@ -16,8 +16,8 @@ type NestedPick<Value, Path extends string> = Value extends PlainObject ? Path e
  * @param message Error message
  * @param error Error constructor _(defaults to `Error`)_
  */
-declare function assert<Condition extends () => boolean>(condition: Condition, message: string, error?: ErrorConstructor): asserts condition;
-declare namespace assert {
+export declare function assert<Condition extends () => boolean>(condition: Condition, message: string, error?: ErrorConstructor): asserts condition;
+export declare namespace assert {
   var condition: typeof assertCondition;
   var defined: typeof assertDefined;
   var instanceOf: typeof assertInstanceOf;
@@ -34,7 +34,7 @@ declare namespace assert {
  * @param error Error constructor _(defaults to `Error`)_
  * @returns _Asserter_
  */
-declare function assertCondition<Value>(condition: (value: unknown) => boolean, message: string, error?: ErrorConstructor): Asserter<Value>;
+export 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
  *
@@ -44,7 +44,7 @@ declare function assertCondition<Value>(condition: (value: unknown) => boolean,
  * @param message Error message
  * @param error Error constructor _(defaults to `Error`)_
  */
-declare function assertDefined<Value>(value: unknown, message?: string, error?: ErrorConstructor): asserts value is Exclude<Value, null | undefined>;
+export 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
  *
@@ -55,7 +55,7 @@ declare function assertDefined<Value>(value: unknown, message?: string, error?:
  * @param error Error constructor _(defaults to `Error`)_
  * @returns _Asserter_
  */
-declare function assertInstanceOf<Value>(constructor: Constructor<Value>, message: string, error?: ErrorConstructor): Asserter<Value>;
+export declare function assertInstanceOf<Value>(constructor: Constructor<Value>, message: string, error?: ErrorConstructor): Asserter<Value>;
 /**
  * Creates an _Asserter_ that asserts a value is of a specific type, throwing an error if it is not
  *
@@ -66,7 +66,7 @@ declare function assertInstanceOf<Value>(constructor: Constructor<Value>, messag
  * @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>;
+export 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
  *
@@ -78,6 +78,5 @@ declare function assertIs<Value>(condition: (value: unknown) => value is Value,
  * @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 { AssertProperty, Asserter, assert, assertCondition, assertDefined, assertInstanceOf, assertIs, assertProperty };
+export 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

package/dist/internal/function/limit.d.mts

@@ -0,0 +1,41 @@
+import { GenericAsyncCallback, GenericCallback } from "../../models.mjs";
+//#region src/internal/function/limit.d.ts
+/**
+ * An asynchronous function that can be cancelled
+ */
+export type AsyncLimiter<Callback extends GenericAsyncCallback> = {
+  /**
+   * Cancel the function
+   */
+  cancel(): void;
+  /**
+   * Call the function
+   *
+   * @param parameters Function parameters
+   * @returns Function result
+   */
+  run(...parameters: Parameters<Callback>): Promise<ReturnType<Callback>>;
+};
+/**
+ * A function that can be cancelled
+ */
+export type Limiter<Callback extends GenericCallback> = {
+  /**
+   * Cancel the function
+   */
+  cancel(): void;
+  /**
+   * Call the function
+   *
+   * @param parameters Function parameters
+   * @returns Function result
+   */
+  run(...parameters: Parameters<Callback>): ReturnType<Callback>;
+};
+type LimiterType = 'debounce' | 'throttle' | 'wait';
+export declare function getAsyncLimiter<Callback extends GenericAsyncCallback | GenericCallback>(type: LimiterType, callback: Callback, time?: number): AsyncLimiter<Callback>;
+export declare function getLimiter<Callback extends GenericCallback>(type: LimiterType, callback: Callback, time?: number): Limiter<Callback>;
+export declare const LIMITER_DEBOUNCE: LimiterType;
+export declare const LIMITER_THROTTLE: LimiterType;
+export declare const LIMITER_WAIT: LimiterType;
+//#endregion

package/dist/internal/function/limit.mjs

@@ -0,0 +1,110 @@
+import { getNumberOrDefault } from "../defaults.mjs";
+//#region src/internal/function/limit.ts
+const LIMITER_NAME_ASYNC = "asyncLimiter";
+const LIMITER_NAME_SYNC = "limiter";
+const LIMITER_PROPERTY = "$limiter";
+function AsyncLimiter(type, callback, time) {
+	Object.defineProperty(this, LIMITER_SYMBOL, { value: {
+		callback,
+		type,
+		interval: getNumberOrDefault(time, 0),
+		parameters: [],
+		throttle: type === LIMITER_THROTTLE
+	} });
+}
+Object.defineProperties(AsyncLimiter.prototype, {
+	[LIMITER_PROPERTY]: { value: LIMITER_NAME_ASYNC },
+	cancel: { value: cancelAsyncLimiter },
+	run: { value: runAsyncLimiter }
+});
+function Limiter(type, callback, time) {
+	Object.defineProperty(this, LIMITER_SYMBOL, { value: {
+		callback,
+		type,
+		interval: getNumberOrDefault(time, 0),
+		parameters: [],
+		throttle: type === LIMITER_THROTTLE
+	} });
+}
+Object.defineProperties(Limiter.prototype, {
+	[LIMITER_PROPERTY]: { value: LIMITER_NAME_SYNC },
+	cancel: { value: cancelLimiter },
+	run: { value: runLimiter }
+});
+function cancelAsyncLimiter() {
+	const state = this[LIMITER_SYMBOL];
+	if (state.timer != null) clearTimer(state.timer);
+	if (state.last != null && !state.last.running) {
+		state.last.reject();
+		state.last = void 0;
+	}
+}
+function cancelLimiter() {
+	const { timer } = this[LIMITER_SYMBOL];
+	if (timer != null) clearTimer(timer);
+}
+function getAsyncLimiter(type, callback, time) {
+	return new AsyncLimiter(type, callback, time);
+}
+function getLimiter(type, callback, time) {
+	return new Limiter(type, callback, time);
+}
+async function handleAsyncLimiter(state, item) {
+	const now = performance.now();
+	state.start ??= now;
+	if (state.interval === 0 || now - state.start >= state.interval - LIMITER_OFFSET) {
+		state.start = state.throttle ? now : void 0;
+		item.running = true;
+		try {
+			let result = state.callback(...item.parameters);
+			if (result instanceof Promise) result = await result;
+			item.resolve(result);
+		} catch (error) {
+			item.reject(error);
+		} finally {
+			item.running = false;
+		}
+	} else state.timer = startTimer(() => handleAsyncLimiter(state, item));
+}
+function handleLimiter(state) {
+	const now = performance.now();
+	state.start ??= now;
+	if (state.interval === 0 || now - state.start >= state.interval - LIMITER_OFFSET) {
+		state.start = state.throttle ? now : void 0;
+		state.callback(...state.parameters);
+	} else state.timer = startTimer(() => handleLimiter(state));
+}
+function runAsyncLimiter() {
+	const state = this[LIMITER_SYMBOL];
+	cancelAsyncLimiter.call(this);
+	const next = {
+		parameters: state.parameters,
+		running: false
+	};
+	next.promise = new Promise((resolve, reject) => {
+		next.reject = reject;
+		next.resolve = resolve;
+	});
+	state.last = next;
+	if (state.throttle) handleAsyncLimiter(state, next);
+	else state.timer = startTimer(() => handleAsyncLimiter(state, next));
+	return next.promise;
+}
+function runLimiter(...parameters) {
+	const state = this[LIMITER_SYMBOL];
+	cancelLimiter.call(this);
+	state.parameters = parameters;
+	if (state.throttle) handleLimiter(state);
+	else state.timer = startTimer(() => handleLimiter(state));
+}
+const LIMITER_DEBOUNCE = "debounce";
+const LIMITER_OFFSET = 5;
+const LIMITER_SYMBOL = Symbol("limiter");
+const LIMITER_THROTTLE = "throttle";
+const LIMITER_WAIT = "wait";
+// istanbul ignore next
+const clearTimer = typeof cancelAnimationFrame === "function" ? cancelAnimationFrame : clearTimeout;
+// istanbul ignore next
+const startTimer = typeof requestAnimationFrame === "function" ? requestAnimationFrame : setTimeout;
+//#endregion
+export { LIMITER_DEBOUNCE, LIMITER_THROTTLE, LIMITER_WAIT, getAsyncLimiter, getLimiter };