@oscarpalmer/atoms 0.164.0 → 0.165.1

package/dist/array/index.d.mts

@@ -1,6 +1,5 @@
 import { difference } from "./difference.mjs";
 import { exists } from "./exists.mjs";
-import { filter } from "./filter.mjs";
 import { find } from "./find.mjs";
 import { flatten } from "./flatten.mjs";
 import { range, times } from "./from.mjs";
@@ -11,7 +10,6 @@ import { indexOf } from "../internal/array/index-of.mjs";
 import { shuffle } from "../internal/array/shuffle.mjs";
 import { insert } from "./insert.mjs";
 import { intersection } from "./intersection.mjs";
-import { move } from "./move.mjs";
 import { partition } from "./partition.mjs";
 import { ArrayPosition, endsWithArray, getArrayPosition, includesArray, indexOfArray, startsWithArray } from "./position.mjs";
 import { push } from "./push.mjs";
@@ -19,9 +17,8 @@ import { select } from "./select.mjs";
 import { drop, slice, take } from "./slice.mjs";
 import { sort } from "./sort.mjs";
 import { splice } from "./splice.mjs";
-import { swap } from "./swap.mjs";
 import { toSet } from "./to-set.mjs";
 import { toggle } from "./toggle.mjs";
 import { union } from "./union.mjs";
 import { update } from "./update.mjs";
-export { ArrayPosition, chunk, compact, difference, drop, endsWithArray, exists, filter, find, flatten, getArray, getArrayPosition, includesArray, indexOf, indexOfArray, insert, intersection, move, partition, push, range, select, shuffle, slice, sort, splice, startsWithArray, swap, take, times, toSet, toggle, union, update };
+export { ArrayPosition, chunk, compact, difference, drop, endsWithArray, exists, find, flatten, getArray, getArrayPosition, includesArray, indexOf, indexOfArray, insert, intersection, partition, push, range, select, shuffle, slice, sort, splice, startsWithArray, take, times, toSet, toggle, union, update };

package/dist/array/index.mjs

@@ -4,24 +4,21 @@ import { indexOf } from "../internal/array/index-of.mjs";
 import { shuffle } from "../internal/array/shuffle.mjs";
 import { difference } from "./difference.mjs";
 import { exists } from "./exists.mjs";
-import { filter } from "./filter.mjs";
 import { find } from "./find.mjs";
 import { flatten } from "./flatten.mjs";
 import { range, times } from "./from.mjs";
 import { getArray } from "./get.mjs";
 import { insert } from "./insert.mjs";
 import { intersection } from "./intersection.mjs";
-import { endsWithArray, getArrayPosition, includesArray, indexOfArray, startsWithArray } from "./position.mjs";
-import { move } from "./move.mjs";
 import { partition } from "./partition.mjs";
+import { endsWithArray, getArrayPosition, includesArray, indexOfArray, startsWithArray } from "./position.mjs";
 import { push } from "./push.mjs";
 import { select } from "./select.mjs";
 import { drop, slice, take } from "./slice.mjs";
 import { sort } from "./sort.mjs";
 import { splice } from "./splice.mjs";
-import { swap } from "./swap.mjs";
 import { toSet } from "./to-set.mjs";
 import { toggle } from "./toggle.mjs";
 import { union } from "./union.mjs";
 import { update } from "./update.mjs";
-export { chunk, compact, difference, drop, endsWithArray, exists, filter, find, flatten, getArray, getArrayPosition, includesArray, indexOf, indexOfArray, insert, intersection, move, partition, push, range, select, shuffle, slice, sort, splice, startsWithArray, swap, take, times, toSet, toggle, union, update };
+export { chunk, compact, difference, drop, endsWithArray, exists, find, flatten, getArray, getArrayPosition, includesArray, indexOf, indexOfArray, insert, intersection, partition, push, range, select, shuffle, slice, sort, splice, startsWithArray, take, times, toSet, toggle, union, update };

package/dist/array/move.mjs

@@ -1,5 +1,5 @@
-import { arraysOverlap } from "../internal/array/overlap.mjs";
 import { indexOfArray } from "./position.mjs";
