@oscarpalmer/atoms 0.204.0 → 0.205.0

package/dist/array/filter.d.mts

@@ -139,6 +139,6 @@ export declare function filter<Item>(array: Item[], filter: (item: Item, index:
  */
 export declare function filter<Item>(array: Item[], item: Item): Item[];
 export declare namespace filter {
-  var remove: typeof exclude;
+  export var remove: typeof exclude;
 }
 //#endregion

package/dist/array/find.d.mts

@@ -65,9 +65,6 @@ export declare function find<Item>(array: Item[], filter: (item: Item, index: nu
  * ```
  */
 export declare function find<Item>(array: Item[], value: Item): Item | undefined;
-export declare namespace find {
-  var last: typeof findLast;
-}
 /**
  * Get the last item matching the given value
  *
@@ -141,4 +138,7 @@ export declare function findLast<Item>(array: Item[], filter: (item: Item, index
  * ```
  */
 export declare function findLast<Item>(array: Item[], value: Item): Item | undefined;
+export declare namespace find {
+  export var last: typeof findLast;
+}
 //#endregion

package/dist/array/first.d.mts

@@ -66,10 +66,6 @@ export declare function first<Item>(array: Item[], filter: (item: Item, index: n
  * ```
  */
 export declare function first<Item>(array: Item[]): Item | undefined;
-export declare namespace first {
-  var _a: typeof firstOrDefault;
-  export { _a as default };
-}
 /**
  * Get the first item matching the given value, or a default value if no match is found
  *
@@ -149,4 +145,7 @@ export declare function firstOrDefault<Item>(array: Item[], defaultValue: Item,
  * ```
  */
 export declare function firstOrDefault<Item>(array: Item[], defaultValue: Item): Item;
+export declare namespace first {
+  export var defaulted: typeof firstOrDefault;
+}
 //#endregion

package/dist/array/first.mjs

@@ -6,6 +6,6 @@ function first(array, ...parameters) {
 function firstOrDefault(array, defaultValue, ...parameters) {
 	return findAbsoluteValueOrDefault(array, parameters, defaultValue, true, false);
 }
-first.default = firstOrDefault;
+first.defaulted = firstOrDefault;
 //#endregion
 export { first, firstOrDefault };

package/dist/array/group-by.d.mts

@@ -52,9 +52,6 @@ export declare function groupBy<Item, KeyArg extends KeyOrCallback<Item, Key>>(a
  * ```
  */
 export declare function groupBy<Item>(array: Item[]): Record<number, Item>;
-export declare namespace groupBy {
-  var arrays: typeof groupArraysBy;
-}
 /**
  * Create a record from an array of items using a specific key, grouping values into arrays
  *
@@ -99,4 +96,7 @@ export declare function groupArraysBy<Item, KeyArg extends KeyOrCallback<Item, K
  * ```
  */
 export declare function groupArraysBy<Item, KeyArg extends KeyOrCallback<Item, Key>>(array: Item[], key: KeyArg): Simplify<Record<KeyOrCallbackKey<Item, KeyArg>, Item[]>>;
+export declare namespace groupBy {
+  export var arrays: typeof groupArraysBy;
+}
 //#endregion

package/dist/array/index.d.mts

@@ -1,20 +1,17 @@
 import { difference } from "./difference.mjs";
 import { exists } from "./exists.mjs";
-import { find, findLast } from "./find.mjs";
 import { flatten } from "./flatten.mjs";
 import { range, times } from "./from.mjs";
 import { chunk } from "../internal/array/chunk.mjs";
 import { compact } from "../internal/array/compact.mjs";
 import { getArray } from "../internal/array/get.mjs";
-import { indexOf, lastIndexOf } from "../internal/array/index-of.mjs";
 import { ArrayComparison, endsWithArray, getArrayComparison, includesArray, indexOfArray, startsWithArray } from "../internal/array/match.mjs";
 import { shuffle } from "../internal/array/shuffle.mjs";
 import { insert } from "./insert.mjs";
 import { intersection } from "./intersection.mjs";
 import { partition } from "./partition.mjs";
-import { push } from "./push.mjs";
+import { append as push } from "./push.mjs";
 import { reverse } from "./reverse.mjs";
-import { reverseSelect, select } from "./select.mjs";
 import { single } from "./single.mjs";
 import { drop, slice, take } from "./slice.mjs";
 import { splice } from "./splice.mjs";
@@ -23,4 +20,4 @@ import { toggle } from "./toggle.mjs";
 import { union } from "./union.mjs";
 import { unique } from "./unique.mjs";
 import { update } from "./update.mjs";
-export { ArrayComparison, chunk, compact, difference, drop, endsWithArray, exists, find, findLast, flatten, getArray, getArrayComparison, includesArray, indexOf, indexOfArray, insert, intersection, lastIndexOf, partition, push, range, reverse, reverseSelect, select, shuffle, single, slice, splice, startsWithArray, take, times, toSet, toggle, union, unique, update };
+export { ArrayComparison, push as append, push, chunk, compact, difference, drop, endsWithArray, exists, flatten, getArray, getArrayComparison, includesArray, indexOfArray, insert, intersection, partition, range, reverse, shuffle, single, slice, splice, startsWithArray, take, times, toSet, toggle, union, unique, update };

package/dist/array/index.mjs

@@ -1,20 +1,17 @@
 import { chunk } from "../internal/array/chunk.mjs";
 import { compact } from "../internal/array/compact.mjs";
 import { getArray } from "../internal/array/get.mjs";
-import { indexOf, lastIndexOf } from "../internal/array/index-of.mjs";
 import { endsWithArray, getArrayComparison, includesArray, indexOfArray, startsWithArray } from "../internal/array/match.mjs";
 import { shuffle } from "../internal/array/shuffle.mjs";
 import { difference } from "./difference.mjs";
 import { exists } from "./exists.mjs";
-import { find, findLast } from "./find.mjs";
 import { flatten } from "./flatten.mjs";
 import { range, times } from "./from.mjs";
 import { insert } from "./insert.mjs";
 import { intersection } from "./intersection.mjs";
 import { partition } from "./partition.mjs";
-import { push } from "./push.mjs";
+import { append as push } from "./push.mjs";
 import { reverse } from "./reverse.mjs";
-import { reverseSelect, select } from "./select.mjs";
 import { single } from "./single.mjs";
 import { drop, slice, take } from "./slice.mjs";
 import { splice } from "./splice.mjs";
@@ -23,4 +20,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, getArrayComparison, includesArray, indexOf, indexOfArray, insert, intersection, lastIndexOf, partition, push, range, reverse, reverseSelect, select, shuffle, single, slice, splice, startsWithArray, take, times, toSet, toggle, union, unique, update };
+export { push as append, push, chunk, compact, difference, drop, endsWithArray, exists, flatten, getArray, getArrayComparison, includesArray, indexOfArray, insert, intersection, partition, range, reverse, shuffle, single, slice, splice, startsWithArray, take, times, toSet, toggle, union, unique, update };

package/dist/array/last.d.mts

@@ -64,10 +64,6 @@ export declare function last<Item>(array: Item[], filter: (item: Item, index: nu
  * ```
  */
 export declare function last<Item>(array: Item[]): Item | undefined;
-export declare namespace last {
-  var _a: typeof lastOrDefault;
-  export { _a as default };
-}
 /**
  * Get the last item matching the given value
  *
@@ -147,4 +143,7 @@ export declare function lastOrDefault<Item>(array: Item[], defaultValue: Item, f
  * ```
  */
 export declare function lastOrDefault<Item>(array: Item[], defaultValue: Item): Item;
+export declare namespace last {
+  export var defaulted: typeof lastOrDefault;
+}
 //#endregion

package/dist/array/last.mjs

@@ -6,6 +6,6 @@ function last(array, ...parameters) {
 function lastOrDefault(array, defaultValue, ...parameters) {
 	return findAbsoluteValueOrDefault(array, parameters, defaultValue, true, true);
 }
-last.default = lastOrDefault;
+last.defaulted = lastOrDefault;
 //#endregion
 export { last, lastOrDefault };

package/dist/array/move.d.mts

@@ -68,10 +68,6 @@ export declare function move<Item extends PlainObject, ItemKey extends keyof Ite
  * ```
  */
 export declare function move<Item>(array: Item[], from: Item | Item[], to: Item | Item[]): Item[];
-export declare namespace move {
-  var indices: typeof moveIndices;
-  var toIndex: typeof moveToIndex;
-}
 /**
  * Move an item from one index to another within an array
  *
@@ -162,4 +158,8 @@ export declare function moveToIndex<Item extends PlainObject, ItemKey extends ke
  * ```
  */
 export declare function moveToIndex<Item>(array: Item[], value: Item | Item[], index: number): Item[];
+export declare namespace move {
+  export var indices: typeof moveIndices;
+  export var toIndex: typeof moveToIndex;
+}
 //#endregion

package/dist/array/push.d.mts

@@ -14,4 +14,5 @@
  * ```
  */
 export declare function push<Item>(array: Item[], pushed: Item[]): number;
-//#endregion
+//#endregion
+export { push as append };

package/dist/array/push.mjs

@@ -18,4 +18,4 @@ function push(array, pushed) {
 	return insertValues(INSERT_TYPE_PUSH, array, pushed, array.length, 0);
 }
 //#endregion
-export { push };
+export { push as append, push };

package/dist/array/select.d.mts

@@ -3,9 +3,87 @@ import { PlainObject } from "../models.mjs";
 type MapKeyOrCallback<Item> = ((item: Item, index: number, array: Item[]) => unknown) | (Item extends PlainObject ? keyof Item : never);
 type Mapped<Item, Map extends MapKeyOrCallback<Item>> = Map extends ((item: Item, index: number, array: Item[]) => unknown) ? ReturnType<Map> : Map extends keyof Item ? Item[Map] : never;
 type ObjectKeysOf<Item> = { [Key in keyof Item]: Item[Key] extends PlainObject ? Key : never; }[keyof Item];
+/**
+ * Get a filtered and mapped array of items
+ *
+ * @param array Array to search in
+ * @param filterCallback Callback to get an item's value for matching
+ * @param filterValue Value to match against
+ * @param map Callback or key to map the matched items
+ * @returns Filtered and mapped array of items
+ *
+ * @example
+ * ```typescript
+ * select(
+ *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
+ *   item => item.id,
+ *   2,
+ *   item => item.name,
+ * ); // => ['Bob']
+ * ```
+ */
+export declare function filterAndMap<Item, FilterCallback extends (item: Item, index: number, array: Item[]) => unknown, Map extends MapKeyOrCallback<Item>>(array: Item[], filterCallback: FilterCallback, filterValue: ReturnType<FilterCallback>, map: Map): Array<Mapped<Item, Map>>;
+/**
+ * Get a filtered and mapped array of items
+ *
+ * @param array Array to search in
+ * @param filterKey Key to get an item's value for matching
+ * @param filterValue Value to match against
+ * @param map Callback or key to map the matched items
+ * @returns Filtered and mapped array of items
+ *
+ * @example
+ * ```typescript
+ * select(
+ *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
+ *   'id',
+ *   2,
+ *   'name',
+ * ); // => ['Bob']
+ * ```
+ */
+export declare function filterAndMap<Item extends PlainObject, ItemKey extends keyof Item, Map extends MapKeyOrCallback<Item>>(array: Item[], filterKey: ItemKey, filterValue: Item[ItemKey], map: Map): Array<Mapped<Item, Map>>;
+/**
+ * Get a filtered and mapped array of items
+ *
+ * @param array Array to search in
+ * @param filter Filter callback to match items
+ * @param map Callback or key to map the matched items
+ * @returns Filtered and mapped array of items
+ *
+ * @example
+ * ```typescript
+ * select(
+ *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
+ *   item => item.id === 2,
+ *   item => item.name,
+ * ); // => ['Bob']
+ * ```
+ */
+export declare function filterAndMap<Item, Map extends MapKeyOrCallback<Item>>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean, map: Map): Array<Mapped<Item, Map>>;
+/**
+ * Get a filtered and mapped array of items
+ *
+ * @param array Array to search in
+ * @param item Item to match against
+ * @param map Callback or key to map the matched items
+ * @returns Filtered and mapped array of items
+ *
+ * @example
+ * ```typescript
+ * select(
+ *   [1, 2, 3, 2, 1],
+ *   3,
+ *   value => value ** 2,
+ * ); // => [9]
+ * ```
+ */
+export declare function filterAndMap<Item, Map extends MapKeyOrCallback<Item>>(array: Item[], item: Item, map: Map): Array<Mapped<Item, Map>>;
 /**
  * Get a mapped and filtered array of items
  *
+ * _Available as `reverseSelect`_ and `select.reverse`_
+ *
  * @param array Array to search in
  * @param map Callback or key to map the items
  * @param filterCallback Callback to get a mapped value's value for matching
@@ -22,10 +100,12 @@ type ObjectKeysOf<Item> = { [Key in keyof Item]: Item[Key] extends PlainObject ?
  * ); // => ['Bob']
  * ```
  */
-export declare function reverseSelect<Item, Map extends MapKeyOrCallback<Item>, FilterCallback extends (item: Mapped<Item, Map>, index: number, array: Item[]) => unknown>(array: Item[], map: Map, filterCallback: FilterCallback, filterValue: ReturnType<FilterCallback>): Array<Mapped<Item, Map>>;
+export declare function mapAndFilter<Item, Map extends MapKeyOrCallback<Item>, FilterCallback extends (item: Mapped<Item, Map>, index: number, array: Item[]) => unknown>(array: Item[], map: Map, filterCallback: FilterCallback, filterValue: ReturnType<FilterCallback>): Array<Mapped<Item, Map>>;
 /**
  * Get a mapped and filtered array of items
  *
+ * _Available as `reverseSelect`_ and `select.reverse`_
+ *
  * @param array Array to search in
  * @param map Callback to map the items
  * @param filterKey Key to get a mapped value's value for matching
@@ -42,10 +122,12 @@ export declare function reverseSelect<Item, Map extends MapKeyOrCallback<Item>,
  * ); // => [{label: 'Bob'}]
  * ```
  */
-export declare function reverseSelect<Item, MapCallback extends (item: Item, index: number, array: Item[]) => PlainObject, ItemKey extends keyof ReturnType<MapCallback>>(array: Item[], map: MapCallback, filterKey: ItemKey, filterValue: ReturnType<MapCallback>[ItemKey]): Array<ReturnType<MapCallback>>;
+export declare function mapAndFilter<Item, MapCallback extends (item: Item, index: number, array: Item[]) => PlainObject, ItemKey extends keyof ReturnType<MapCallback>>(array: Item[], map: MapCallback, filterKey: ItemKey, filterValue: ReturnType<MapCallback>[ItemKey]): Array<ReturnType<MapCallback>>;
 /**
  * Get a mapped and filtered array of items
  *
+ * _Available as `reverseSelect`_ and `select.reverse`_
+ *
  * @param array Array to search in
  * @param map Key to map the items
  * @param filterKey Key to get a mapped value's value for matching
@@ -62,10 +144,12 @@ export declare function reverseSelect<Item, MapCallback extends (item: Item, ind
  * ); // => [{tag: 'b'}]
  * ```
  */
-export declare function reverseSelect<Item, MapKey extends ObjectKeysOf<Item>, ItemKey extends keyof Item[MapKey]>(array: Item[], map: MapKey, filterKey: ItemKey, filterValue: Item[MapKey][ItemKey]): Array<Item[MapKey]>;
+export declare function mapAndFilter<Item, MapKey extends ObjectKeysOf<Item>, ItemKey extends keyof Item[MapKey]>(array: Item[], map: MapKey, filterKey: ItemKey, filterValue: Item[MapKey][ItemKey]): Array<Item[MapKey]>;
 /**
  * Get a mapped and filtered array of items
  *
+ * _Available as `reverseSelect`_ and `select.reverse`_
+ *
  * @param array Array to search in
  * @param map Callback or key to map the items
  * @param filter Filter callback to match mapped values
@@ -80,10 +164,12 @@ export declare function reverseSelect<Item, MapKey extends ObjectKeysOf<Item>, I
  * ); // => ['Bob']
  * ```
  */
-export declare function reverseSelect<Item, Map extends MapKeyOrCallback<Item>>(array: Item[], map: Map, filter: (item: Mapped<Item, Map>, index: number, array: Item[]) => boolean): Array<Mapped<Item, Map>>;
+export declare function mapAndFilter<Item, Map extends MapKeyOrCallback<Item>>(array: Item[], map: Map, filter: (item: Mapped<Item, Map>, index: number, array: Item[]) => boolean): Array<Mapped<Item, Map>>;
 /**
  * Get a mapped and filtered array of items
  *
+ * _Available as `reverseSelect`_ and `select.reverse`_
+ *
  * @param array Array to search in
  * @param map Callback or key to map the items
  * @param value Mapped value to match against
@@ -98,84 +184,9 @@ export declare function reverseSelect<Item, Map extends MapKeyOrCallback<Item>>(
  * ); // => [4, 4]
  * ```
  */
-export declare function reverseSelect<Item, Map extends MapKeyOrCallback<Item>>(array: Item[], map: Map, value: Mapped<Item, Map>): Array<Mapped<Item, Map>>;
-/**
- * Get a filtered and mapped array of items
- *
- * @param array Array to search in
- * @param filterCallback Callback to get an item's value for matching
- * @param filterValue Value to match against
- * @param map Callback or key to map the matched items
- * @returns Filtered and mapped array of items
- *
- * @example
- * ```typescript
- * select(
- *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
- *   item => item.id,
- *   2,
- *   item => item.name,
- * ); // => ['Bob']
- * ```
- */
-export declare function select<Item, FilterCallback extends (item: Item, index: number, array: Item[]) => unknown, Map extends MapKeyOrCallback<Item>>(array: Item[], filterCallback: FilterCallback, filterValue: ReturnType<FilterCallback>, map: Map): Array<Mapped<Item, Map>>;
-/**
- * Get a filtered and mapped array of items
- *
- * @param array Array to search in
- * @param filterKey Key to get an item's value for matching
- * @param filterValue Value to match against
- * @param map Callback or key to map the matched items
- * @returns Filtered and mapped array of items
- *
- * @example
- * ```typescript
- * select(
- *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
- *   'id',
- *   2,
- *   'name',
- * ); // => ['Bob']
- * ```
- */
-export declare function select<Item extends PlainObject, ItemKey extends keyof Item, Map extends MapKeyOrCallback<Item>>(array: Item[], filterKey: ItemKey, filterValue: Item[ItemKey], map: Map): Array<Mapped<Item, Map>>;
-/**
- * Get a filtered and mapped array of items
- *
- * @param array Array to search in
- * @param filter Filter callback to match items
- * @param map Callback or key to map the matched items
- * @returns Filtered and mapped array of items
- *
- * @example
- * ```typescript
- * select(
- *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
- *   item => item.id === 2,
- *   item => item.name,
- * ); // => ['Bob']
- * ```
- */
-export declare function select<Item, Map extends MapKeyOrCallback<Item>>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean, map: Map): Array<Mapped<Item, Map>>;
-/**
- * Get a filtered and mapped array of items
- *
- * @param array Array to search in
- * @param item Item to match against
- * @param map Callback or key to map the matched items
- * @returns Filtered and mapped array of items
- *
- * @example
- * ```typescript
- * select(
- *   [1, 2, 3, 2, 1],
- *   3,
- *   value => value ** 2,
- * ); // => [9]
- * ```
- */
-export declare function select<Item, Map extends MapKeyOrCallback<Item>>(array: Item[], item: Item, map: Map): Array<Mapped<Item, Map>>;
-export declare namespace select {
-  var reverse: typeof reverseSelect;
+export declare function mapAndFilter<Item, Map extends MapKeyOrCallback<Item>>(array: Item[], map: Map, value: Mapped<Item, Map>): Array<Mapped<Item, Map>>;
+export declare namespace filterAndMap {
+  export var reverse: typeof mapAndFilter;
 }
-//#endregion
+//#endregion
+export { filterAndMap as select, mapAndFilter as reverseSelect };

package/dist/array/select.mjs

@@ -1,15 +1,15 @@
 import { findValues } from "../internal/array/find.mjs";
 //#region src/array/select.ts
-function reverseSelect(array, ...parameters) {
+function filterAndMap(array, ...parameters) {
+	return selectValues(array, parameters);
+}
+function mapAndFilter(array, ...parameters) {
 	const mapper = parameters.shift();
 	return findValues("all", array, parameters, {
 		callback: mapper,
 		reverse: true
 	}).matched;
 }
-function select(array, ...parameters) {
-	return selectValues(array, parameters);
-}
 function selectValues(array, parameters) {
 	const mapper = parameters.pop();
 	return findValues("all", array, parameters, {
@@ -17,6 +17,6 @@ function selectValues(array, parameters) {
 		reverse: false
 	}).matched;
 }
-select.reverse = reverseSelect;
+filterAndMap.reverse = mapAndFilter;
 //#endregion
-export { reverseSelect, select };
+export { filterAndMap, filterAndMap as select, mapAndFilter, mapAndFilter as reverseSelect };

package/dist/array/sort.d.mts

@@ -67,7 +67,7 @@ type ComparisonSorter<Item> = (first: Item, second: Item) => number;
 /**
  * Direction to sort by
  */
-export type SortDirection = 'ascending' | 'descending';
+export type SortDirection = "ascending" | "descending";
 /**
  * Sorter for an array with predefined sorters
  *
@@ -244,11 +244,11 @@ export declare function sort<Item>(array: Item[], sorter: ArraySorter<Item>, des
  * @returns Sorted array
  */
 export declare function sort<Item>(array: Item[], descending?: boolean): Item[];
-export declare namespace sort {
-  var getIndex: typeof getSortedIndex;
-  var initialize: typeof initializeSorter;
-  var is: typeof isSorted;
-}
 export declare const SORT_DIRECTION_ASCENDING: SortDirection;
 export declare const SORT_DIRECTION_DESCENDING: SortDirection;
+export declare namespace sort {
+  export var getIndex: typeof getSortedIndex;
+  export var initialize: typeof initializeSorter;
+  export var is: typeof isSorted;
+}
 //#endregion

package/dist/array/swap.d.mts

@@ -166,9 +166,6 @@ export declare function swap<Item extends PlainObject, ItemKey extends keyof Ite
  * ```
  */
 export declare function swap<Item>(array: Item[], first: Item, second: Item): Item[];
-export declare namespace swap {
-  var indices: typeof swapIndices;
-}
 /**
  * Swap two indiced items in an array
  *
@@ -182,4 +179,7 @@ export declare namespace swap {
  * @returns Original array with items swapped _(or unchanged if unable to swap)_
  */
 declare function swapIndices<Item>(array: Item[], first: number, second: number): Item[];
+export declare namespace swap {
+  export var indices: typeof swapIndices;
+}
 //#endregion

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 { indexOfArray } from "../internal/array/match.mjs";
 import { arraysOverlap } from "../internal/array/overlap.mjs";
+import { indexOf } from "../internal/array/index-of.mjs";
 //#region src/array/swap.ts
 function swap(array, first, second, third) {
 	if (!Array.isArray(array)) return [];

package/dist/array/to-map.d.mts

@@ -52,9 +52,6 @@ export declare function toMap<Item, KeyArg extends KeyOrCallback<Item, Key>>(arr
  * ```
  */
 export declare function toMap<Item>(array: Item[]): Map<number, Item>;
-export declare namespace toMap {
-  var arrays: typeof toMapArrays;
-}
 /**
  * Create a _Map_ from an array of items using a specific key, grouping values into arrays
  *
@@ -93,4 +90,7 @@ export declare function toMapArrays<Item, KeyArg extends KeyOrCallback<Item, Key
  * ```
  */
 export declare function toMapArrays<Item, KeyArg extends KeyOrCallback<Item, Key>>(array: Item[], key: KeyArg): Map<KeyOrCallbackKey<Item, KeyArg>, Item[]>;
+export declare namespace toMap {
+  export var arrays: typeof toMapArrays;
+}
 //#endregion

package/dist/array/to-record.d.mts

@@ -52,9 +52,6 @@ export declare function toRecord<Item, KeyArg extends KeyOrCallback<Item, Key>>(
  * ```
  */
 export declare function toRecord<Item>(array: Item[]): Record<number, Item>;
-export declare namespace toRecord {
-  var arrays: typeof toRecordArrays;
-}
 /**
  * Create a record from an array of items using a specific key, grouping values into arrays
  *
@@ -93,4 +90,7 @@ export declare function toRecordArrays<Item, KeyArg extends KeyOrCallback<Item,
  * ```
  */
 export declare function toRecordArrays<Item, KeyArg extends KeyOrCallback<Item, Key>>(array: Item[], key: KeyArg): Simplify<Record<KeyOrCallbackKey<Item, KeyArg>, Item[]>>;
+export declare namespace toRecord {
+  export var arrays: typeof toRecordArrays;
+}
 //#endregion

package/dist/beacon.mjs

@@ -38,7 +38,7 @@ function Observable(beacon) {
 	};
 }
 Observable.prototype[BEACON_PROPERTY] = BEACON_OBSERVABLE;
-Observable.prototype.deactivate = deactiveateObservable;
+Observable.prototype.deactivate = deactivateObservable;
 Observable.prototype.subscribe = subscribeToObservable;
 Object.defineProperty(Observable.prototype, "active", {
 	enumerable: true,
@@ -87,7 +87,7 @@ function createObserver(first, second, third) {
 function deactivateBeacon() {
 	closeBeacon(this[BEACON_SYMBOL], false);
 }
-function deactiveateObservable() {
+function deactivateObservable() {
 	this[BEACON_SYMBOL].active = false;
 }
 function emitBeaconError(error, finish) {

package/dist/color/constants.d.mts

@@ -1,17 +1,17 @@
 import { SubscriptionProperty } from "../internal/subscription.mjs";
-import { ColorTypeExtended, HSLAColor, HSLColor, HWBAColor, HWBColor, RGBAColor, RGBColor } from "./models.mjs";
+import { ColorDefaults, ColorExpressions, ColorTypeExtended, HSLAColor, HSLColor, HWBAColor, HWBColor, RGBAColor, RGBColor } from "./models.mjs";
 //#region src/color/constants.d.ts
 type ColorTypes = {
-  all: Set<'alpha' | ColorTypeExtended>;
-  hex: 'hex';
-  hexa: 'hexa';
-  hsl: 'hsl';
-  hsla: 'hsla';
-  hwb: 'hwb';
-  hwba: 'hwba';
-  rgb: 'rgb';
-  rgba: 'rgba';
-  wildcard: '*';
+  all: Set<"alpha" | ColorTypeExtended>;
+  hex: "hex";
+  hexa: "hexa";
+  hsl: "hsl";
+  hsla: "hsla";
+  hwb: "hwb";
+  hwba: "hwba";
+  rgb: "rgb";
+  rgba: "rgba";
+  wildcard: "*";
 };
 export declare const COLOR_ALPHA: {
   fullHexShort: string;
@@ -20,35 +20,8 @@ export declare const COLOR_ALPHA: {
   noneHex: string;
   noneValue: number;
 };
-export declare const COLOR_DEFAULTS: {
-  alpha: {
-    hex: string;
-    value: number;
-  };
-  hexBlack: string;
-  hexWhite: string;
-  hsl: {
-    hue: number;
-    saturation: number;
-    lightness: number;
-  };
-  hwb: {
-    hue: number;
-    whiteness: number;
-    blackness: number;
-  };
-  rgb: {
-    blue: number;
-    green: number;
-    red: number;
-  };
-};
-export declare const COLOR_EXPRESSION: {
-  alphaHex: RegExp;
-  hexLong: RegExp;
-  hexShort: RegExp;
-  prefix: RegExp;
-};
+export declare const COLOR_DEFAULTS: ColorDefaults;
+export declare const COLOR_EXPRESSION: ColorExpressions;
 export declare const COLOR_LENGTHS: {
   hexLong: number;
   hexShort: number;
@@ -68,7 +41,7 @@ export declare const COLOR_MAX: {
 };
 export declare const COLOR_NAME = "color";
 export declare const COLOR_PROPERTY = "$color";
-export declare const COLOR_SYMBOL: unique symbol;
+export declare const COLOR_SYMBOL: symbol;
 export declare const COLOR_TYPE: ColorTypes;
 export declare const COLOR_SRGB: {
   luminanceBlue: number;

package/dist/color/instance.d.mts

@@ -1,5 +1,4 @@
 import { Color } from "./models.mjs";
 //#region src/color/instance.d.ts
-declare function Color(this: any, value: unknown): void;
 export declare function color(value: unknown): Color;
 //#endregion