@oscarpalmer/atoms 0.118.0 → 0.119.0

package/dist/atoms.full.js

@@ -5,25 +5,21 @@ function calculate() {
 		function step(now) {
 			if (last != null) values.push(now - last);
 			last = now;
-			if (values.length >= CALCULATION_TOTAL) resolve(values.sort().slice(CALCULATION_TRIM_PART, -CALCULATION_TRIM_PART).reduce((first, second) => first + second, 0) / (values.length - CALCULATION_TRIM_TOTAL));
+			if (values.length >= TOTAL) resolve(values.sort().slice(TRIM_PART, -TRIM_PART).reduce((first, second) => first + second, 0) / (values.length - TRIM_TOTAL));
 			else requestAnimationFrame(step);
 		}
 		requestAnimationFrame(step);
 	});
 }
-const CALCULATION_TOTAL = 10;
-const CALCULATION_TRIM_PART = 2;
-const CALCULATION_TRIM_TOTAL = 4;
-let FRAME_RATE_MS = 1e3 / 60;
-calculate().then((value) => {
-	FRAME_RATE_MS = value;
-});
-var frame_rate_default = FRAME_RATE_MS;
+const TOTAL = 10;
+const TRIM_PART = 2;
+const TRIM_TOTAL = 4;
+var frame_rate_default = await calculate();
 function chunk(array, size) {
 	if (!Array.isArray(array)) return [];
 	if (array.length === 0) return [];
 	const { length } = array;
-	const actualSize = typeof size === "number" && size > 0 && size <= DEFAULT_SIZE ? size : DEFAULT_SIZE;
+	const actualSize = typeof size === "number" && size > 0 && size <= MAX_SIZE ? size : MAX_SIZE;
 	if (length <= actualSize) return [array];
 	const chunks = [];
 	let index = 0;
@@ -33,15 +29,15 @@ function chunk(array, size) {
 	}
 	return chunks;
 }
-const DEFAULT_SIZE = 5e3;
+const MAX_SIZE = 5e3;
 function compact(array, strict) {
 	if (!Array.isArray(array)) return [];
+	if (strict === true) return array.filter(Boolean);
 	const { length } = array;
-	const isStrict = strict ?? false;
 	const compacted = [];
 	for (let index = 0; index < length; index += 1) {
 		const item = array[index];
-		if (isStrict && !!item || !isStrict && item != null) compacted.push(item);
+		if (item != null) compacted.push(item);
 	}
 	return compacted;
 }
@@ -76,15 +72,18 @@ const TYPED_ARRAYS = new Set([
 	BigInt64Array,
 	BigUint64Array
 ]);