+import { arraysOverlap } from "../internal/array/overlap.mjs";
 //#region src/array/move.ts
 function move(array, from, to, key) {
 	if (!Array.isArray(array)) return [];

package/dist/array/swap.mjs

@@ -1,7 +1,7 @@
 import { getArrayCallback } from "../internal/array/callbacks.mjs";
 import { indexOf } from "../internal/array/index-of.mjs";
-import { arraysOverlap } from "../internal/array/overlap.mjs";
 import { indexOfArray } from "./position.mjs";
+import { arraysOverlap } from "../internal/array/overlap.mjs";
 //#region src/array/swap.ts
 function swap(array, first, second, third) {
 	if (!Array.isArray(array)) return [];

package/dist/function/index.d.mts

@@ -1,7 +1,6 @@
 import { CancelableCallback, GenericCallback } from "../models.mjs";
 import { noop } from "../internal/function/misc.mjs";
 import { Memoized, MemoizedOptions, memoize } from "./memoize.mjs";
-import { once } from "./once.mjs";
 
 //#region src/function/index.d.ts
 /**
@@ -21,4 +20,4 @@ declare function debounce<Callback extends GenericCallback>(callback: Callback,
  */
 declare function throttle<Callback extends GenericCallback>(callback: Callback, time?: number): CancelableCallback<Callback>;
 //#endregion
-export { type Memoized, type MemoizedOptions, debounce, memoize, noop, once, throttle };
+export { type Memoized, type MemoizedOptions, debounce, memoize, noop, throttle };

package/dist/function/index.mjs

@@ -1,7 +1,6 @@
 import { noop } from "../internal/function/misc.mjs";
 import { TIMER_DEBOUNCE, TIMER_THROTTLE, getTimer } from "../internal/function/timer.mjs";
 import { memoize } from "./memoize.mjs";
-import { once } from "./once.mjs";
 //#region src/function/index.ts
 /**
 * Debounce a function, ensuring it is only called after `time` milliseconds have passed
@@ -24,4 +23,4 @@ function throttle(callback, time) {
 	return getTimer(TIMER_THROTTLE, callback, time);
 }
 //#endregion
-export { debounce, memoize, noop, once, throttle };
+export { debounce, memoize, noop, throttle };

package/dist/index.d.mts

@@ -135,6 +135,45 @@ type ToString<Value> = Value extends string | number ? `${Value}` : never;
  */
 type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
 //#endregion
+//#region src/array/filter.d.ts
+/**
+ * Get a filtered array of items
+ * @param array Array to search in
+ * @param callback Callback to get an item's value for matching
+ * @param value Value to match against
+ * @returns Filtered array of items
+ */
+declare function filter<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): Item[];
+/**
+ * Get a filtered array of items
+ * @param array Array to search in
+ * @param key Key to get an item's value for matching
+ * @param value Value to match against
+ * @returns Filtered array of items
+ */
+declare function filter<Item extends PlainObject, Key extends keyof Item>(array: Item[], key: Key, value: Item[Key]): Item[];
+/**
+ * Get a filtered array of items matching the filter
+ * @param array Array to search in
+ * @param filter Filter callback to match items
+ * @returns Filtered array of items
+ */
+declare function filter<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): Item[];
+/**
+ * Get a filtered array of items matching the given item
+ * @param array Array to search in
+ * @param item Item to match against
+ * @returns Filtered array of items
+ */
+declare function filter<Item>(array: Item[], item: Item): Item[];
+declare namespace filter {
+  var remove: typeof removeFiltered;
+}
+declare function removeFiltered<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): unknown[];
+declare function removeFiltered<Item extends PlainObject, Key extends keyof Item>(array: Item[], key: Key, value: Item[Key]): unknown[];
+declare function removeFiltered<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): unknown[];
+declare function removeFiltered<Item>(array: Item[], item: Item): unknown[];
+//#endregion
 //#region src/array/group-by.d.ts
 /**
  * Create a record from an array of items using a specific key and value
@@ -371,45 +410,6 @@ declare function exists<Item>(array: Item[], filter: (item: Item, index: number,
  */
 declare function exists<Item>(array: Item[], item: Item): boolean;
 //#endregion
