@oscarpalmer/atoms 0.167.0 → 0.169.0

package/dist/array/index.d.mts

@@ -15,11 +15,10 @@ import { ArrayPosition, endsWithArray, getArrayPosition, includesArray, indexOfA
 import { push } from "./push.mjs";
 import { select } from "./select.mjs";
 import { drop, slice, take } from "./slice.mjs";
-import { ArrayComparisonSorter, ArrayKeySorter, ArrayValueSorter, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SortDirection, sort } from "./sort.mjs";
 import { splice } from "./splice.mjs";
 import { toSet } from "./to-set.mjs";
 import { toggle } from "./toggle.mjs";
 import { union } from "./union.mjs";
 import { unique } from "./unique.mjs";
 import { update } from "./update.mjs";
-export { ArrayComparisonSorter, ArrayKeySorter, ArrayPosition, ArrayValueSorter, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SortDirection, 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, unique, update };
+export { ArrayPosition, chunk, compact, difference, drop, endsWithArray, exists, find, flatten, getArray, getArrayPosition, includesArray, indexOf, indexOfArray, insert, intersection, partition, push, range, select, shuffle, slice, splice, startsWithArray, take, times, toSet, toggle, union, unique, update };

package/dist/array/index.mjs

@@ -15,11 +15,10 @@ import { endsWithArray, getArrayPosition, includesArray, indexOfArray, startsWit
 import { push } from "./push.mjs";
 import { select } from "./select.mjs";
 import { drop, slice, take } from "./slice.mjs";
-import { SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, sort } from "./sort.mjs";
 import { splice } from "./splice.mjs";
 import { toSet } from "./to-set.mjs";
 import { toggle } from "./toggle.mjs";
 import { union } from "./union.mjs";
 import { unique } from "./unique.mjs";
 import { update } from "./update.mjs";
-export { SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, 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, unique, update };
+export { chunk, compact, difference, drop, endsWithArray, exists, find, flatten, getArray, getArrayPosition, includesArray, indexOf, indexOfArray, insert, intersection, partition, push, range, select, shuffle, slice, splice, startsWithArray, take, times, toSet, toggle, union, unique, update };

package/dist/array/sort.d.mts

@@ -35,6 +35,10 @@ type ArrayKeySorter<Item extends PlainObject, ItemKey extends keyof Item> = {
  * Sorters based on keys in an object
  */
 type ArrayKeySorters<Item extends PlainObject> = { [ItemKey in keyof Item]: ArrayKeySorter<Item, ItemKey> }[keyof Item];
+/**
+ * Sorter to use for sorting
+ */
+type ArraySorter<Item> = Item extends PlainObject ? keyof Item | ArrayComparisonSorter<Item> | ArrayKeySorters<Item> | ArrayValueSorter<Item> | ComparisonSorter<Item> : ArrayComparisonSorter<Item> | ArrayValueSorter<Item> | ComparisonSorter<Item>;
 /**
  * Sorting information for arrays _(using a value callback and built-in comparison)_
  */
@@ -61,10 +65,27 @@ type ComparisonSorter<Item> = (first: Item, second: Item) => number;
  * Direction to sort by
  */
 type SortDirection = 'ascending' | 'descending';
+type Sorter<Item> = (array: Item[]) => Item[];
 /**
- * Sorter to use for sorting
+ * Initialize a sort handler with sorters _(and an optional default direction)_
+ * @param sorters Sorters to use for sorting
+ * @param descending Sort in descending order? _(defaults to `false`; overridden by individual sorters)_
+ * @returns Sort handler
+ */
+declare function initializeSort<Item>(sorters: Array<ArraySorter<Item>>, descending?: boolean): Sorter<Item>;
+/**
+ * Initialize a sort handler with a sorter _(and an optional default direction)_
+ * @param sorter Sorter to use for sorting
+ * @param descending Sort in descending order? _(defaults to `false`; overridden by individual sorters)_
+ * @returns Sort handler
+ */
+declare function initializeSort<Item>(sorter: ArraySorter<Item>, descending?: boolean): Sorter<Item>;
+/**
+ * Initialize a sort handler _(with an optional default direction)_
+ * @param descending Sort in descending order? _(defaults to `false`)_
+ * @returns Sort handler
  */
-type Sorter<Item> = Item extends PlainObject ? keyof Item | ArrayComparisonSorter<Item> | ArrayKeySorters<Item> | ArrayValueSorter<Item> | ComparisonSorter<Item> : ArrayComparisonSorter<Item> | ArrayValueSorter<Item> | ComparisonSorter<Item>;
+declare function initializeSort<Item>(descending?: boolean): Sorter<Item>;
 /**
  * Sort an array of items, using multiple sorters to sort by specific values
  * @param array Array to sort
@@ -72,7 +93,7 @@ type Sorter<Item> = Item extends PlainObject ? keyof Item | ArrayComparisonSorte
  * @param descending Sort in descending order? _(defaults to `false`; overridden by individual sorters)_
  * @returns Sorted array
  */
-declare function sort<Item>(array: Item[], sorters: Array<Sorter<Item>>, descending?: boolean): Item[];
+declare function sort<Item>(array: Item[], sorters: Array<ArraySorter<Item>>, descending?: boolean): Item[];
 /**
  * Sort an array of items, using multiple sorters to sort by specific values
  * @param array Array to sort
@@ -80,7 +101,7 @@ declare function sort<Item>(array: Item[], sorters: Array<Sorter<Item>>, descend
  * @param descending Sort in descending order? _(defaults to `false`; overridden by individual sorters)_
  * @returns Sorted array
  */
-declare function sort<Item>(array: Item[], sorter: Sorter<Item>, descending?: boolean): Item[];
+declare function sort<Item>(array: Item[], sorter: ArraySorter<Item>, descending?: boolean): Item[];
 /**
  * Sort an array of items
  * @param array Array to sort
@@ -88,7 +109,10 @@ declare function sort<Item>(array: Item[], sorter: Sorter<Item>, descending?: bo
  * @returns Sorted array
  */
 declare function sort<Item>(array: Item[], descending?: boolean): Item[];
+declare namespace sort {
+  var initialize: typeof initializeSort;
+}
 declare const SORT_DIRECTION_ASCENDING: SortDirection;
 declare const SORT_DIRECTION_DESCENDING: SortDirection;
 //#endregion
-export { ArrayComparisonSorter, ArrayKeySorter, ArrayValueSorter, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SortDirection, sort };
+export { ArrayComparisonSorter, ArrayKeySorter, ArrayValueSorter, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SortDirection, Sorter, sort };

package/dist/array/sort.mjs

@@ -9,6 +9,9 @@ function getComparisonSorter(callback, modifier) {
 		identifier: String(callback)
 	};
 }
+function getModifier(first, second) {
+	return modifiers[first === true || second === true ? SORT_DIRECTION_DESCENDING : SORT_DIRECTION_ASCENDING];
+}
 function getObjectSorter(obj, modifier) {
 	let sorter;
 	if (typeof obj.comparison === "function") sorter = getComparisonSorter(obj.comparison, modifier);
@@ -27,6 +30,17 @@ function getSorter(value, modifier) {
 		default: break;
 	}
 }
+function getSorters(value, modifier) {
+	const array = Array.isArray(value) ? value : [value];
+	const { length } = array;
+	const sorters = [];
+	for (let index = 0; index < length; index += 1) {
+		const item = array[index];
+		const sorter = getSorter(item, modifier);
+		if (sorter != null) sorters.push(sorter);
+	}
+	return sorters.filter((value, index, array) => array.findIndex((next) => next.identifier === value.identifier) === index);
+}
 function getValueSorter(value, modifier) {
 	return {
 		modifier,
@@ -35,32 +49,31 @@ function getValueSorter(value, modifier) {
 		value: typeof value === "function" ? value : (item) => item[value]
 	};
 }
+function initializeSort(first, second) {
+	const modifier = getModifier(first, second);
+	const sorters = getSorters(first, modifier);
+	return (array) => work(array, sorters, modifier);
+}
 function sort(array, first, second) {
+	const modifier = getModifier(first, second);
+	return work(array, getSorters(first, modifier), modifier);
+}
+function work(array, sorters, modifier) {
 	if (!Array.isArray(array)) return [];
 	if (array.length < 2) return array;
-	const modifier = modifiers[first === true || second === true ? SORT_DIRECTION_DESCENDING : SORT_DIRECTION_ASCENDING];
-	const sorters = (Array.isArray(first) ? first : [first]).map((item) => getSorter(item, modifier)).filter((sorter) => sorter != null).filter((current, index, filtered) => filtered.findIndex((next) => next.identifier === current.identifier) === index);
 	const { length } = sorters;
 	if (length === 0) return array.sort((first, second) => compare(first, second) * modifier);
-	if (length === 1) {
-		const sorter = sorters[0];
-		return array.sort((firstItem, secondItem) => {
-			const firstValue = sorter.get ? sorter.value(firstItem) : firstItem;
-			const secondValue = sorter.get ? sorter.value(secondItem) : secondItem;
-			return (sorter.compare?.complex?.(firstItem, firstValue, secondItem, secondValue) ?? sorter.compare?.simple?.(firstItem, secondItem) ?? compare(firstValue, secondValue)) * sorter.modifier;
-		});
-	}
-	return array.sort((firstItem, secondItem) => {
+	return array.sort((first, second) => {
 		for (let index = 0; index < length; index += 1) {
 			const sorter = sorters[index];
-			const firstValue = sorter.value?.(firstItem) ?? firstItem;
-			const secondValue = sorter.value?.(secondItem) ?? secondItem;
-			const comparison = (sorter.compare?.complex?.(firstItem, firstValue, secondItem, secondValue) ?? sorter.compare?.simple?.(firstItem, secondItem) ?? compare(firstValue, secondValue)) * sorter.modifier;
+			const values = [sorter.get ? sorter.value(first) : first, sorter.get ? sorter.value(second) : second];
+			const comparison = (sorter.compare?.complex?.(first, values[0], second, values[1]) ?? sorter.compare?.simple?.(values[0], values[1]) ?? compare(values[0], values[1])) * sorter.modifier;
 			if (comparison !== 0) return comparison;
 		}
 		return 0;
 	});
 }
+sort.initialize = initializeSort;
 const SORT_DIRECTION_ASCENDING = "ascending";
 const SORT_DIRECTION_DESCENDING = "descending";
 const modifiers = {

package/dist/index.d.mts

@@ -853,97 +853,6 @@ declare function take<Item extends PlainObject>(array: Item[], callback: (item:
  */
 declare function take(array: unknown[], count: number): unknown[];
 //#endregion
-//#region src/array/sort.d.ts
-/**
- * Sorting information for arrays _(using a comparison callback)_
- */
-type ArrayComparisonSorter<Item> = {
-  /**
-   * Callback to use when comparing items and values
-   */
-  comparison: ComparisonSorter<Item>;
-  /**
-   * Direction to sort by
-   */
-  direction?: SortDirection;
-};
-/**
- * Sorting information for arrays _(using a key)_
- */
-type ArrayKeySorter<Item extends PlainObject, ItemKey extends keyof Item> = {
-  /**
-   * Comparator to use when comparing items and values
-   */
-  compare?: CompareCallback<Item, Item[ItemKey]>;
-  /**
-   * Direction to sort by
-   */
-  direction?: SortDirection;
-  /**
-   * Key to sort by
-   */
-  key: ItemKey;
-};
-/**
- * Sorters based on keys in an object
- */
-type ArrayKeySorters<Item extends PlainObject> = { [ItemKey in keyof Item]: ArrayKeySorter<Item, ItemKey> }[keyof Item];
-/**
- * Sorting information for arrays _(using a value callback and built-in comparison)_
- */
-type ArrayValueSorter<Item> = {
-  /**
-   * Direction to sort by
-   */
-  direction?: SortDirection;
-  /**
-   * Value to sort by
-   */
-  value: (item: Item) => unknown;
-};
-/**
- * Comparator to use when comparing items and values
- */
-type CompareCallback<Item, Value = CompareCallbackValue<Item>> = (first: Item, firstValue: Value, second: Item, secondValue: Value) => number;
-type CompareCallbackValue<Item> = Item extends Primitive ? Item : unknown;
-/**
- * Callback to use when comparing items and values
- */
-type ComparisonSorter<Item> = (first: Item, second: Item) => number;
-/**
- * Direction to sort by
- */
-type SortDirection = 'ascending' | 'descending';
-/**
- * Sorter to use for sorting
- */
-type Sorter<Item> = Item extends PlainObject ? keyof Item | ArrayComparisonSorter<Item> | ArrayKeySorters<Item> | ArrayValueSorter<Item> | ComparisonSorter<Item> : ArrayComparisonSorter<Item> | ArrayValueSorter<Item> | ComparisonSorter<Item>;
-/**
- * Sort an array of items, using multiple sorters to sort by specific values
- * @param array Array to sort
- * @param sorters Sorters to use for sorting
- * @param descending Sort in descending order? _(defaults to `false`; overridden by individual sorters)_
- * @returns Sorted array
- */
-declare function sort<Item>(array: Item[], sorters: Array<Sorter<Item>>, descending?: boolean): Item[];
-/**
- * Sort an array of items, using multiple sorters to sort by specific values
- * @param array Array to sort
- * @param sorter Sorter to use for sorting
- * @param descending Sort in descending order? _(defaults to `false`; overridden by individual sorters)_
- * @returns Sorted array
- */
-declare function sort<Item>(array: Item[], sorter: Sorter<Item>, descending?: boolean): Item[];
-/**
- * Sort an array of items
- * @param array Array to sort
- * @param descending Sort in descending order? _(defaults to `false`)_
- * @returns Sorted array
- */
-declare function sort<Item>(array: Item[], descending?: boolean): Item[];
-declare const SORT_DIRECTION_ASCENDING: SortDirection;
-declare const SORT_DIRECTION_DESCENDING: SortDirection;
-//#endregion
 //#region src/array/splice.d.ts
 /**
  * Adds items into an array at a specific index and removes a specific amount of items
@@ -1183,6 +1092,121 @@ declare function moveToIndex<Item>(array: Item[], value: Item | Item[], index: n
  */
 declare function moveToIndex<Item>(array: Item[], value: Item | Item[], index: number): Item[];
 //#endregion
+//#region src/array/sort.d.ts
+/**
+ * Sorting information for arrays _(using a comparison callback)_
+ */
+type ArrayComparisonSorter<Item> = {
+  /**
+   * Callback to use when comparing items and values
+   */
+  comparison: ComparisonSorter<Item>;
+  /**
+   * Direction to sort by
+   */
+  direction?: SortDirection;
+};
+/**
+ * Sorting information for arrays _(using a key)_
+ */
+type ArrayKeySorter<Item extends PlainObject, ItemKey extends keyof Item> = {
+  /**
+   * Comparator to use when comparing items and values
+   */
+  compare?: CompareCallback<Item, Item[ItemKey]>;
+  /**
+   * Direction to sort by
+   */
+  direction?: SortDirection;
+  /**
+   * Key to sort by
+   */
+  key: ItemKey;
+};
+/**
+ * Sorters based on keys in an object
+ */
+type ArrayKeySorters<Item extends PlainObject> = { [ItemKey in keyof Item]: ArrayKeySorter<Item, ItemKey> }[keyof Item];
+/**
+ * Sorter to use for sorting
+ */
+type ArraySorter<Item> = Item extends PlainObject ? keyof Item | ArrayComparisonSorter<Item> | ArrayKeySorters<Item> | ArrayValueSorter<Item> | ComparisonSorter<Item> : ArrayComparisonSorter<Item> | ArrayValueSorter<Item> | ComparisonSorter<Item>;
+/**
+ * Sorting information for arrays _(using a value callback and built-in comparison)_
+ */
+type ArrayValueSorter<Item> = {
+  /**
+   * Direction to sort by
+   */
+  direction?: SortDirection;
+  /**
+   * Value to sort by
+   */
+  value: (item: Item) => unknown;
+};
+/**
+ * Comparator to use when comparing items and values
+ */
+type CompareCallback<Item, Value = CompareCallbackValue<Item>> = (first: Item, firstValue: Value, second: Item, secondValue: Value) => number;
+type CompareCallbackValue<Item> = Item extends Primitive ? Item : unknown;
+/**
+ * Callback to use when comparing items and values
+ */
+type ComparisonSorter<Item> = (first: Item, second: Item) => number;
+/**
+ * Direction to sort by
+ */
+type SortDirection = 'ascending' | 'descending';
+type Sorter<Item> = (array: Item[]) => Item[];
+/**
+ * Initialize a sort handler with sorters _(and an optional default direction)_
+ * @param sorters Sorters to use for sorting
+ * @param descending Sort in descending order? _(defaults to `false`; overridden by individual sorters)_
+ * @returns Sort handler
+ */
+declare function initializeSort<Item>(sorters: Array<ArraySorter<Item>>, descending?: boolean): Sorter<Item>;
+/**
+ * Initialize a sort handler with a sorter _(and an optional default direction)_
+ * @param sorter Sorter to use for sorting
+ * @param descending Sort in descending order? _(defaults to `false`; overridden by individual sorters)_
+ * @returns Sort handler
+ */
+declare function initializeSort<Item>(sorter: ArraySorter<Item>, descending?: boolean): Sorter<Item>;
+/**
+ * Initialize a sort handler _(with an optional default direction)_
+ * @param descending Sort in descending order? _(defaults to `false`)_
+ * @returns Sort handler
+ */
+declare function initializeSort<Item>(descending?: boolean): Sorter<Item>;
+/**
+ * Sort an array of items, using multiple sorters to sort by specific values
+ * @param array Array to sort
+ * @param sorters Sorters to use for sorting
+ * @param descending Sort in descending order? _(defaults to `false`; overridden by individual sorters)_
+ * @returns Sorted array
+ */
+declare function sort<Item>(array: Item[], sorters: Array<ArraySorter<Item>>, descending?: boolean): Item[];
+/**
+ * Sort an array of items, using multiple sorters to sort by specific values
+ * @param array Array to sort
+ * @param sorter Sorter to use for sorting
+ * @param descending Sort in descending order? _(defaults to `false`; overridden by individual sorters)_
+ * @returns Sorted array
+ */
+declare function sort<Item>(array: Item[], sorter: ArraySorter<Item>, descending?: boolean): Item[];
+/**
+ * Sort an array of items
+ * @param array Array to sort
+ * @param descending Sort in descending order? _(defaults to `false`)_
+ * @returns Sorted array
+ */
+declare function sort<Item>(array: Item[], descending?: boolean): Item[];
+declare namespace sort {
+  var initialize: typeof initializeSort;
+}
+declare const SORT_DIRECTION_ASCENDING: SortDirection;
+declare const SORT_DIRECTION_DESCENDING: SortDirection;
+//#endregion
 //#region src/array/swap.d.ts
 /**
  * Swap two smaller arrays within a larger array
@@ -2956,6 +2980,12 @@ declare function isNumber(value: unknown): value is number;
  * @returns `true` if the value is a plain object, otherwise `false`
  */
 declare function isPlainObject(value: unknown): value is PlainObject;
+/**
+ * - Is the value a primitive value?
+ * @param value Value to check
+ * @returns `true` if the value matches, otherwise `false`
+ */
+declare function isPrimitive(value: unknown): value is Primitive;
 /**
  * Is the value a typed array?
  * @param value Value to check
@@ -3006,12 +3036,6 @@ declare function isNumerical(value: unknown): value is number | `${number}`;
  * @returns `true` if the value matches, otherwise `false`
  */
 declare function isObject(value: unknown): value is object;
-/**
- * - Is the value a primitive value?
- * @param value Value to check
- * @returns `true` if the value matches, otherwise `false`
- */
-declare function isPrimitive(value: unknown): value is Primitive;
 //#endregion
 //#region src/logger.d.ts
 declare class Logger {
@@ -4327,4 +4351,4 @@ declare class SizedSet<Value = unknown> extends Set<Value> {
   get(value: Value, update?: boolean): Value | undefined;
 }
 //#endregion
-export { AnyResult, ArrayComparisonSorter, ArrayKeySorter, ArrayOrPlainObject, ArrayPosition, ArrayValueSorter, Asserter, AttemptFlow, AttemptFlowPromise, type Beacon, type BeaconOptions, BuiltIns, CancelableCallback, CancelablePromise, type Color, Constructor, DiffOptions, DiffResult, DiffValue, EqualOptions, Err, EventPosition, ExtendedErr, ExtendedResult, Flow, FlowPromise, FulfilledPromise, GenericAsyncCallback, GenericCallback, type HSLAColor, type HSLColor, HasValue, Key, KeyedValue, type Logger, type Memoized, type MemoizedOptions, MergeOptions, Merger, NestedArray, NestedKeys, NestedPartial, NestedValue, NestedValues, NumericalKeys, NumericalValues, type Observable, type Observer, Ok, OnceAsyncCallback, OnceCallback, PROMISE_ABORT_EVENT, PROMISE_ABORT_OPTIONS, PROMISE_ERROR_NAME, PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_MESSAGE_EXPECTATION_RESULT, PROMISE_MESSAGE_EXPECTATION_TIMED, PROMISE_MESSAGE_TIMEOUT, PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED, PlainObject, Primitive, PromiseData, PromiseHandlers, PromiseOptions, PromiseParameters, PromiseStrategy, PromiseTimeoutError, PromisesItems, PromisesOptions, PromisesResult, PromisesUnwrapped, PromisesValue, PromisesValues, type Queue, QueueError, type QueueOptions, type Queued, type RGBAColor, type RGBColor, RejectedPromise, RequiredKeys, Result, ResultMatch, RetryError, RetryOptions, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, Simplify, SizedMap, SizedSet, Smushed, SortDirection, type Subscription, TemplateOptions, type Time, ToString, TypedArray, Unsmushed, UnwrapValue, assert, attempt, attemptFlow, attemptPipe, 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, fromQuery, toPromise as fromResult, toPromise, getArray, getArrayPosition, getColor, getError, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getString, getTimedPromise, getUuid, getValue, groupBy, handleResult, 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, matchResult, 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, settlePromise, shuffle, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toQuery, toRecord, toResult, toSet, toggle, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };
+export { AnyResult, ArrayComparisonSorter, ArrayKeySorter, ArrayOrPlainObject, ArrayPosition, ArrayValueSorter, Asserter, AttemptFlow, AttemptFlowPromise, type Beacon, type BeaconOptions, BuiltIns, CancelableCallback, CancelablePromise, type Color, Constructor, DiffOptions, DiffResult, DiffValue, EqualOptions, Err, EventPosition, ExtendedErr, ExtendedResult, Flow, FlowPromise, FulfilledPromise, GenericAsyncCallback, GenericCallback, type HSLAColor, type HSLColor, HasValue, Key, KeyedValue, type Logger, type Memoized, type MemoizedOptions, MergeOptions, Merger, NestedArray, NestedKeys, NestedPartial, NestedValue, NestedValues, NumericalKeys, NumericalValues, type Observable, type Observer, Ok, OnceAsyncCallback, OnceCallback, PROMISE_ABORT_EVENT, PROMISE_ABORT_OPTIONS, PROMISE_ERROR_NAME, PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_MESSAGE_EXPECTATION_RESULT, PROMISE_MESSAGE_EXPECTATION_TIMED, PROMISE_MESSAGE_TIMEOUT, PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED, PlainObject, Primitive, PromiseData, PromiseHandlers, PromiseOptions, PromiseParameters, PromiseStrategy, PromiseTimeoutError, PromisesItems, PromisesOptions, PromisesResult, PromisesUnwrapped, PromisesValue, PromisesValues, type Queue, QueueError, type QueueOptions, type Queued, type RGBAColor, type RGBColor, RejectedPromise, RequiredKeys, Result, ResultMatch, RetryError, RetryOptions, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, Simplify, SizedMap, SizedSet, Smushed, SortDirection, Sorter, type Subscription, TemplateOptions, type Time, ToString, TypedArray, Unsmushed, UnwrapValue, assert, attempt, attemptFlow, attemptPipe, 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, fromQuery, toPromise as fromResult, toPromise, getArray, getArrayPosition, getColor, getError, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getString, getTimedPromise, getUuid, getValue, groupBy, handleResult, 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, matchResult, 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, settlePromise, shuffle, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toQuery, toRecord, toResult, toSet, toggle, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };