@oscarpalmer/atoms 0.218.0 → 0.219.0

package/dist/index.mjs

@@ -8,7 +8,7 @@ function getArrayCallback(value) {
 	switch (typeof value) {
 		case "function": return value;
 		case "number":
-		case "string": return typeof value === "string" && value.includes(".") ? void 0 : (obj) => obj[value];
+		case "string": return (obj) => obj?.[value];
 		default: return;
 	}
 }
@@ -21,6 +21,15 @@ function getArrayCallbacks(bool, key, value) {
 }
 //#endregion
 //#region src/internal/array/find.ts
+function addResult(result, mapped, flat) {
+	if (!flat) {
+		result.matched.push(mapped);
+		return;
+	}
+	const array = Array.isArray(mapped) ? mapped : [mapped];
+	const { length } = array;
+	for (let index = 0; index < length; index += 1) result.matched.push(array[index]);
+}
 function createFindParameters(original) {
 	const { length } = original;
 	return {
@@ -29,24 +38,27 @@ function createFindParameters(original) {
 		value: length === 1 && typeof original[0] !== "function" ? original[0] : original[1]
 	};
 }
+function findAbsoluteValueOrDefault(array, parameters, defaultValue, useDefaultValue, reversed) {
+	if (parameters.length === 0) {
+		if (Array.isArray(array) && array.length > 0) return reversed ? array.at(-1) : array[0];
+		return useDefaultValue ? defaultValue : void 0;
+	}
+	const index = findValue(ARRAY_FIND_VALUE_INDEX, array, parameters, reversed);
+	if (index === -1) return useDefaultValue ? defaultValue : void 0;
+	return array[index];
+}
 function findComplexValues(parameters) {
-	const { array, keyCallback, length, mapAfter, mapBefore, result, type, value } = parameters;
+	const { array, arrayLength, callback, limit, result, type, value } = parameters;
 	const keys = /* @__PURE__ */ new Set();
-	for (let index = 0; index < length; index += 1) {
-		const item = array[index];
-		let keyed;
-		let transformed;
-		if (mapBefore == null) {
-			keyed = keyCallback?.(item, index, array) ?? item;
-			transformed = item;
-		} else {
-			transformed = mapBefore(item, index, array);
-			keyed = keyCallback?.(transformed, index, array) ?? transformed;
-		}
+	for (let arrayIndex = 0; arrayIndex < arrayLength; arrayIndex += 1) {
+		const arrayItem = array[arrayIndex];
+		const keyed = callback == null ? arrayItem : callback(arrayItem, arrayIndex, array);
+		const mapped = arrayItem;
 		if (type === "all" && Object.is(keyed, value) || type === "unique" && !keys.has(keyed)) {
 			keys.add(keyed);
-			result.matched.push(mapAfter?.(item, index, array) ?? transformed);
-		} else result.notMatched.push(item);
+			result.matched.push(mapped);
+			if (result.matched.length >= limit) return result;
+		} else result.notMatched.push(arrayItem);
 	}
 	return result;
 }
@@ -54,13 +66,28 @@ function findSimpleValue(array, value, findIndex, reversed) {
 	if (findIndex) return reversed ? array.lastIndexOf(value) : array.indexOf(value);
 	return reversed ? array.findLast((item) => Object.is(item, value)) : array.find((item) => Object.is(item, value));
 }
-function findSimpleValues(array, length, value, boolCallback, mapBefore, mapAfter, result) {
-	const callback = boolCallback ?? ((item) => Object.is(item, value));
-	for (let index = 0; index < length; index += 1) {
-		const item = array[index];
-		const transformed = mapBefore?.(item, index, array) ?? item;
-		if (callback(transformed, index, array)) result.matched.push(mapAfter?.(item, index, array) ?? transformed);
-		else result.notMatched.push(item);
+function findSimpleValues(parameters) {
+	const { array, arrayLength, callback, flat, limit, map, result, value } = parameters;
+	const { after, before } = map ?? {};
+	const handler = callback ?? ((item) => Object.is(item, value));
+	for (let arrayIndex = 0; arrayIndex < arrayLength; arrayIndex += 1) {
+		const arrayItem = array[arrayIndex];
+		let mapped = before == null ? arrayItem : before(arrayItem, arrayIndex, array);
+		if (!flat || after != null) {
+			if (handler(mapped, arrayIndex, array)) {
+				mapped = after == null ? mapped : after(arrayItem, arrayIndex, array);
+				addResult(result, mapped, flat);
+				if (result.matched.length >= limit) return result;
+			} else result.notMatched.push(arrayItem);
+			continue;
+		}
+		const flatItems = Array.isArray(mapped) ? mapped : [mapped];
+		const flatLength = flatItems.length;
+		for (let flatIndex = 0; flatIndex < flatLength; flatIndex += 1) {
+			const flatItem = flatItems[flatIndex];
+			if (handler(flatItem, arrayIndex, array)) result.matched.push(flatItem);
+			else result.notMatched.push(flatItem);
+		}
 	}
 	return result;
 }
@@ -84,50 +111,42 @@ function findValueInArray(array, callback, value, findIndex, reversed) {
 	}
 	return findIndex ? -1 : void 0;
 }
-function findAbsoluteValueOrDefault(array, parameters, defaultValue, useDefaultValue, reversed) {
-	if (parameters.length === 0) {
-		if (Array.isArray(array) && array.length > 0) return reversed ? array.at(-1) : array[0];
-		return useDefaultValue ? defaultValue : void 0;
-	}
-	const index = findValue(ARRAY_FIND_VALUE_INDEX, array, parameters, reversed);
-	if (index === -1) return useDefaultValue ? defaultValue : void 0;
-	return array[index];
-}
-function findValues(type, array, parameters, mapper) {
+function findValues(type, array, parameters, options) {
 	const result = {
 		matched: [],
 		notMatched: []
 	};
-	if (!Array.isArray(array) || array.length === 0) return result;
-	const { length } = array;
+	if (!Array.isArray(array)) return result;
+	const arrayLength = array.length;
+	if (arrayLength === 0) return result;
 	const { bool, key, value } = createFindParameters(parameters);
 	const callbacks = getArrayCallbacks(bool, key);
-	if (type === "unique" && callbacks?.keyed == null && length >= 100) {
+	if (type === "unique" && callbacks?.keyed == null && arrayLength >= 100) {
 		result.matched = [...new Set(array)];
 		return result;
 	}
-	const mapCallback = getArrayCallback(mapper?.callback);
-	const mapReverse = mapper?.reverse ?? false;
-	let mapAfter;
-	let mapBefore;
-	if (mapCallback == null) {
-		mapAfter = void 0;
-		mapBefore = void 0;
-	} else {
-		mapAfter = mapReverse ? void 0 : mapCallback;
-		mapBefore = mapReverse ? mapCallback : void 0;
-	}
-	if (callbacks?.bool != null || type === "all" && key == null) return findSimpleValues(array, length, value, callbacks?.bool, mapBefore, mapAfter, result);
-	return findComplexValues({
+	const limit = options?.limit ?? Number.POSITIVE_INFINITY;
+	const flat = options?.map?.flat ?? false;
+	const mapCallback = getArrayCallback(options?.map?.callback);
+	const mapReverse = options?.map?.reverse ?? false;
+	let map;
+	if (mapCallback != null) map = {
+		before: mapReverse ? mapCallback : void 0,
+		after: mapReverse ? void 0 : mapCallback
+	};
+	const simple = callbacks?.bool != null || type === "all" && key == null;
+	const findParameters = {
 		array,
-		length,
-		mapAfter,
-		mapBefore,
+		arrayLength,
+		flat,
+		limit,
+		map,
 		result,
 		type,
 		value,
-		keyCallback: callbacks?.keyed
-	});
+		callback: simple ? callbacks?.bool : callbacks?.keyed
+	};
+	return simple ? findSimpleValues(findParameters) : findComplexValues(findParameters);
 }
 //#endregion
 //#region src/array/filter.ts
@@ -506,6 +525,13 @@ function startsWithArray(haystack, needle, key) {
 * @param value Number to round down
 * @param decimals Number of decimal places to round to _(defaults to `0`)_
 * @returns Rounded number, or `Number.NaN` if the value if unable to be rounded
+*
+* @example
+* ```typescript
+* floor(10.567, 2); // => 10.56
+* floor(10.567);    // => 10
+* floor('abc');       // => Number.NaN
+* ```
 */
 function floor(value, decimals) {
 	return roundNumber(Math.floor, value, decimals);
@@ -516,6 +542,13 @@ function floor(value, decimals) {
 * @param value Number to round
 * @param decimals Number of decimal places to round to _(defaults to `0`)_
 * @returns Rounded number, or `Number.NaN` if the value if unable to be rounded
+*
+* @example
+* ```typescript
+* round(10.567, 2); // => 10.57
+* round(10.567);    // => 11
+* round('abc');       // => Number.NaN
+* ```
 */
 function round(value, decimals) {
 	return roundNumber(Math.round, value, decimals);
@@ -573,6 +606,11 @@ const RANDOM_DIVISOR = 2 ** 32;
 *
 * @param array Original array
 * @returns Shuffled array
+*
+* @example
+* ```typescript
+* shuffle([1, 2, 3]); // => [3, 1, 2] (maybe? it's random, you know)
+* ```
 */
 function shuffle(array) {
 	if (!Array.isArray(array)) return [];
@@ -805,6 +843,12 @@ function push(array, pushed) {
 *
 * @param array Array to reverse
 * @returns Reversed array
+*
+* @example
+* ```typescript
+* reverse([1, 2, 3]);       // => [3, 2, 1]
+* reverse(['a', 'b', 'c']); // => ['c', 'b', 'a']
+* ```
 */
 function reverse(array) {
 	if (!Array.isArray(array)) return [];
@@ -822,7 +866,7 @@ function reverse(array) {
 //#endregion
 //#region src/array/single.ts
 function single(array, ...parameters) {
-	const { matched } = findValues("all", array, parameters);
+	const { matched } = findValues("all", array, parameters, { limit: 2 });
 	if (matched.length > 1) throw new Error(SINGLE_MESSAGE);
 	return matched[0];
 }
@@ -1053,22 +1097,28 @@ move.indices = moveIndices;
 move.toIndex = moveToIndex;
 //#endregion
 //#region src/array/select.ts
-function filterAndMap(array, ...parameters) {
-	return selectValues(array, parameters);
+function filterAndFlatMap(array, filter, mapper) {
+	return selectValues(array, filter, mapper, true, false);
+}
+function filterAndMap(array, filter, mapper) {
+	return selectValues(array, filter, mapper, false, false);
+}
+function flatMapAndFilter(array, mapper, filter) {
+	return selectValues(array, filter, mapper, true, true);
 }
-function mapAndFilter(array, ...parameters) {
-	return findValues("all", array, parameters, {
-		callback: parameters.shift(),
-		reverse: true
-	}).matched;
+function mapAndFilter(array, mapper, filter) {
+	return selectValues(array, filter, mapper, false, true);
 }
-function selectValues(array, parameters) {
-	return findValues("all", array, parameters, {
-		callback: parameters.pop(),
-		reverse: false
-	}).matched;
+function selectValues(array, filter, mapper, flat, reverse) {
+	return findValues("all", array, [filter], { map: {
+		flat,
+		reverse,
+		callback: mapper
+	} }).matched;
 }
+filterAndMap.flat = filterAndFlatMap;
 filterAndMap.reverse = mapAndFilter;
+mapAndFilter.flat = flatMapAndFilter;
 //#endregion
 //#region src/models/value/value.misc.model.ts
 const COMPARE_NAME = "compare";
@@ -1194,9 +1244,15 @@ function getString(value) {
 	const asString = String(value.valueOf?.() ?? value);
 	return asString.startsWith("[object ") ? JSON.stringify(value) : asString;
 }
+/**
+* @internal
+*/
 function ignoreKey(key) {
 	return STRING_EXPRESSION_IGNORED.test(key);
 }
+/**
+* @internal
+*/
 function interpolate(strings, values) {
 	const { length } = strings;
 	let interpolated = "";
@@ -1214,6 +1270,14 @@ function interpolate(strings, values) {
 * @param array Array of values
 * @param delimiter Delimiter to use between values
 * @returns Joined string
+* @example
+* ```typescript
+* join(['a', 'b', 'c']);          // => 'abc'
+* join(['a', 'b', 'c'], ', ');   // => 'a, b, c'
+* join(['a', '', 'c']);           // => 'ac'
+* join([null, 'b', undefined]);   // => 'b'
+* join([]);                       // => ''
+* ```
 */
 function join(array, delimiter) {
 	if (!Array.isArray(array)) return "";
@@ -1229,9 +1293,15 @@ function join(array, delimiter) {
 function tryCallback(value, callback) {
 	return unwrap(attempt(() => callback(value)), value);
 }
+/**
+* @internal
+*/
 function tryDecode(value) {
 	return tryCallback(value, decodeURIComponent);
 }
+/**
+* @internal
+*/
 function tryEncode(value) {
 	return tryCallback(value, encodeURIComponent);
 }
@@ -2219,6 +2289,13 @@ const EXPRESSION_WHITESPACE_ONLY = /^\s*$/;
 * @param minimum Minimum value
 * @param maximum Maximum value _(inclusive)_
 * @returns `true` if the value is between the minimum and maximum, otherwise `false`
+*
+* @example
+* ```typescript
+* between(5, 1, 10); // => true
+* between(0, 1, 10); // => false
+* between(10, 10, 10); // => true
+* ```
 */
 function between(value, minimum, maximum) {
 	if (![
@@ -2261,6 +2338,17 @@ function clamp(value, minimum, maximum, loop) {
 *
 * @param value Original value
 * @returns Original value as a number, or `Number.NaN` if the value is unable to be parsed
+*
+* @example
+* ```typescript
+* getNumber(null)       // => Number.NaN
+* getNumber('foo')      // => Number.NaN
+* getNumber('123')        // => 123
+* getNumber(true)       // => 1
+* getNumber([1, 2, 3])  // => Number.NaN
+* getNumber({a: 1})     // => Number.NaN
+* getNumber(() => 123)  // => 123
+* ```
 */
 function getNumber(value) {
 	if (typeof value === "number") return value;
@@ -2493,6 +2581,14 @@ const STRING_REPLACEMENT_CAMEL_CASE = "$1-$2";
 *
 * @param value String to convert
 * @returns Camel-cased string
+*
+* @example
+* ```typescript
+* camelCase('this is camel case'); // => 'thisIsCamelCase'
+* camelCase('ThisIsCamelCase');    // => 'thisIsCamelCase'
+* camelCase('this-is-camel-case'); // => 'thisIsCamelCase'
+* camelCase('this_is_camel_case'); // => 'thisIsCamelCase'
+* ```
 */
 function camelCase(value) {
 	return toCase(STRING_CASE_CAMEL, value, true, false);
@@ -2502,6 +2598,14 @@ function camelCase(value) {
 *
 * @param value String to capitalize
 * @returns Capitalized string
+*
+* @example
+* ```typescript
+* capitalize('this is a test'); // => 'This is a test'
+* capitalize('This Is A Test'); // => 'This is a test'
+* capitalize('t');              // => 'T'
+* capitalize('');               // => ''
+* ```
 */
 function capitalize(value) {
 	if (typeof value !== "string" || value.length === 0) return "";
@@ -2513,6 +2617,14 @@ function capitalize(value) {
 *
 * @param value String to convert
 * @returns Kebab-cased string
+*
+* @example
+* ```typescript
+* kebabCase('this is kebab case'); // => 'this-is-kebab-case'
+* kebabCase('ThisIsKebabCase');    // => 'this-is-kebab-case'
+* kebabCase('this-is-kebab-case'); // => 'this-is-kebab-case'
+* kebabCase('this_is_kebab_case'); // => 'this-is-kebab-case'
+* ```
 */
 function kebabCase(value) {
 	return toCase(STRING_CASE_KEBAB, value, false, false);
@@ -2522,6 +2634,13 @@ function kebabCase(value) {
 *
 * @param value String to convert
 * @returns Lower-cased string
+*
+* @example
+* ```typescript
+* lowerCase('THIS IS A TEST'); // => 'this is a test'
+* lowerCase('this is a test'); // => 'this is a test'
+* lowerCase('t');              // => 't'
+* ```
 */
 function lowerCase(value) {
 	if (typeof value !== "string") return "";
@@ -2533,6 +2652,14 @@ function lowerCase(value) {
 *
 * @param value String to convert
 * @returns Pascal-cased string
+*
+* @example
+* ```typescript
+* pascalCase('this is pascal case'); // => 'ThisIsPascalCase'
+* pascalCase('ThisIsPascalCase');    // => 'ThisIsPascalCase'
+* pascalCase('this-is-pascal-case'); // => 'ThisIsPascalCase'
+* pascalCase('this_is_pascal_case'); // => 'ThisIsPascalCase'
+* ```
 */
 function pascalCase(value) {
 	return toCase(STRING_CASE_PASCAL, value, true, true);
@@ -2542,6 +2669,14 @@ function pascalCase(value) {
 *
 * @param value String to convert
 * @returns Snake-cased string
+*
+* @example
+* ```typescript
+* snakeCase('this is snake case'); // => 'this_is_snake_case'
+* snakeCase('ThisIsSnakeCase');    // => 'this_is_snake_case'
+* snakeCase('this-is-snake-case'); // => 'this_is_snake_case'
+* snakeCase('this_is_snake_case'); // => 'this_is_snake_case'
+* ```
 */
 function snakeCase(value) {
 	return toCase(STRING_CASE_SNAKE, value, false, false);
@@ -2551,6 +2686,14 @@ function snakeCase(value) {
 *
 * @param value String to convert
 * @returns Title-cased string
+*
+* @example
+* ```typescript
+* titleCase('this is a test'); // => 'This Is A Test'
+* titleCase('This Is A Test'); // => 'This Is A Test'
+* titleCase('t');              // => 'T'
+* titleCase('');               // => ''
+* ```
 */
 function titleCase(value) {
 	if (typeof value !== "string" || value.length === 0) return "";
@@ -2593,6 +2736,14 @@ function toCaseCallback(value) {
 *
 * @param value String to convert
 * @returns Upper-cased string
+*
+* @example
+* ```typescript
+* upperCase('this is a test'); // => 'THIS IS A TEST'
+* upperCase('This Is A Test'); // => 'THIS IS A TEST'
+* upperCase('t');              // => 'T'
+* upperCase('');               // => ''
+* ```
 */
 function upperCase(value) {
 	if (typeof value !== "string" || value.length === 0) return "";
@@ -3337,6 +3488,9 @@ function isRejected(value) {
 function cancelable(executor) {
 	return new CancelablePromise(executor);
 }
+/**
+* @internal
+*/
 function handleResult(status, parameters) {
 	const { aborter, complete, data, handlers, index, key, value } = parameters;
 	if (aborter?.signal.aborted ?? false) return;
@@ -3360,6 +3514,9 @@ function handleResult(status, parameters) {
 		handlers.resolve(data.result);
 	}
 }
+/**
+* @internal
+*/
 function settlePromise(settler, value, aborter) {
 	aborter?.cancel();
 	settler(value);
@@ -3390,6 +3547,9 @@ function delay(options) {
 }
 //#endregion
 //#region src/promise/timed.ts
+/**
+* @internal
+*/
 async function getTimedPromise(promise, time, signal) {
 	const aborter = createAborter(signal, () => {
 		limiter.cancel();
@@ -3581,6 +3741,14 @@ const FUZZY_SYMBOL = Symbol(FUZZY_PROPERTY);
 * @param needle String to look for
 * @param ignoreCase Ignore case when matching? _(defaults to `false`)_
 * @returns `true` if the string ends with the given substring, otherwise `false`
+*
+* @example
+* ```typescript
+* endsWith('this is a test', 'test');          // => true
+* endsWith('this is a test', 'Test');          // => false
+* endsWith('this is a test', 'Test', true);    // => true
+* endsWith('this is a test', 'not');           // => false
+* ```
 */
 function endsWith(haystack, needle, ignoreCase) {
 	return match(STRING_MATCH_ENDS_WITH, haystack, needle, ignoreCase === true);
@@ -3592,6 +3760,14 @@ function endsWith(haystack, needle, ignoreCase) {
 * @param needle String to look for
 * @param ignoreCase Ignore case when matching? _(defaults to `false`)_
 * @returns `true` if the string includes the given substring, otherwise `false`
+*
+* @example
+* ```typescript
+* includes('this is a test', 'is');          // => true
+* includes('this is a test', 'Is');          // => false
+* includes('this is a test', 'Is', true);    // => true
+* includes('this is a test', 'not');         // => false
+* ```
 */
 function includes(haystack, needle, ignoreCase) {
 	return match(STRING_MATCH_INCLUDES, haystack, needle, ignoreCase === true);
@@ -3611,6 +3787,14 @@ function matchCallback(haystack, needle, ignoreCase) {
 * @param needle String to look for
 * @param ignoreCase Ignore case when matching? _(defaults to `false`)_
 * @returns `true` if the string starts with the given substring, otherwise `false`
+*
+* @example
+* ```typescript
+* startsWith('this is a test', 'this');          // => true
+* startsWith('this is a test', 'This');          // => false
+* startsWith('this is a test', 'This', true);    // => true
+* startsWith('this is a test', 'not');           // => false
+* ```
 */
 function startsWith(haystack, needle, ignoreCase) {
 	return match(STRING_MATCH_STARTS_WITH, haystack, needle, ignoreCase === true);
@@ -3855,7 +4039,7 @@ function getUuid(html) {
 *
 * @param value JSON string to parse
 * @param reviver Reviver function to transform the parsed values
-* @returns Parsed value or `undefined` if parsing fails
+* @returns Parsed value, or `undefined` if parsing fails
 */
 function parse(value, reviver) {
 	try {
@@ -3869,6 +4053,13 @@ function parse(value, reviver) {
 *
 * @param value String to trim
 * @returns Trimmed string
+* @example
+* ```typescript
+* trim('  this is a test  '); // => 'this is a test'
+* trim('this is a test');     // => 'this is a test'
+* trim('   ');                // => ''
+* trim('');                   // => ''
+* ```
 */
 function trim(value) {
 	return typeof value === "string" ? value.trim() : "";
@@ -3880,6 +4071,13 @@ function trim(value) {
 * @param length Maximum length of the string after truncation
 * @param suffix Suffix to append to the truncated string
 * @returns Truncated string
+* @example
+* ```typescript
+* truncate('this is a test', 7);          // => 'this is'
+* truncate('this is a test', 7, '...');   // => 'this ...'
+* truncate('this is a test', 20);         // => 'this is a test'
+* truncate('this is a test', 0);          // => ''
+* ```
 */
 function truncate(value, length, suffix) {
 	if (typeof value !== "string" || typeof length !== "number" || length === 0) return "";
@@ -5929,6 +6127,14 @@ function getHexaColor$1() {
 * @param value Value to normalize
 * @param alpha Include alpha channel _(opacity)_? _(defaults to `false`)_
 * @returns Normalized hex color
+*
+* @example
+* ```typescript
+* getNormalizedHex('#abc'); // => '#aabbcc'
+* getNormalizedHex('#abc', true); // => '#aabbccff'
+* getNormalizedHex(123); // => '#000000'
+* getNormalizedHex(123, true); // => '#000000ff'
+* ```
 */
 function getNormalizedHex(value, alpha) {
 	const includeAlpha = alpha === true;
@@ -6703,12 +6909,24 @@ function getTimeLoggerStop() {
 	}
 	return noop;
 }
+/**
+* Is the value a _Logger_?
+*
+* @param value Value to check
+* @returns `true` if the value is a _Logger_, otherwise `false`
+*/
 function isLogger(value) {
 	return isLoggerInstance(LOGGER_NAME, value);
 }
 function isLoggerInstance(name, value) {
 	return typeof value === "object" && value !== null && "$logger" in value && value["$logger"] === name;
 }
+/**
+* Is the value a _TimeLogger_?
+*
+* @param value Value to check
+* @returns `true` if the value is a _TimeLogger_, otherwise `false`
+*/
 function isTimeLogger(value) {
 	return isLoggerInstance(LOGGER_NAME_TIMED, value);
 }
@@ -6734,6 +6952,13 @@ function average(array, key) {
 * @param value Number to round up
 * @param decimals Number of decimal places to round to _(defaults to `0`)_
 * @returns Rounded number, or `Number.NaN` if the value if unable to be rounded
+*
+* @example
+* ```typescript
+* ceil(1.234, 2); // => 1.24
+* ceil(1.234);    // => 2
+* ceil('abc');    // => Number.NaN
+* ```
 */
 function ceil(value, decimals) {
 	return roundNumber(Math.ceil, value, decimals);
@@ -7353,4 +7578,4 @@ var SizedSet = class extends Set {
 	}
 };
 //#endregion
-export { CancelablePromise, Logger, PromiseTimeoutError, RetryError, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SizedMap, SizedSet, push as append, push, assert, assertCondition, assertDefined, assertInstanceOf, assertIs, assertProperty, assign, asyncAttempt, asyncAttemptRun, asyncDebounce, asyncFail, asyncFlow, asyncMatchResult, asyncOnce, asyncPipe, asyncRun, asyncSucceed, asyncThrottle, asyncUse, attempt, attemptAsyncFlow, attemptAsyncPipe, attemptFlow, attemptPipe, attemptPromise, attemptRun, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, copy, count, debounce, deburr, dedent, delay, deregisterCloner, deregisterComparator, deregisterEqualizer, diff, difference, drop, endsWith, endsWithArray, equal, error, exclude, exists, fail, filter, filterAndMap, filterAndMap as select, find, findLast, first, firstOrDefault, flatFreeze, flatten, floor, flow, freeze, fromQuery, toPromise as fromResult, toPromise, fuzzy, fuzzyMatch, getArray, getArrayComparison, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getHwbColor, getHwbaColor, getNormalizedHex, getNumber, getRandom, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloatingNumber as getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getSortedIndex, getString, getTimedPromise, getUuid, getValue, groupArraysBy, groupBy, handleResult, hasValue, hasValueResult, herald, hexToHsl, hexToHsla, hexToHwb, hexToHwba, hexToRgb, hexToRgba, hslToHex, hslToHwb, hslToHwba, hslToRgb, hslToRgba, hwbToHex, hwbToHsl, hwbToHsla, hwbToRgb, hwbToRgba, ignoreKey, inMap, inSet, includes, includesArray, indexOf, indexOfArray, initializeAssigner, initializeCloner, initializeEqualizer, initializeMerger, initializeNormalizer, initializeSorter, initializeTemplater, initializeTransformer, insert, interpolate, intersection, isArrayOrPlainObject, isAsyncFailure, isAsyncGenerator, isAsyncGeneratorFunction, isAsyncOnce, isAsyncPlan, isAsyncStep, isAsyncSuccess, isBeacon, isBeaconSubscription, isColor, isConstructor, isEmpty, isError, isFailure, isFrozen, isFulfilled, isFuzzy, isGenerator, isGeneratorFunction, isHerald, isHeraldEvents, isHeraldSubscription, isHexColor, isHslColor, isHslaColor, isHwbColor, isHwbaColor, isInstanceOf, isKey, isKeyedQueue, isLogger, isNonArrayOrPlainObject, isNonConstructor, isNonEmpty, isNonInstanceOf, isNonKey, isNonNullable, isNonNullableOrEmpty, isNonNullableOrWhitespace, isNonNumber, isNonNumerical, isNonObject, isNonPlainObject, isNonPrimitive, isNonTemplateStringsArray, isNonTypedArray, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isObservable, isOk, isOnce, isPlainObject, isPlan, isPrimitive, isQueue, isQueueInstance, isRejected, isResult, isRgbColor, isRgbaColor, isSorted, isStep, isSubscription, isSubscriptions, isSuccess, isTemplateStringsArray, isTimeLogger, isTypedArray, join, kebabCase, keyedQueue, last, lastIndexOf, lastOrDefault, lowerCase, mapAndFilter, mapAndFilter as reverseSelect, matchResult, max, median, memoize, merge, min, move, moveIndices, moveToIndex, noop, normalize, ok, omit, once, parse, partition, pascalCase, pick, pipe, plan, promises, queue, range, registerCloner, registerComparator, registerEqualizer, resultPromises, retry, reverse, rgbToHex, rgbToHsl, rgbToHsla, rgbToHwb, rgbToHwba, round, run, setValue, settlePromise, shake, shuffle, single, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, subscriptions, succeed, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toMapArrays, toQuery, toRecord, toRecordArrays, toResult, toSet, toggle, transform, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, use, words };
+export { CancelablePromise, Logger, PromiseTimeoutError, RetryError, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SizedMap, SizedSet, push as append, push, assert, assertCondition, assertDefined, assertInstanceOf, assertIs, assertProperty, assign, asyncAttempt, asyncAttemptRun, asyncDebounce, asyncFail, asyncFlow, asyncMatchResult, asyncOnce, asyncPipe, asyncRun, asyncSucceed, asyncThrottle, asyncUse, attempt, attemptAsyncFlow, attemptAsyncPipe, attemptFlow, attemptPipe, attemptPromise, attemptRun, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, copy, count, debounce, deburr, dedent, delay, deregisterCloner, deregisterComparator, deregisterEqualizer, diff, difference, drop, endsWith, endsWithArray, equal, error, exclude, exists, fail, filter, filterAndFlatMap, filterAndMap, filterAndMap as select, find, findLast, first, firstOrDefault, flatFreeze, flatMapAndFilter, flatten, floor, flow, freeze, fromQuery, toPromise as fromResult, toPromise, fuzzy, fuzzyMatch, getArray, getArrayComparison, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getHwbColor, getHwbaColor, getNormalizedHex, getNumber, getRandom, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloatingNumber as getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getSortedIndex, getString, getTimedPromise, getUuid, getValue, groupArraysBy, groupBy, handleResult, hasValue, hasValueResult, herald, hexToHsl, hexToHsla, hexToHwb, hexToHwba, hexToRgb, hexToRgba, hslToHex, hslToHwb, hslToHwba, hslToRgb, hslToRgba, hwbToHex, hwbToHsl, hwbToHsla, hwbToRgb, hwbToRgba, ignoreKey, inMap, inSet, includes, includesArray, indexOf, indexOfArray, initializeAssigner, initializeCloner, initializeEqualizer, initializeMerger, initializeNormalizer, initializeSorter, initializeTemplater, initializeTransformer, insert, interpolate, intersection, isArrayOrPlainObject, isAsyncFailure, isAsyncGenerator, isAsyncGeneratorFunction, isAsyncOnce, isAsyncPlan, isAsyncStep, isAsyncSuccess, isBeacon, isBeaconSubscription, isColor, isConstructor, isEmpty, isError, isFailure, isFrozen, isFulfilled, isFuzzy, isGenerator, isGeneratorFunction, isHerald, isHeraldEvents, isHeraldSubscription, isHexColor, isHslColor, isHslaColor, isHwbColor, isHwbaColor, isInstanceOf, isKey, isKeyedQueue, isLogger, isNonArrayOrPlainObject, isNonConstructor, isNonEmpty, isNonInstanceOf, isNonKey, isNonNullable, isNonNullableOrEmpty, isNonNullableOrWhitespace, isNonNumber, isNonNumerical, isNonObject, isNonPlainObject, isNonPrimitive, isNonTemplateStringsArray, isNonTypedArray, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isObservable, isOk, isOnce, isPlainObject, isPlan, isPrimitive, isQueue, isRejected, isResult, isRgbColor, isRgbaColor, isSorted, isStep, isSubscription, isSubscriptions, isSuccess, isTemplateStringsArray, isTimeLogger, isTypedArray, join, kebabCase, keyedQueue, last, lastIndexOf, lastOrDefault, lowerCase, mapAndFilter, mapAndFilter as reverseSelect, matchResult, max, median, memoize, merge, min, move, moveIndices, moveToIndex, noop, normalize, ok, omit, once, parse, partition, pascalCase, pick, pipe, plan, promises, queue, range, registerCloner, registerComparator, registerEqualizer, resultPromises, retry, reverse, rgbToHex, rgbToHsl, rgbToHsla, rgbToHwb, rgbToHwba, round, run, setValue, settlePromise, shake, shuffle, single, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, subscriptions, succeed, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toMapArrays, toQuery, toRecord, toRecordArrays, toResult, toSet, toggle, transform, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, use, words };

package/dist/internal/array/callbacks.mjs

@@ -3,7 +3,7 @@ function getArrayCallback(value) {
 	switch (typeof value) {
 		case "function": return value;
 		case "number":
-		case "string": return typeof value === "string" && value.includes(".") ? void 0 : (obj) => obj[value];
+		case "string": return (obj) => obj?.[value];
 		default: return;
 	}
 }

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

@@ -1,8 +1,8 @@
-import { ArrayFindMapper, ArrayFindValueType, ArrayFindValuesResult, ArrayFindValuesType, ArrayParameters } from "../../models/array/array.find.model.mjs";
+import { ArrayFindOptions, ArrayFindValueType, ArrayFindValuesResult, ArrayFindValuesType, ArrayParameters } from "../../models/array/array.find.model.mjs";
 //#region src/internal/array/find.d.ts
 export declare function createFindParameters(original: unknown[]): ArrayParameters;
+export declare function findAbsoluteValueOrDefault(array: unknown[], parameters: unknown[], defaultValue: unknown, useDefaultValue: boolean, reversed: boolean): unknown;
 export declare function findValue(type: Exclude<ArrayFindValueType, "item">, array: unknown[], parameters: unknown[], reversed: boolean): number;
 export declare function findValue(type: Exclude<ArrayFindValueType, "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: ArrayFindValuesType, array: unknown[], parameters: unknown[], mapper?: ArrayFindMapper): ArrayFindValuesResult;
+export declare function findValues(type: ArrayFindValuesType, array: unknown[], parameters: unknown[], options?: ArrayFindOptions): ArrayFindValuesResult;
 //#endregion