-//#region src/array/filter.d.ts
-/**
- * Get a filtered array of items
- * @param array Array to search in
- * @param callback Callback to get an item's value for matching
- * @param value Value to match against
- * @returns Filtered array of items
- */
-declare function filter<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): Item[];
-/**
- * Get a filtered array of items
- * @param array Array to search in
- * @param key Key to get an item's value for matching
- * @param value Value to match against
- * @returns Filtered array of items
- */
-declare function filter<Item extends PlainObject, Key extends keyof Item>(array: Item[], key: Key, value: Item[Key]): Item[];
-/**
- * Get a filtered array of items matching the filter
- * @param array Array to search in
- * @param filter Filter callback to match items
- * @returns Filtered array of items
- */
-declare function filter<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): Item[];
-/**
- * Get a filtered array of items matching the given item
- * @param array Array to search in
- * @param item Item to match against
- * @returns Filtered array of items
- */
-declare function filter<Item>(array: Item[], item: Item): Item[];
-declare namespace filter {
-  var remove: typeof removeFiltered;
-}
-declare function removeFiltered<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): unknown[];
-declare function removeFiltered<Item extends PlainObject, Key extends keyof Item>(array: Item[], key: Key, value: Item[Key]): unknown[];
-declare function removeFiltered<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): unknown[];
-declare function removeFiltered<Item>(array: Item[], item: Item): unknown[];
-//#endregion
 //#region src/array/find.d.ts
 /**
  * Get the first items matching the given value
@@ -567,92 +567,6 @@ declare function intersection<First extends Record<string, unknown>, Second exte
  */
 declare function intersection<First, Second>(first: First[], second: Second[]): First[];
 //#endregion
-//#region src/array/move.d.ts
-/**
- * Move an item _(or array of items)_ to the position of another item _(or array of items)_ within an array
- *
- * When moving to the front of the array, the moved items will be placed __before__ the target item. When moving to the back of the array, the moved items will be placed __after__ the target item.
- *
- * If either of values are not present in the array, or if they overlap, the array will be returned unchanged
- * @param array Array to move within
- * @param from Item or items to move
- * @param to Item or items to move to
- * @param key Key to get an item's value for matching
- * @returns Original array with items moved _(or unchanged if unable to move)_
- */
-declare function move<Item extends PlainObject, Key extends keyof Item>(array: Item[], from: Item | Item[], to: Item | Item[], key: Key): Item[];
-/**
- * Move an item _(or array of items)_ to the position of another item _(or array of items)_ within an array
- *
- * When moving to the front of the array, the moved items will be placed __before__ the target item. When moving to the back of the array, the moved items will be placed __after__ the target item.
- *
- * If either of values are not present in the array, or if they overlap, the array will be returned unchanged
- * @param array Array to move within
- * @param from Item or items to move
- * @param to Item or items to move to
- * @param callback Callback to get an item's value for matching
- * @returns Original array with items moved _(or unchanged if unable to move)_
- */
-declare function move<Item>(array: Item[], from: Item | Item[], to: Item | Item[], callback: (item: Item, index: number, array: Item[]) => unknown): Item[];
-/**
- * Move an item _(or array of items)_ to the position of another item _(or array of items)_ within an array
- *
- * When moving to the front of the array, the moved items will be placed __before__ the target item. When moving to the back of the array, the moved items will be placed __after__ the target item.
- *
- * If either of values are not present in the array, or if they overlap, the array will be returned unchanged
- * @param array Array to move within
- * @param from Item or items to move
- * @param to Item or items to move to
- * @returns Original array with items moved _(or unchanged if unable to move)_
- */
-declare function move<Item>(array: Item[], from: Item | Item[], to: Item | Item[]): Item[];
-declare namespace move {
-  var indices: typeof moveIndices;
-  var toIndex: typeof moveToIndex;
-}
-/**
- * Move an item from one index to another within an array
- *
- * If the from index is out of bounds, the array will be returned unchanged
- * @param array Array to move within
- * @param from Index to move from
- * @param to Index to move to
- * @returns Original array with item moved _(or unchanged if unable to move)_
- */
-declare function moveIndices<Item>(array: Item[], from: number, to: number): Item[];
-/**
- * Move an item _(or array of items)_ to an index within an array
- *
- * If the value is not present in the array, or if the index is out of bounds, the array will be returned unchanged
- * @param array Array to move within
- * @param value Item or items to move
- * @param index Index to move to
- * @param key Key to get an item's value for matching
- * @returns Original array with items moved _(or unchanged if unable to move)_
- */
-declare function moveToIndex<Item extends PlainObject, Key extends keyof Item>(array: Item[], value: Item | Item[], index: number, key: Key): Item[];
-/**
- * Move an item _(or array of items)_ to an index within an array
- *
- * If the value is not present in the array, or if the index is out of bounds, the array will be returned unchanged
- * @param array Array to move within
- * @param value Item or items to move
- * @param index Index to move to
- * @param callback Callback to get an item's value for matching
- * @returns Original array with items moved _(or unchanged if unable to move)_
- */
-declare function moveToIndex<Item>(array: Item[], value: Item | Item[], index: number, callback: (item: Item, index: number, array: Item[]) => unknown): Item[];
-/**
- * Move an item _(or array of items)_ to an index within an array
- *
- * If the value is not present in the array, or if the index is out of bounds, the array will be returned unchanged
- * @param array Array to move within
- * @param value Item or items to move
- * @param index Index to move to
- * @returns Original array with items moved _(or unchanged if unable to move)_
- */
-declare function moveToIndex<Item>(array: Item[], value: Item | Item[], index: number): Item[];
-//#endregion
 //#region src/array/partition.d.ts
 /**
  * Get a partitioned array of items
@@ -1065,83 +979,6 @@ declare function splice<Item>(array: Item[], start: number, amount: number): Ite
  */
 declare function splice<Item>(array: Item[], start: number): Item[];
 //#endregion