-function getRandomFloat(minimum, maximum) {
+function _getRandomFloat(inclusive, minimum, maximum) {
 	let maxFloat = isNumber(maximum) && maximum <= Number.MAX_SAFE_INTEGER ? maximum : Number.MAX_SAFE_INTEGER;
 	let minFloat = isNumber(minimum) && minimum >= Number.MIN_SAFE_INTEGER ? minimum : Number.MIN_SAFE_INTEGER;
 	if (minFloat === maxFloat) return minFloat;
 	if (minFloat > maxFloat) [minFloat, maxFloat] = [maxFloat, minFloat];
-	return Math.random() * (maxFloat + 1 - minFloat) + minFloat;
+	return Math.random() * (maxFloat + (inclusive ? 1 : 0) - minFloat) + minFloat;
+}
+function getRandomFloat(minimum, maximum) {
+	return _getRandomFloat(false, minimum, maximum);
 }
 function getRandomInteger(minimum, maximum) {
-	return Math.floor(getRandomFloat(minimum, maximum));
+	return Math.floor(_getRandomFloat(true, minimum, maximum));
 }
 function shuffle(array) {
 	if (!Array.isArray(array)) return [];
@@ -219,7 +218,8 @@ function insertChunkedValues(type, array, items, start, deleteCount) {
 	const lastIndex = chunked.length - 1;
 	let index = Number(chunked.length);
 	let returned;
-	while (--index >= 0) {
+	while (index > 0) {
+		index -= 1;
 		const result = array.splice(actualStart, index === lastIndex ? actualDeleteCount : 0, ...chunked[index]);
 		if (returned == null) returned = result;
 		else returned.push(...result);
@@ -229,8 +229,7 @@ function insertChunkedValues(type, array, items, start, deleteCount) {
 }
 function insertValues(type, array, items, start, deleteCount) {
 	const spliceArray = type === "insert" || type === "splice";
-	if (!Array.isArray(array) || typeof start !== "number") return spliceArray ? [] : 0;
-	if (!Array.isArray(items) || items.length === 0) return spliceArray ? [] : 0;
+	if (!Array.isArray(array) || typeof start !== "number" || !Array.isArray(items) || items.length === 0) return spliceArray ? [] : 0;
 	return insertChunkedValues(type, array, items, start, spliceArray ? deleteCount : 0);
 }
 function insert(array, indexOrItems, items) {
@@ -265,11 +264,15 @@ function aggregate(type, array, key) {
 	};
 }
 function max(array, key) {
-	return aggregate("max", array, key).value;
+	return getAggregated("max", array, key);
 }
 function calculateSum(current, value, notNumber) {
 	return notNumber ? value : current + value;
 }
+function getAggregated(type, array, key) {
+	const aggregated = aggregate(type, array, key);
+	return aggregated.count > 0 ? aggregated.value : NaN;
+}
 const aggregators = {
 	average: calculateSum,
 	max: (current, value, notNumber) => notNumber || value > current ? value : current,
@@ -772,8 +775,12 @@ function getForegroundColor(value) {
 		green / MAX_HEX,
 		red / MAX_HEX
 	];
-	for (let color of values) if (color <= SRGB_LUMINANCE_MINIMUM) color /= SRGB_LUMINANCE_MULTIPLIER;
-	else color = ((color + SRGB_LUMINANCE_OFFSET) / SRGB_LUMINANCE_MODIFIER) ** SRGB_LUMINANCE_EXPONENT;
+	const { length } = values;
+	for (let index = 0; index < length; index += 1) {
+		const color = values[index];
+		if (color <= SRGB_LUMINANCE_MINIMUM) values[index] /= SRGB_LUMINANCE_MULTIPLIER;
+		else values[index] = ((color + SRGB_LUMINANCE_OFFSET) / SRGB_LUMINANCE_MODIFIER) ** SRGB_LUMINANCE_EXPONENT;
+	}
 	return new Color(SRGB_LUMINANCE_RED * values[2] + SRGB_LUMINANCE_GREEN * values[1] + SRGB_LUMINANCE_BLUE * values[0] > SRGB_LUMINANCE_THRESHOLD ? HEX_BLACK : HEX_WHITE);
 }
 function getHexaColor(value) {
@@ -1103,6 +1110,34 @@ var Color = class {
 function getColor(value) {
 	return isColor(value) ? value : new Color(value);
 }
+function isEmpty(value) {
+	if (value == null) return true;
+	if (typeof value === "string") return value.length === 0;
+	const values = getArray(value);
+	const { length } = values;
+	for (let index = 0; index < length; index += 1) if (values[index] != null) return false;
+	return true;
+}
+function isNullable(value) {
+	return value == null;
+}
+function isNullableOrEmpty(value) {
+	return value == null || getString(value) === "";
+}
+function isNullableOrWhitespace(value) {
+	return value == null || EXPRESSION_WHITESPACE.test(getString(value));
+}
+function isNumerical(value) {
+	return isNumber(value) || typeof value === "string" && value.trim().length > 0 && !Number.isNaN(+value);
+}
+function isObject(value) {
+	return typeof value === "object" && value !== null || typeof value === "function";
+}
+function isPrimitive(value) {
+	return value == null || EXPRESSION_PRIMITIVE.test(typeof value);
+}
+const EXPRESSION_PRIMITIVE = /^(bigint|boolean|number|string|symbol)$/;
+const EXPRESSION_WHITESPACE = /^\s*$/;
 var SizedMap = class extends Map {
 	#maximumSize;
 	get full() {
@@ -1181,10 +1216,10 @@ var Memoized = class {
 	get size() {
 		return this.#state.cache?.size ?? NaN;
 	}
-	constructor(callback, size) {
-		const cache = new SizedMap(size);
+	constructor(callback, options) {
+		const cache = new SizedMap(options.cacheSize);
 		const getter = (...parameters) => {
-			const key = parameters.length === 1 ? parameters[0] : join(parameters.map(getString), "_");
+			const key = options.cacheKey?.(...parameters) ?? (parameters.length === 1 ? parameters[0] : join(parameters.map(getString), "_"));
 			if (cache.has(key)) return cache.get(key);
 			const value = callback(...parameters);
 			cache.set(key, value);
@@ -1218,89 +1253,49 @@ var Memoized = class {
 	}
 };
 function debounce(callback, time) {
-	const interval = typeof time === "number" && time >= frame_rate_default ? time : frame_rate_default;
-	function step(now, parameters) {
-		if (interval === frame_rate_default || now - start >= interval) callback(...parameters);
-		else frame = requestAnimationFrame((next) => {
-			step(next, parameters);
-		});
-	}
-	let frame;
-	let start;
-	const debounced = (...parameters) => {
-		debounced.cancel();
-		frame = requestAnimationFrame((now) => {
-			start = now - frame_rate_default;
-			step(now, parameters);
-		});
-	};
-	debounced.cancel = () => {
-		if (frame != null) {
-			cancelAnimationFrame(frame);
-			frame = void 0;
-		}
-	};
-	return debounced;
+	return getLimiter(callback, false, time);
 }
-function memoize(callback, cacheSize) {
-	return new Memoized(callback, typeof cacheSize === "number" && cacheSize > 0 ? cacheSize : DEFAULT_CACHE_SIZE);
-}
-function throttle(callback, time) {
+function getLimiter(callback, throttler, time) {
 	const interval = typeof time === "number" && time >= frame_rate_default ? time : frame_rate_default;
 	function step(now, parameters) {
-		if (interval === frame_rate_default || now - last >= interval) {
-			last = now;
+		if (interval === frame_rate_default || now - timestamp >= interval) {
+			if (throttler) timestamp = now;
 			callback(...parameters);
 		} else frame = requestAnimationFrame((next) => {
 			step(next, parameters);
 		});
 	}
-	let last;
 	let frame;
-	const throttler = (...parameters) => {
-		throttler.cancel();
+	let timestamp;
+	const limiter = (...parameters) => {
+		limiter.cancel();
 		frame = requestAnimationFrame((now) => {
-			last ??= now - frame_rate_default;
+			timestamp ??= now - frame_rate_default;
 			step(now, parameters);
 		});
 	};
-	throttler.cancel = () => {
+	limiter.cancel = () => {
 		if (frame != null) {
 			cancelAnimationFrame(frame);
 			frame = void 0;
 		}
 	};
-	return throttler;
+	return limiter;
 }
-const DEFAULT_CACHE_SIZE = 65536;
-function isEmpty(value) {
-	if (value == null) return true;
-	if (typeof value === "string") return value.length === 0;
-	const values = getArray(value);
-	const { length } = values;
-	for (let index = 0; index < length; index += 1) if (values[index] != null) return false;
-	return true;
-}
-function isNullable(value) {
-	return value == null;
-}
-function isNullableOrEmpty(value) {
-	return value == null || getString(value) === "";
-}
-function isNullableOrWhitespace(value) {
-	return value == null || EXPRESSION_WHITESPACE.test(getString(value));
-}
-function isNumerical(value) {
-	return isNumber(value) || typeof value === "string" && value.trim().length > 0 && !Number.isNaN(+value);
+function getMemoizationOptions(input) {
+	const { cacheKey, cacheSize } = isPlainObject(input) ? input : {};
+	return {
+		cacheKey: typeof cacheKey === "function" ? cacheKey : void 0,
+		cacheSize: typeof cacheSize === "number" && cacheSize > 0 ? cacheSize : DEFAULT_CACHE_SIZE
+	};
 }
-function isObject(value) {
-	return typeof value === "object" && value !== null || typeof value === "function";
+function memoize(callback, options) {
+	return new Memoized(callback, getMemoizationOptions(options));
 }
-function isPrimitive(value) {
-	return value == null || EXPRESSION_PRIMITIVE.test(typeof value);
+function throttle(callback, time) {
+	return getLimiter(callback, true, time);
 }
-const EXPRESSION_PRIMITIVE = /^(bigint|boolean|number|string|symbol)$/;
-const EXPRESSION_WHITESPACE = /^\s*$/;
+const DEFAULT_CACHE_SIZE = 1024;
 let enabled = true;
 var Logger = class {
 	get debug() {
@@ -1338,8 +1333,21 @@ var Logger = class {
 	}
 };
 var Time = class {
+	#logger;
+	#stopper;
 	#state;
+	get active() {
+		return this.#state.started && !this.#state.stopped && enabled;
+	}
+	get log() {
+		return this.active ? this.#logger : noop;
+	}
+	get stop() {
+		return this.active ? this.#stopTimer() : noop;
+	}
 	constructor(label) {
+		this.#logger = console.timeLog.bind(console, label);
+		this.#stopper = console.timeEnd.bind(console, label);
 		this.#state = {
 			label,
 			started: enabled,
@@ -1347,14 +1355,12 @@ var Time = class {
 		};
 		if (this.#state.started) console.time(label);
 	}
-	log() {
-		if (this.#state.started && !this.#state.stopped && enabled) console.timeLog(this.#state.label);
-	}
-	stop() {
-		if (this.#state.started && !this.#state.stopped) {
-			this.#state.stopped = true;
-			console.timeEnd(this.#state.label);
-		}
+	#stopTimer() {
+		const stopper = this.#stopper;
+		this.#state.stopped = true;
+		this.#logger = void 0;
+		this.#stopper = void 0;
+		return stopper;
 	}
 };
 const logger = new Logger();
@@ -1376,8 +1382,7 @@ function count(array, key, value) {
 	return counted;
 }
 function min(array, key) {
-	const aggregated = aggregate("min", array, key);
-	return aggregated.count > 0 ? aggregated.value : NaN;
+	return getAggregated("min", array, key);
 }
 function round(value, decimals) {
 	if (typeof value !== "number") return NaN;
@@ -1386,8 +1391,7 @@ function round(value, decimals) {
 	return Math.round((value + Number.EPSILON) * mod) / mod;
 }
 function sum(array, key) {
-	const aggregated = aggregate("sum", array, key);
-	return aggregated.count > 0 ? aggregated.value : NaN;
+	return getAggregated("sum", array, key);
 }
 function findKey(needle, haystack) {
 	const keys = Object.keys(haystack);
@@ -1525,33 +1529,44 @@ const BOOLEAN_MODIFIER = .5;
 const HEX_CHARACTERS = "0123456789ABCDEF";
 const HEX_MAXIMUM = 15;
 function camelCase(value) {
-	return toCase(value, "", true, false);
+	return toCase(TYPE_CAMEL, value, true, false);
 }
 function capitalize(value) {
 	if (typeof value !== "string" || value.length === 0) return "";
-	return value.length === 1 ? value.toLocaleUpperCase() : `${value.charAt(0).toLocaleUpperCase()}${value.slice(1).toLocaleLowerCase()}`;
+	memoizedCapitalize ??= memoize((v) => v.length === 1 ? v.toLocaleUpperCase() : `${v.charAt(0).toLocaleUpperCase()}${v.slice(1).toLocaleLowerCase()}`);
+	return memoizedCapitalize.run(value);
 }
 function kebabCase(value) {
-	return toCase(value, "-", false, false);
+	return toCase(TYPE_KEBAB, value, false, false);
 }
 function pascalCase(value) {
-	return toCase(value, "", true, true);
+	return toCase(TYPE_PASCAL, value, true, true);
 }
 function snakeCase(value) {
-	return toCase(value, "_", false, false);
+	return toCase(TYPE_SNAKE, value, false, false);
 }
 function titleCase(value) {
 	if (typeof value !== "string") return "";
-	return value.length < 1 ? capitalize(value) : join(words(value).map(capitalize), " ");
-}
-function toCase(value, delimiter, capitalizeAny, capitalizeFirst) {
+	memoizedTitleCase ??= memoize((v) => v.length < 1 ? capitalize(v) : join(words(v).map(capitalize), " "));
+	return memoizedTitleCase.run(value);
+}
+function toCase(type, value, capitalizeAny, capitalizeFirst) {
+	memoizers[type] ??= memoize(toCaseCallback.bind({
+		type,
+		capitalizeAny,
+		capitalizeFirst
+	}));
+	return memoizers[type].run(value);
+}
+function toCaseCallback(value) {
 	if (typeof value !== "string") return "";
 	if (value.length < 1) return value;
+	const { capitalizeAny, capitalizeFirst, type } = this;
 	const parts = words(value);
 	const partsLength = parts.length;
 	const result = [];
 	for (let partIndex = 0; partIndex < partsLength; partIndex += 1) {
-		const items = parts[partIndex].replace(EXPRESSION_ACRONYM, (full, one, two, three) => three === "s" ? full : `${one}-${two}${three}`).replace(EXPRESSION_CAMEL_CASE, "$1-$2").split("-");
+		const items = parts[partIndex].replace(EXPRESSION_ACRONYM, (full, one, two, three) => three === "s" ? full : `${one}-${two}${three}`).replace(EXPRESSION_CAMEL_CASE, REPLACEMENT_CAMEL_CASE).split("-");
 		const itemsLength = items.length;
 		const partResult = [];
 		let itemCount = 0;
@@ -1562,17 +1577,42 @@ function toCase(value, delimiter, capitalizeAny, capitalizeFirst) {
 			else partResult.push(capitalize(item));
 			itemCount += 1;
 		}
-		result.push(join(partResult, delimiter));
+		result.push(join(partResult, delimiters[type]));
 	}
-	return join(result, delimiter);
+	return join(result, delimiters[type]);
 }
 const EXPRESSION_CAMEL_CASE = /(\p{Ll})(\p{Lu})/gu;
 const EXPRESSION_ACRONYM = /(\p{Lu}*)(\p{Lu})(\p{Ll}+)/gu;
+const REPLACEMENT_CAMEL_CASE = "$1-$2";
+const TYPE_CAMEL = "camel";
+const TYPE_KEBAB = "kebab";
+const TYPE_PASCAL = "pascal";
+const TYPE_SNAKE = "snake";
+const delimiters = {
+	[TYPE_CAMEL]: "",
+	[TYPE_KEBAB]: "-",
+	[TYPE_PASCAL]: "",
+	[TYPE_SNAKE]: "_"
+};
+const memoizers = {};
+let memoizedCapitalize;
+let memoizedTitleCase;
 function createUuid() {
-	return TEMPLATE_UUID.replace(EXPRESSION_UUID_PART, (substring) => {
-		const digit = Number.parseInt(substring, 10);
-		return (digit ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> digit / 4).toString(16);
-	});
+	return getUuid();
+}
+function getUuid() {
+	const bytes = new Uint8Array(16);
+	crypto.getRandomValues(bytes);
+	bytes[6] = bytes[6] & 15 | 64;
+	bytes[8] = bytes[8] & 63 | 128;
+	const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+	return [
+		hex.substring(0, 8),
+		hex.substring(8, 12),
+		hex.substring(12, 16),
+		hex.substring(16, 20),
+		hex.substring(20, 32)
+	].join("-");
 }
 function parse(value, reviver) {
 	try {
@@ -1582,14 +1622,14 @@ function parse(value, reviver) {
 	}
 }
 function truncate(value, length, suffix) {
-	if (typeof value !== "string" || typeof length !== "number" || length <= 0) return "";
+	if (typeof value !== "string" || typeof length !== "number" || length === 0) return "";
 	if (length >= value.length) return value;
 	const actualSuffix = typeof suffix === "string" ? suffix : "";
-	const truncatedLength = length - actualSuffix.length;
+	const actualSuffixLength = actualSuffix.length;
+	if (length <= actualSuffixLength) return actualSuffix;
+	const truncatedLength = length - actualSuffixLength;
 	return `${value.slice(0, truncatedLength)}${actualSuffix}`;
 }
-const EXPRESSION_UUID_PART = /[018]/g;
-const TEMPLATE_UUID = "10000000-1000-4000-8000-100000000000";
 function getValue(data, path, ignoreCase) {
 	if (typeof data !== "object" || data === null || typeof path !== "string" || path.trim().length === 0) return;
 	const shouldIgnoreCase = ignoreCase === true;
@@ -1601,24 +1641,43 @@ function getValue(data, path, ignoreCase) {
 	while (index < length && value != null) value = handleValue(value, paths[index++], null, true, shouldIgnoreCase);
 	return value;
 }
-function template(value, variables, options) {
+function getTemplateOptions(input) {
+	const options = isPlainObject(input) ? input : {};
+	return {
+		ignoreCase: options.ignoreCase === true,
+		pattern: options.pattern instanceof RegExp ? options.pattern : EXPRESSION_VARIABLE
+	};
+}
+function handleTemplate(value, pattern, ignoreCase, variables) {
 	if (typeof value !== "string") return "";
 	if (typeof variables !== "object" || variables === null) return value;
-	const hasOptions = typeof options === "object" && options != null;
-	const ignoreCase = hasOptions && options?.ignoreCase === true;
-	const pattern = hasOptions && options?.pattern instanceof RegExp ? options.pattern : EXPRESSION_VARIABLE;
 	const values = {};
 	return value.replace(pattern, (_, key) => {
-		if (values[key] != null) return values[key];
-		const templateValue = getValue(variables, key, ignoreCase);
-		values[key] = templateValue == null ? "" : getString(templateValue);
+		if (values[key] == null) {
+			const templateValue = getValue(variables, key, ignoreCase);
+			values[key] = templateValue == null ? "" : getString(templateValue);
+		}
 		return values[key];
 	});
 }
+const template = ((value, variables, options) => {
+	const { ignoreCase, pattern } = getTemplateOptions(options);
+	return handleTemplate(value, pattern, ignoreCase, variables);
+});
+template.initialize = (options) => {
+	const { ignoreCase, pattern } = getTemplateOptions(options);
+	return (value, variables) => {
+		return handleTemplate(value, pattern, ignoreCase, variables);
+	};
+};
 const EXPRESSION_VARIABLE = /{{([\s\S]+?)}}/g;
-function equal(first, second, options) {
+const equal = ((first, second, options) => {
 	return equalValue(first, second, getEqualOptions(options));
-}
+});
+equal.initialize = (options) => {
+	const actual = getEqualOptions(options);
+	return (first, second) => equalValue(first, second, actual);
+};
 function equalArray(first, second, options) {
 	const { length } = first;
 	if (length !== second.length) return false;
@@ -1932,7 +1991,7 @@ function setChanges(parameters) {
 	const diffsLength = diffs.length;
 	for (let diffIndex = 0; diffIndex < diffsLength; diffIndex += 1) changes.push(diffs[diffIndex]);
 }
-function getOptions(options) {
+function getMergeOptions(options) {
 	const actual = {
 		replaceableObjects: void 0,
 		skipNullableInArrays: false
@@ -1946,10 +2005,16 @@ function getReplaceableObjects(value) {
 	const items = (Array.isArray(value) ? value : [value]).filter((item) => typeof item === "string" || item instanceof RegExp);
 	if (items.length > 0) return (name) => items.some((item) => typeof item === "string" ? item === name : item.test(name));
 }
-function merge(values, options) {
-	if (!Array.isArray(values) || values.length === 0) return {};
-	return mergeValues(values, getOptions(options), true);
+function handleMerge(values, options) {
+	return !Array.isArray(values) || values.length === 0 ? {} : mergeValues(values, options, true);
 }
+const merge = ((values, options) => {
+	return handleMerge(values, getMergeOptions(options));
+});
+merge.initialize = (options) => {
+	const actual = getMergeOptions(options);
+	return (values) => handleMerge(values, actual);
+};
 function mergeObjects(values, options, prefix) {
 	const { length } = values;
 	const isArray = values.every(Array.isArray);
@@ -1980,7 +2045,7 @@ function partial(value, keys) {
 	const result = {};
 	for (let index = 0; index < length; index += 1) {
 		const key = keys[index];
-		result[key] = value[key];
+		if (key in value) result[key] = value[key];
 	}
 	return result;
 }
@@ -1993,11 +2058,17 @@ function flattenObject(value, depth, smushed, prefix) {
 	for (let index = 0; index < length; index += 1) {
 		const key = keys[index];
 		const val = value[key];
-		if (isArrayOrPlainObject(val)) Object.assign(flattened, {
-			[join([prefix, key], ".")]: Array.isArray(val) ? [...val] : { ...val },
-			...flattenObject(val, depth + 1, smushed, join([prefix, key], "."))
-		});
-		else flattened[join([prefix, key], ".")] = val;
+		if (isArrayOrPlainObject(val)) {
+			const prefixedKey = join([prefix, key], ".");
+			flattened[prefixedKey] = Array.isArray(val) ? [...val] : { ...val };
+			const nested = flattenObject(val, depth + 1, smushed, prefixedKey);
+			const nestedKeys = Object.keys(nested);
+			const nestedLength = nestedKeys.length;
+			for (let nestedIndex = 0; nestedIndex < nestedLength; nestedIndex += 1) {
+				const nestedKey = nestedKeys[nestedIndex];
+				flattened[nestedKey] = nested[nestedKey];
+			}
+		} else flattened[join([prefix, key], ".")] = val;
 	}
 	smushed.set(value, flattened);
 	return flattened;
@@ -2033,4 +2104,4 @@ function unsmush(value) {
 	}
 	return unsmushed;
 }
-export { frame_rate_default as FRAME_RATE_MS, SizedMap, SizedSet, average, beacon, between, camelCase, capitalize, chunk, clamp, clone, compact, compare, count, createUuid, debounce, diff, equal, exists, filter, find, flatten, fromQuery, getArray, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getString, getValue, groupBy, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, indexOf, insert, isArrayOrPlainObject, isColor, isEmpty, isHexColor, isHslColor, isHslLike, isHslaColor, isKey, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isPlainObject, isPrimitive, isRgbColor, isRgbLike, isRgbaColor, isTypedArray, join, kebabCase, logger, max, memoize, merge, min, noop, parse, partial, pascalCase, push, rgbToHex, rgbToHsl, rgbToHsla, round, setValue, shuffle, smush, snakeCase, sort, splice, sum, template, throttle, titleCase, toMap, toQuery, toRecord, toSet, truncate, unique, unsmush, words };
+export { frame_rate_default as FRAME_RATE_MS, SizedMap, SizedSet, average, beacon, between, camelCase, capitalize, chunk, clamp, clone, compact, compare, count, createUuid, debounce, diff, equal, exists, filter, find, flatten, fromQuery, getArray, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getString, getUuid, getValue, groupBy, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, indexOf, insert, isArrayOrPlainObject, isColor, isEmpty, isHexColor, isHslColor, isHslLike, isHslaColor, isKey, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isPlainObject, isPrimitive, isRgbColor, isRgbLike, isRgbaColor, isTypedArray, join, kebabCase, logger, max, memoize, merge, min, noop, parse, partial, pascalCase, push, rgbToHex, rgbToHsl, rgbToHsla, round, setValue, shuffle, smush, snakeCase, sort, splice, sum, template, throttle, titleCase, toMap, toQuery, toRecord, toSet, truncate, unique, unsmush, words };

package/dist/color/misc/get.js

@@ -13,8 +13,12 @@ function getForegroundColor(value) {
 		green / 255,
 		red / 255
 	];
-	for (let color of values) if (color <= .03928) color /= SRGB_LUMINANCE_MULTIPLIER;
-	else color = ((color + SRGB_LUMINANCE_OFFSET) / SRGB_LUMINANCE_MODIFIER) ** SRGB_LUMINANCE_EXPONENT;
+	const { length } = values;
+	for (let index = 0; index < length; index += 1) {
+		const color = values[index];
+		if (color <= .03928) values[index] /= SRGB_LUMINANCE_MULTIPLIER;
+		else values[index] = ((color + SRGB_LUMINANCE_OFFSET) / SRGB_LUMINANCE_MODIFIER) ** SRGB_LUMINANCE_EXPONENT;
+	}
 	return new Color(.2126 * values[2] + .7152 * values[1] + .0722 * values[0] > .625 ? HEX_BLACK : HEX_WHITE);
 }
 function getHexaColor(value) {