-//#region src/array/swap.d.ts
-/**
- * Swap two smaller arrays within a larger array
- *
- * If either of the smaller arrays are not present in the larger array, or if they overlap, the larger array will be returned unchanged
- * @param array Array of items to swap
- * @param first First array
- * @param second Second array
- * @param key Key to get an item's value for matching
- * @returns Original array with items swapped _(or unchanged if unable to swap)_
- */
-declare function swap<Item extends PlainObject, Key extends keyof Item>(array: Item[], first: Item[], second: Item[], key: Key): Item[];
-/**
- * Swap two smaller arrays within a larger array
- *
- * If either of the smaller arrays are not present in the larger array, or if they overlap, the larger array will be returned unchanged
- * @param array Array of items to swap
- * @param first First array
- * @param second Second array
- * @param callback Callback to get an item's value for matching
- * @returns Original array with items swapped _(or unchanged if unable to swap)_
- */
-declare function swap<Item>(array: Item[], first: Item[], second: Item[], callback: (item: Item, index: number, array: Item[]) => unknown): Item[];
-/**
- * Swap two smaller arrays within a larger array
- *
- * If either of the smaller arrays are not present in the larger array, or if they overlap, the larger array will be returned unchanged
- * @param array Array of items to swap
- * @param first First array
- * @param second Second array
- * @returns Original array with items swapped _(or unchanged if unable to swap)_
- */
-declare function swap<Item>(array: Item[], first: Item[], second: Item[]): Item[];
-/**
- * Swap two indiced items in an array
- *
- * If either of the items are not present in the array, the array will be returned unchanged
- * @param array Array of items to swap
- * @param first First item
- * @param second Second item
- * @param key Key to get an item's value for matching
- * @returns Original array with items swapped _(or unchanged if unable to swap)_
- */
-declare function swap<Item extends PlainObject, Key extends keyof Item>(array: Item[], first: Item, second: Item, key: Key): Item[];
-/**
- * Swap two indiced items in an array
- *
- * If either of the items are not present in the array, the array will be returned unchanged
- * @param array Array of items to swap
- * @param first First item
- * @param second Second item
- * @param callback Callback to get an item's value for matching
- * @returns Original array with items swapped _(or unchanged if unable to swap)_
- */
-declare function swap<Item>(array: Item[], first: Item, second: Item, callback: (item: Item, index: number, array: Item[]) => unknown): Item[];
-/**
- * Swap two indiced items in an array
- * @param array Array of items to swap
- * @param first First item
- * @param second Second item
- * @returns Original array with items swapped _(or unchanged if unable to swap)_
- */
-declare function swap<Item>(array: Item[], first: Item, second: Item): Item[];
-declare namespace swap {
-  var indices: typeof swapIndices;
-}
-/**
- * Swap two indiced items in an array
- *
- * If either index is out of bounds, the array will be returned unchanged
- * @param array Array of items to swap
- * @param first First index _(can be negative to count from the end)_
- * @param second Second index _(can be negative to count from the end)_
- * @returns Original array with items swapped _(or unchanged if unable to swap)_
- */
-declare function swapIndices<Item>(array: Item[], first: number, second: number): Item[];
-//#endregion
 //#region src/array/to-set.d.ts
 /**
  * Create a Set from an array of items using a callback
@@ -1239,6 +1076,169 @@ declare function update<Item extends PlainObject, Key extends keyof Item>(destin
  */
 declare function update<Item>(destination: Item[], updated: Item[]): Item[];
 //#endregion
+//#region src/array/move.d.ts
+/**
+ * Move an item _(or array of items)_ to the position of another item _(or array of items)_ within an array
+ *
+ * When moving to the front of the array, the moved items will be placed __before__ the target item. When moving to the back of the array, the moved items will be placed __after__ the target item.
+ *
+ * If either of values are not present in the array, or if they overlap, the array will be returned unchanged
+ * @param array Array to move within
+ * @param from Item or items to move
+ * @param to Item or items to move to
+ * @param key Key to get an item's value for matching
+ * @returns Original array with items moved _(or unchanged if unable to move)_
+ */
+declare function move<Item extends PlainObject, Key extends keyof Item>(array: Item[], from: Item | Item[], to: Item | Item[], key: Key): Item[];
+/**
+ * Move an item _(or array of items)_ to the position of another item _(or array of items)_ within an array
+ *
+ * When moving to the front of the array, the moved items will be placed __before__ the target item. When moving to the back of the array, the moved items will be placed __after__ the target item.
+ *
+ * If either of values are not present in the array, or if they overlap, the array will be returned unchanged
+ * @param array Array to move within
+ * @param from Item or items to move
+ * @param to Item or items to move to
+ * @param callback Callback to get an item's value for matching
+ * @returns Original array with items moved _(or unchanged if unable to move)_
+ */
+declare function move<Item>(array: Item[], from: Item | Item[], to: Item | Item[], callback: (item: Item, index: number, array: Item[]) => unknown): Item[];
+/**
+ * Move an item _(or array of items)_ to the position of another item _(or array of items)_ within an array
+ *
+ * When moving to the front of the array, the moved items will be placed __before__ the target item. When moving to the back of the array, the moved items will be placed __after__ the target item.
+ *
+ * If either of values are not present in the array, or if they overlap, the array will be returned unchanged
+ * @param array Array to move within
+ * @param from Item or items to move
+ * @param to Item or items to move to
+ * @returns Original array with items moved _(or unchanged if unable to move)_
+ */
+declare function move<Item>(array: Item[], from: Item | Item[], to: Item | Item[]): Item[];
+declare namespace move {
+  var indices: typeof moveIndices;
+  var toIndex: typeof moveToIndex;
+}
+/**
+ * Move an item from one index to another within an array
+ *
+ * If the from index is out of bounds, the array will be returned unchanged
+ * @param array Array to move within
+ * @param from Index to move from
+ * @param to Index to move to
+ * @returns Original array with item moved _(or unchanged if unable to move)_
+ */
+declare function moveIndices<Item>(array: Item[], from: number, to: number): Item[];
+/**
+ * Move an item _(or array of items)_ to an index within an array
+ *
+ * If the value is not present in the array, or if the index is out of bounds, the array will be returned unchanged
+ * @param array Array to move within
+ * @param value Item or items to move
+ * @param index Index to move to
+ * @param key Key to get an item's value for matching
+ * @returns Original array with items moved _(or unchanged if unable to move)_
+ */
+declare function moveToIndex<Item extends PlainObject, Key extends keyof Item>(array: Item[], value: Item | Item[], index: number, key: Key): Item[];
+/**
+ * Move an item _(or array of items)_ to an index within an array
+ *
+ * If the value is not present in the array, or if the index is out of bounds, the array will be returned unchanged
+ * @param array Array to move within
+ * @param value Item or items to move
+ * @param index Index to move to
+ * @param callback Callback to get an item's value for matching
+ * @returns Original array with items moved _(or unchanged if unable to move)_
+ */
+declare function moveToIndex<Item>(array: Item[], value: Item | Item[], index: number, callback: (item: Item, index: number, array: Item[]) => unknown): Item[];
+/**
+ * Move an item _(or array of items)_ to an index within an array
+ *
+ * If the value is not present in the array, or if the index is out of bounds, the array will be returned unchanged
+ * @param array Array to move within
+ * @param value Item or items to move
+ * @param index Index to move to
+ * @returns Original array with items moved _(or unchanged if unable to move)_
+ */
+declare function moveToIndex<Item>(array: Item[], value: Item | Item[], index: number): Item[];
+//#endregion
+//#region src/array/swap.d.ts
+/**
+ * Swap two smaller arrays within a larger array
+ *
+ * If either of the smaller arrays are not present in the larger array, or if they overlap, the larger array will be returned unchanged
+ * @param array Array of items to swap
+ * @param first First array
+ * @param second Second array
+ * @param key Key to get an item's value for matching
+ * @returns Original array with items swapped _(or unchanged if unable to swap)_
+ */
+declare function swap<Item extends PlainObject, Key extends keyof Item>(array: Item[], first: Item[], second: Item[], key: Key): Item[];
+/**
+ * Swap two smaller arrays within a larger array
+ *
+ * If either of the smaller arrays are not present in the larger array, or if they overlap, the larger array will be returned unchanged
+ * @param array Array of items to swap
+ * @param first First array
+ * @param second Second array
+ * @param callback Callback to get an item's value for matching
+ * @returns Original array with items swapped _(or unchanged if unable to swap)_
+ */
+declare function swap<Item>(array: Item[], first: Item[], second: Item[], callback: (item: Item, index: number, array: Item[]) => unknown): Item[];
+/**
+ * Swap two smaller arrays within a larger array
+ *
+ * If either of the smaller arrays are not present in the larger array, or if they overlap, the larger array will be returned unchanged
+ * @param array Array of items to swap
+ * @param first First array
+ * @param second Second array
+ * @returns Original array with items swapped _(or unchanged if unable to swap)_
+ */
+declare function swap<Item>(array: Item[], first: Item[], second: Item[]): Item[];
+/**
+ * Swap two indiced items in an array
+ *
+ * If either of the items are not present in the array, the array will be returned unchanged
+ * @param array Array of items to swap
+ * @param first First item
+ * @param second Second item
+ * @param key Key to get an item's value for matching
+ * @returns Original array with items swapped _(or unchanged if unable to swap)_
+ */
+declare function swap<Item extends PlainObject, Key extends keyof Item>(array: Item[], first: Item, second: Item, key: Key): Item[];
+/**
+ * Swap two indiced items in an array
+ *
+ * If either of the items are not present in the array, the array will be returned unchanged
+ * @param array Array of items to swap
+ * @param first First item
+ * @param second Second item
+ * @param callback Callback to get an item's value for matching
+ * @returns Original array with items swapped _(or unchanged if unable to swap)_
+ */
+declare function swap<Item>(array: Item[], first: Item, second: Item, callback: (item: Item, index: number, array: Item[]) => unknown): Item[];
+/**
+ * Swap two indiced items in an array
+ * @param array Array of items to swap
+ * @param first First item
+ * @param second Second item
+ * @returns Original array with items swapped _(or unchanged if unable to swap)_
+ */
+declare function swap<Item>(array: Item[], first: Item, second: Item): Item[];
+declare namespace swap {
+  var indices: typeof swapIndices;
+}
+/**
+ * Swap two indiced items in an array
+ *
+ * If either index is out of bounds, the array will be returned unchanged
+ * @param array Array of items to swap
+ * @param first First index _(can be negative to count from the end)_
+ * @param second Second index _(can be negative to count from the end)_
+ * @returns Original array with items swapped _(or unchanged if unable to swap)_
+ */
+declare function swapIndices<Item>(array: Item[], first: number, second: number): Item[];
+//#endregion
 //#region src/array/to-map.d.ts
 /**
  * Create a Map from an array of items using callbacks
@@ -1491,6 +1491,52 @@ declare function unique<Item extends PlainObject, ItemKey extends keyof Item>(ar
  */
 declare function unique<Item>(array: Item[]): Item[];
 //#endregion
+//#region src/function/assert.d.ts
+type Asserter<Value> = (value: unknown) => asserts value is Value;
+/**
+ * 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
+ */
+declare function assert<Condition extends () => boolean>(condition: Condition, message: string, error?: ErrorConstructor): asserts condition;
+declare namespace assert {
+  var condition: typeof assertCondition;
+  var defined: typeof assertDefined;
+  var instanceOf: typeof assertInstanceOf;
+  var is: typeof assertIs;
+}
+/**
+ * Creates an asserter that asserts a condition is true, throwing an error if it is not
+ * @param condition Condition to assert
+ * @param message Error message
+ * @param error Error constructor
+ * @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
+ * @param value Value to assert
+ * @param message Error message
+ */
+declare function assertDefined<Value>(value: unknown, message?: string): 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
+ * @param constructor Constructor to check against
+ * @param message Error message
+ * @param error Error constructor
+ * @returns Asserter
+ */
+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
+ * @param condition Type guard function to check the value
+ * @param message Error message
+ * @param error Error constructor
+ * @returns Asserter
+ */
+declare function assertIs<Value>(condition: (value: unknown) => value is Value, message: string, error?: ErrorConstructor): Asserter<Value>;
+//#endregion
 //#region src/internal/function/misc.d.ts
 /**
  * A function that does nothing, which can be useful, I guess…
@@ -1567,23 +1613,6 @@ type Options = {
  */
 declare function memoize<Callback extends GenericCallback>(callback: Callback, options?: MemoizedOptions<Callback>): Memoized<Callback>;
 //#endregion
-//#region src/function/once.d.ts
-/**
- * Create an asynchronous function that can only be called once, rejecting or resolving the same result on subsequent calls
- * @param callback Callback to use once
- * @returns Once callback
- */
-declare function asyncOnce<Callback extends GenericAsyncCallback>(callback: Callback): OnceAsyncCallback<Callback>;
-/**
- * Create a function that can only be called once, returning the same value on subsequent calls
- * @param callback Callback to use once
- * @returns Once callback
- */
-declare function once<Callback extends GenericCallback>(callback: Callback): OnceCallback<Callback>;
-declare namespace once {
-  var async: typeof asyncOnce;
-}
-//#endregion
 //#region src/function/index.d.ts
 /**
  * Debounce a function, ensuring it is only called after `time` milliseconds have passed
@@ -1602,6 +1631,23 @@ declare function debounce<Callback extends GenericCallback>(callback: Callback,
  */
 declare function throttle<Callback extends GenericCallback>(callback: Callback, time?: number): CancelableCallback<Callback>;
 //#endregion
+//#region src/function/once.d.ts
+/**
+ * Create an asynchronous function that can only be called once, rejecting or resolving the same result on subsequent calls
+ * @param callback Callback to use once
+ * @returns Once callback
+ */
+declare function asyncOnce<Callback extends GenericAsyncCallback>(callback: Callback): OnceAsyncCallback<Callback>;
+/**
+ * Create a function that can only be called once, returning the same value on subsequent calls
+ * @param callback Callback to use once
+ * @returns Once callback
+ */
+declare function once<Callback extends GenericCallback>(callback: Callback): OnceCallback<Callback>;
+declare namespace once {
+  var async: typeof asyncOnce;
+}
+//#endregion
 //#region src/function/retry.d.ts
 declare class RetryError extends Error {
   readonly original: unknown;
@@ -4250,4 +4296,4 @@ declare class SizedSet<Value = unknown> extends Set<Value> {
   get(value: Value, update?: boolean): Value | undefined;
 }
 //#endregion
-export { ArrayOrPlainObject, ArrayPosition, type Beacon, type BeaconOptions, BuiltIns, CancelableCallback, CancelablePromise, type Color, Constructor, DiffOptions, DiffResult, DiffValue, EqualOptions, type Err, EventPosition, type ExtendedErr, type ExtendedResult, Flow, FlowPromise, type FulfilledPromise, GenericAsyncCallback, GenericCallback, type HSLAColor, type HSLColor, HasValue, Key$1 as Key, KeyedValue, type Logger, type Memoized, type MemoizedOptions, MergeOptions, Merger, NestedArray, NestedKeys, NestedPartial, NestedValue, NestedValues, NumericalKeys, NumericalValues, type Observable, type Observer, type Ok, OnceAsyncCallback, OnceCallback, PlainObject, Primitive, type PromiseOptions, type PromiseStrategy, PromiseTimeoutError, type PromisesOptions, type PromisesResult, type PromisesValues as PromisesValue, type PromisesValue as PromisesValueItem, type Queue, QueueError, type QueueOptions, type Queued, type RGBAColor, type RGBColor, type RejectedPromise, RequiredKeys, type Result, RetryError, RetryOptions, Simplify, SizedMap, SizedSet, Smushed, type Subscription, TemplateOptions, type Time, ToString, TypedArray, Unsmushed, attempt, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, count, debounce, delay, diff, difference, drop, endsWith, endsWithArray, equal, error, exists, filter, find, flatten, floor, flow, toResult as fromPromise, toResult, fromQuery, toPromise as fromResult, toPromise, getArray, getArrayPosition, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getString, getUuid, getValue, groupBy, hasValue, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, ignoreKey, includes, includesArray, indexOf, indexOfArray, insert, intersection, isArrayOrPlainObject, isColor, isConstructor, isEmpty, isError, isFulfilled, isHexColor, isHslColor, isHslLike, isHslaColor, isInstanceOf, isKey, isNonNullable, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isRejected, isResult, isRgbColor, isRgbLike, isRgbaColor, isTypedArray, join, kebabCase, logger, lowerCase, max, median, memoize, merge, min, move, noop, ok, omit, once, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, retry, rgbToHex, rgbToHsl, rgbToHsla, round, select, setValue, shuffle, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toQuery, toRecord, toSet, toggle, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };
+export { ArrayOrPlainObject, ArrayPosition, Asserter, type Beacon, type BeaconOptions, BuiltIns, CancelableCallback, CancelablePromise, type Color, Constructor, DiffOptions, DiffResult, DiffValue, EqualOptions, type Err, EventPosition, type ExtendedErr, type ExtendedResult, Flow, FlowPromise, type FulfilledPromise, GenericAsyncCallback, GenericCallback, type HSLAColor, type HSLColor, HasValue, Key$1 as Key, KeyedValue, type Logger, type Memoized, type MemoizedOptions, MergeOptions, Merger, NestedArray, NestedKeys, NestedPartial, NestedValue, NestedValues, NumericalKeys, NumericalValues, type Observable, type Observer, type Ok, OnceAsyncCallback, OnceCallback, PlainObject, Primitive, type PromiseOptions, type PromiseStrategy, PromiseTimeoutError, type PromisesOptions, type PromisesResult, type PromisesValues as PromisesValue, type PromisesValue as PromisesValueItem, type Queue, QueueError, type QueueOptions, type Queued, type RGBAColor, type RGBColor, type RejectedPromise, RequiredKeys, type Result, RetryError, RetryOptions, Simplify, SizedMap, SizedSet, Smushed, type Subscription, TemplateOptions, type Time, ToString, TypedArray, Unsmushed, assert, attempt, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, count, debounce, delay, diff, difference, drop, endsWith, endsWithArray, equal, error, exists, filter, find, flatten, floor, flow, toResult as fromPromise, toResult, fromQuery, toPromise as fromResult, toPromise, getArray, getArrayPosition, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getString, getUuid, getValue, groupBy, hasValue, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, ignoreKey, includes, includesArray, indexOf, indexOfArray, insert, intersection, isArrayOrPlainObject, isColor, isConstructor, isEmpty, isError, isFulfilled, isHexColor, isHslColor, isHslLike, isHslaColor, isInstanceOf, isKey, isNonNullable, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isRejected, isResult, isRgbColor, isRgbLike, isRgbaColor, isTypedArray, join, kebabCase, logger, lowerCase, max, median, memoize, merge, min, move, noop, ok, omit, once, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, retry, rgbToHex, rgbToHsl, rgbToHsla, round, select, setValue, shuffle, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toQuery, toRecord, toSet, toggle, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };