@oscarpalmer/atoms 0.115.0 → 0.116.0

package/dist/atoms.full.js

@@ -1,3307 +1,2024 @@
-/**
- * Chunk an array into smaller arrays
- * @param array Array to chunk
- * @param size Size of each chunk _(defaults to 5000)_
- * @returns Array of arrays
- */
+function calculate() {
+	return new Promise((resolve) => {
+		const values = [];
+		let last;
+		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));
+			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;
 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;
-    if (length <= actualSize) {
-        return [array];
-    }
-    const chunks = [];
-    let index = 0;
-    while (index < length) {
-        chunks.push(array.slice(index, index + actualSize));
-        index += actualSize;
-    }
-    return chunks;
-}
-//
-const DEFAULT_SIZE = 5_000;
-
+	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;
+	if (length <= actualSize) return [array];
+	const chunks = [];
+	let index = 0;
+	while (index < length) {
+		chunks.push(array.slice(index, index + actualSize));
+		index += actualSize;
+	}
+	return chunks;
+}
+const DEFAULT_SIZE = 5e3;
 function compact(array, strict) {
-    if (!Array.isArray(array)) {
-        return [];
-    }
-    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);
-        }
-    }
-    return compacted;
-}
-
-/**
- * Is the value an array or a record?
- * @param value Value to check
- * @returns `true` if the value is an array or a record, otherwise `false`
- */
+	if (!Array.isArray(array)) return [];
+	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);
+	}
+	return compacted;
+}
 function isArrayOrPlainObject(value) {
-    return Array.isArray(value) || isPlainObject(value);
+	return Array.isArray(value) || isPlainObject(value);
 }
-/**
- * Is the value a key?
- * @param value Value to check
- * @returns `true` if the value is a `Key` _(`number` or `string`)_, otherwise `false`
- */
 function isKey(value) {
-    return typeof value === 'number' || typeof value === 'string';
+	return typeof value === "number" || typeof value === "string";
 }
-/**
- * Is the value a number?
- * @param value Value to check
- * @returns `true` if the value is a `number`, otherwise `false`
- */
 function isNumber(value) {
-    return typeof value === 'number' && !Number.isNaN(value);
+	return typeof value === "number" && !Number.isNaN(value);
 }
-/**
- * Is the value a plain object?
- * @param value Value to check
- * @returns `true` if the value is a plain object, otherwise `false`
- */
 function isPlainObject(value) {
-    if (value === null || typeof value !== 'object') {
-        return false;
-    }
-    if (Symbol.toStringTag in value || Symbol.iterator in value) {
-        return false;
-    }
-    const prototype = Object.getPrototypeOf(value);
-    return (prototype === null ||
-        prototype === Object.prototype ||
-        Object.getPrototypeOf(prototype) === null);
-}
-/**
- * Is the value a typed array?
- * @param value Value to check
- * @returns `true` if the value is a typed array, otherwise `false`
- */
+	if (value === null || typeof value !== "object") return false;
+	if (Symbol.toStringTag in value || Symbol.iterator in value) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null;
+}
 function isTypedArray(value) {
-    return TYPED_ARRAYS.has(value?.constructor);
+	return TYPED_ARRAYS.has(value?.constructor);
 }
-//
 const TYPED_ARRAYS = new Set([
-    Int8Array,
-    Uint8Array,
-    Uint8ClampedArray,
-    Int16Array,
-    Uint16Array,
-    Int32Array,
-    Uint32Array,
-    Float32Array,
-    Float64Array,
-    BigInt64Array,
-    BigUint64Array,
+	Int8Array,
+	Uint8Array,
+	Uint8ClampedArray,
+	Int16Array,
+	Uint16Array,
+	Int32Array,
+	Uint32Array,
+	Float32Array,
+	Float64Array,
+	BigInt64Array,
+	BigUint64Array
 ]);
-
-/**
- * Get a random floating-point number
- * @param minimum Minimum value
- * @param maximum Maximum value
- * @returns Random floating-point number
- */
 function getRandomFloat(minimum, maximum) {
-    let max = isNumber(maximum) && maximum <= Number.MAX_SAFE_INTEGER
-        ? maximum
-        : Number.MAX_SAFE_INTEGER;
-    let min = isNumber(minimum) && minimum >= Number.MIN_SAFE_INTEGER
-        ? minimum
-        : Number.MIN_SAFE_INTEGER;
-    if (min === max) {
-        return min;
-    }
-    if (min > max) {
-        [min, max] = [max, min];
-    }
-    return Math.random() * (max + 1 - min) + min;
-}
-/**
- * Get a random integer
- * @param minimum Minimum value
- * @param maximum Maximum value
- * @returns Random integer
- */
+	let max$1 = isNumber(maximum) && maximum <= Number.MAX_SAFE_INTEGER ? maximum : Number.MAX_SAFE_INTEGER;
+	let min$1 = isNumber(minimum) && minimum >= Number.MIN_SAFE_INTEGER ? minimum : Number.MIN_SAFE_INTEGER;
+	if (min$1 === max$1) return min$1;
+	if (min$1 > max$1) [min$1, max$1] = [max$1, min$1];
+	return Math.random() * (max$1 + 1 - min$1) + min$1;
+}
 function getRandomInteger(minimum, maximum) {
-    return Math.floor(getRandomFloat(minimum, maximum));
-}
-
-/**
- * Shuffle items in array
- * @param array Original array
- * @returns Shuffled array
- */
+	return Math.floor(getRandomFloat(minimum, maximum));
+}
 function shuffle(array) {
-    if (!Array.isArray(array)) {
-        return [];
-    }
-    const shuffled = [...array];
-    if (shuffled.length < 2) {
-        return shuffled;
-    }
-    let index = Number(shuffled.length);
-    while (--index >= 0) {
-        const random = getRandomInteger(0, index);
-        [shuffled[index], shuffled[random]] = [shuffled[random], shuffled[index]];
-    }
-    return shuffled;
-}
-
+	if (!Array.isArray(array)) return [];
+	const shuffled = [...array];
+	if (shuffled.length < 2) return shuffled;
+	let index = Number(shuffled.length);
+	while (--index >= 0) {
+		const random = getRandomInteger(0, index);
+		[shuffled[index], shuffled[random]] = [shuffled[random], shuffled[index]];
+	}
+	return shuffled;
+}
 function getCallback$1(value) {
-    switch (typeof value) {
-        case 'function':
-            return value;
-        case 'number':
-        case 'string':
-            return typeof value === 'string' && value.includes('.')
-                ? undefined
-                : (obj) => obj[value];
-    }
+	switch (typeof value) {
+		case "function": return value;
+		case "number":
+		case "string": return typeof value === "string" && value.includes(".") ? void 0 : (obj) => obj[value];
+		default: break;
+	}
 }
 function getCallbacks(bool, key, value) {
-    if (typeof bool === 'function') {
-        return { bool: bool };
-    }
-    return {
-        keyed: getCallback$1(key),
-        value: getCallback$1(value),
-    };
-}
-
-//
+	if (typeof bool === "function") return { bool };
+	return {
+		keyed: getCallback$1(key),
+		value: getCallback$1(value)
+	};
+}
 function findValue(type, array, parameters) {
-    const findIndex = type === 'index';
-    if (!Array.isArray(array) || array.length === 0) {
-        return findIndex ? -1 : undefined;
-    }
-    const { bool, key, value } = getParameters(parameters);
-    const callbacks = getCallbacks(bool, key);
-    if (callbacks?.bool == null && callbacks?.keyed == null) {
-        return findIndex
-            ? array.indexOf(value)
-            : array.find(item => item === value);
-    }
-    if (callbacks.bool != null) {
-        const index = array.findIndex(callbacks.bool);
-        return findIndex ? index : array[index];
-    }
-    return findValueInArray(array, callbacks.keyed, value, findIndex);
+	const findIndex = type === "index";
+	if (!Array.isArray(array) || array.length === 0) return findIndex ? -1 : void 0;
+	const { bool, key, value } = getParameters(parameters);
+	const callbacks = getCallbacks(bool, key);
+	if (callbacks?.bool == null && callbacks?.keyed == null) return findIndex ? array.indexOf(value) : array.find((item) => item === value);
+	if (callbacks.bool != null) {
+		const index = array.findIndex(callbacks.bool);
+		return findIndex ? index : array[index];
+	}
+	return findValueInArray(array, callbacks.keyed, value, findIndex);
 }
 function findValueInArray(array, callback, value, findIndex) {
-    const { length } = array;
-    for (let index = 0; index < length; index += 1) {
-        const item = array[index];
-        if (callback?.(item, index, array) === value) {
-            return findIndex ? index : item;
-        }
-    }
-    return findIndex ? -1 : undefined;
+	const { length } = array;
+	for (let index = 0; index < length; index += 1) {
+		const item = array[index];
+		if (callback?.(item, index, array) === value) return findIndex ? index : item;
+	}
+	return findIndex ? -1 : void 0;
 }
 function findValues(type, array, parameters) {
-    if (!Array.isArray(array)) {
-        return [];
-    }
-    if (array.length === 0) {
-        return [];
-    }
-    const { length } = array;
-    const { bool, key, value } = getParameters(parameters);
-    const callbacks = getCallbacks(bool, key);
-    if (type === 'unique' &&
-        callbacks?.keyed == null &&
-        length >= UNIQUE_THRESHOLD) {
-        return [...new Set(array)];
-    }
-    if (callbacks?.bool != null) {
-        return array.filter(callbacks.bool);
-    }
-    if (type === 'all' && key == null) {
-        return array.filter(item => item === value);
-    }
-    const keys = new Set();
-    const result = [];
-    for (let index = 0; index < length; index += 1) {
-        const item = array[index];
-        const keyed = callbacks?.keyed?.(item, index, array) ?? item;
-        if ((type === 'all' && Object.is(keyed, value)) ||
-            (type === 'unique' && !keys.has(keyed))) {
-            keys.add(keyed);
-            result.push(item);
-        }
-    }
-    keys.clear();
-    return result;
+	if (!Array.isArray(array)) return [];
+	if (array.length === 0) return [];
+	const { length } = array;
+	const { bool, key, value } = getParameters(parameters);
+	const callbacks = getCallbacks(bool, key);
+	if (type === "unique" && callbacks?.keyed == null && length >= UNIQUE_THRESHOLD) return [...new Set(array)];
+	if (callbacks?.bool != null) return array.filter(callbacks.bool);
+	if (type === "all" && key == null) return array.filter((item) => item === value);
+	const keys = /* @__PURE__ */ new Set();
+	const result = [];
+	for (let index = 0; index < length; index += 1) {
+		const item = array[index];
+		const keyed = callbacks?.keyed?.(item, index, array) ?? item;
+		if (type === "all" && Object.is(keyed, value) || type === "unique" && !keys.has(keyed)) {
+			keys.add(keyed);
+			result.push(item);
+		}
+	}
+	keys.clear();
+	return result;
 }
 function getParameters(original) {
-    const { length } = original;
-    return {
-        bool: length === 1 && typeof original[0] === 'function'
-            ? original[0]
-            : undefined,
-        key: length === 2 ? original[0] : undefined,
-        value: length === 1 && typeof original[0] !== 'function'
-            ? original[0]
-            : original[1],
-    };
-}
-//
+	const { length } = original;
+	return {
+		bool: length === 1 && typeof original[0] === "function" ? original[0] : void 0,
+		key: length === 2 ? original[0] : void 0,
+		value: length === 1 && typeof original[0] !== "function" ? original[0] : original[1]
+	};
+}
 const UNIQUE_THRESHOLD = 100;
-
 function exists(array, ...parameters) {
-    if (parameters.length === 1 && typeof parameters[0] !== 'function') {
-        return Array.isArray(array) ? array.includes(parameters[0]) : false;
-    }
-    return findValue('index', array, parameters) > -1;
+	if (parameters.length === 1 && typeof parameters[0] !== "function") return Array.isArray(array) ? array.includes(parameters[0]) : false;
+	return findValue("index", array, parameters) > -1;
 }
-
 function filter(array, ...parameters) {
-    return findValues('all', array, parameters);
+	return findValues("all", array, parameters);
 }
-
 function find(array, ...parameters) {
-    return findValue('value', array, parameters);
-}
-
-/**
- * Flatten an array _(using native `flat` and maximum depth)_
- * @param array Array to flatten
- * @returns Flattened array
- */
-function flatten$1(array) {
-    return (Array.isArray(array) ? array.flat(Number.POSITIVE_INFINITY) : []);
-}
-
+	return findValue("value", array, parameters);
+}
+function flatten(array) {
+	return Array.isArray(array) ? array.flat(Number.POSITIVE_INFINITY) : [];
+}
 function getArray(value, indiced) {
-    if (Array.isArray(value)) {
-        return value;
-    }
-    if (!isPlainObject(value)) {
-        return [value];
-    }
-    if (indiced !== true) {
-        return Object.values(value);
-    }
-    const keys = Object.keys(value);
-    const { length } = keys;
-    const array = [];
-    for (let index = 0; index < length; index += 1) {
-        const key = keys[index];
-        if (!Number.isNaN(Number(key))) {
-            array.push(value[key]);
-        }
-    }
-    return array;
-}
-
+	if (Array.isArray(value)) return value;
+	if (!isPlainObject(value)) return [value];
+	if (indiced !== true) return Object.values(value);
+	const keys = Object.keys(value);
+	const { length } = keys;
+	const array = [];
+	for (let index = 0; index < length; index += 1) {
+		const key = keys[index];
+		if (!Number.isNaN(Number(key))) array.push(value[key]);
+	}
+	return array;
+}
 function groupValues(array, key, value, arrays) {
-    if (!Array.isArray(array) || array.length === 0) {
-        return {};
-    }
-    const { length } = array;
-    const callbacks = getCallbacks(undefined, key, value);
-    const record = {};
-    for (let index = 0; index < length; index += 1) {
-        const item = array[index];
-        const keyed = callbacks?.keyed?.(item, index, array) ?? index;
-        const valued = callbacks?.value?.(item, index, array) ?? item;
-        if (arrays) {
-            const existing = record[keyed];
-            if (existing == null) {
-                record[keyed] = [valued];
-            }
-            else {
-                existing.push(valued);
-            }
-        }
-        else {
-            record[keyed] = valued;
-        }
-    }
-    return record;
-}
-
+	if (!Array.isArray(array) || array.length === 0) return {};
+	const { length } = array;
+	const callbacks = getCallbacks(void 0, key, value);
+	const record = {};
+	for (let index = 0; index < length; index += 1) {
+		const item = array[index];
+		const keyed = callbacks?.keyed?.(item, index, array) ?? index;
+		const valued = callbacks?.value?.(item, index, array) ?? item;
+		if (arrays) {
+			const existing = record[keyed];
+			if (existing == null) record[keyed] = [valued];
+			else existing.push(valued);
+		} else record[keyed] = valued;
+	}
+	return record;
+}
 const groupBy = ((array, first, second) => groupValues(array, first, second, false));
 groupBy.arrays = ((array, first, second) => groupValues(array, first, second, true));
-
 function indexOf(array, ...parameters) {
-    return findValue('index', array, parameters);
+	return findValue("index", array, parameters);
 }
-
-//
 function insertChunkedValues(type, array, items, start, deleteCount) {
-    const actualDeleteCount = deleteCount < 0 ? 0 : deleteCount;
-    const actualStart = Math.min(Math.max(0, start), array.length);
-    const chunked = chunk(items);
-    const lastIndex = chunked.length - 1;
-    let index = Number(chunked.length);
-    let returned;
-    while (--index >= 0) {
-        const result = array.splice(actualStart, index === lastIndex ? actualDeleteCount : 0, ...chunked[index]);
-        if (returned == null) {
-            returned = result;
-        }
-        else {
-            returned.push(...result);
-        }
-    }
-    if (type === 'insert') {
-        return array;
-    }
-    return type === 'splice' ? returned : array.length;
+	const actualDeleteCount = deleteCount < 0 ? 0 : deleteCount;
+	const actualStart = Math.min(Math.max(0, start), array.length);
+	const chunked = chunk(items);
+	const lastIndex = chunked.length - 1;
+	let index = Number(chunked.length);
+	let returned;
+	while (--index >= 0) {
+		const result = array.splice(actualStart, index === lastIndex ? actualDeleteCount : 0, ...chunked[index]);
+		if (returned == null) returned = result;
+		else returned.push(...result);
+	}
+	if (type === "insert") return array;
+	return type === "splice" ? returned : array.length;
 }
 function insertValues(type, array, items, start, deleteCount) {
-    const splice = type === 'insert' || type === 'splice';
-    if (!Array.isArray(array) || typeof start !== 'number') {
-        return splice ? [] : 0;
-    }
-    if (!Array.isArray(items) || items.length === 0) {
-        return splice ? [] : 0;
-    }
-    return insertChunkedValues(type, array, items, start, splice ? deleteCount : 0);
-}
-
+	const splice$1 = type === "insert" || type === "splice";
+	if (!Array.isArray(array) || typeof start !== "number") return splice$1 ? [] : 0;
+	if (!Array.isArray(items) || items.length === 0) return splice$1 ? [] : 0;
+	return insertChunkedValues(type, array, items, start, splice$1 ? deleteCount : 0);
+}
 function insert(array, indexOrItems, items) {
-    return insertValues('insert', array, items == null ? indexOrItems : items, typeof indexOrItems === 'number' ? indexOrItems : array?.length, 0);
-}
-
-// Uses chunking to avoid call stack size being exceeded
-/**
- * Push items into an array _(at the end)_
- * @param array Original array
- * @param pushed Pushed items
- * @returns New length of the array
- */
+	return insertValues("insert", array, items == null ? indexOrItems : items, typeof indexOrItems === "number" ? indexOrItems : array?.length, 0);
+}
 function push(array, pushed) {
-    return insertValues('push', array, pushed, array.length, 0);
+	return insertValues("push", array, pushed, array.length, 0);
 }
-
 function aggregate(type, array, key) {
-    const length = Array.isArray(array) ? array.length : 0;
-    if (length === 0) {
-        return {
-            count: 0,
-            value: Number.NaN,
-        };
-    }
-    const aggregator = aggregators[type];
-    const isCallback = typeof key === 'function';
-    let count = 0;
-    let aggregated = Number.NaN;
-    let notNumber = true;
-    for (let index = 0; index < length; index += 1) {
-        const item = array[index];
-        const value = isCallback
-            ? key(item, index, array)
-            : (item[key] ?? item);
-        if (typeof value === 'number' && !Number.isNaN(value)) {
-            aggregated = aggregator(aggregated, value, notNumber);
-            count += 1;
-            notNumber = false;
-        }
-    }
-    return {
-        count,
-        value: aggregated,
-    };
+	const length = Array.isArray(array) ? array.length : 0;
+	if (length === 0) return {
+		count: 0,
+		value: NaN
+	};
+	const aggregator = aggregators[type];
+	const isCallback = typeof key === "function";
+	let count$1 = 0;
+	let aggregated = NaN;
+	let notNumber = true;
+	for (let index = 0; index < length; index += 1) {
+		const item = array[index];
+		const value = isCallback ? key(item, index, array) : item[key] ?? item;
+		if (typeof value === "number" && !Number.isNaN(value)) {
+			aggregated = aggregator(aggregated, value, notNumber);
+			count$1 += 1;
+			notNumber = false;
+		}
+	}
+	return {
+		count: count$1,
+		value: aggregated
+	};
 }
 function max(array, key) {
-    return aggregate('max', array, key).value;
+	return aggregate("max", array, key).value;
 }
 function sum$1(current, value, notNumber) {
-    return notNumber ? value : current + value;
+	return notNumber ? value : current + value;
 }
-//
 const aggregators = {
-    sum: sum$1,
-    average: sum$1,
-    max: (current, value, notNumber) => notNumber || value > current ? value : current,
-    min: (current, value, notNumber) => notNumber || value < current ? value : current,
+	sum: sum$1,
+	average: sum$1,
+	max: (current, value, notNumber) => notNumber || value > current ? value : current,
+	min: (current, value, notNumber) => notNumber || value < current ? value : current
 };
-
-/**
- * Get the string value from any value
- * @param value Original value
- * @returns String representation of the value
- */
 function getString(value) {
-    if (typeof value === 'string') {
-        return value;
-    }
-    if (value == null) {
-        return '';
-    }
-    if (typeof value === 'function') {
-        return getString(value());
-    }
-    if (typeof value !== 'object') {
-        return String(value);
-    }
-    const asString = String(value.valueOf?.() ?? value);
-    return asString.startsWith('[object ') ? JSON.stringify(value) : asString;
+	if (typeof value === "string") return value;
+	if (value == null) return "";
+	if (typeof value === "function") return getString(value());
+	if (typeof value !== "object") return String(value);
+	const asString = String(value.valueOf?.() ?? value);
+	return asString.startsWith("[object ") ? JSON.stringify(value) : asString;
 }
 function ignoreKey(key) {
-    return EXPRESSION_IGNORED.test(key);
-}
-/**
- * Join an array of values into a string
- * @param value Array of values
- * @param delimiter Delimiter to use between values
- * @returns Joined string
- */
+	return EXPRESSION_IGNORED.test(key);
+}
 function join(value, delimiter) {
-    return compact(value)
-        .map(getString)
-        .join(typeof delimiter === 'string' ? delimiter : '');
+	return compact(value).map(getString).join(typeof delimiter === "string" ? delimiter : "");
 }
 function tryCallback(value, callback) {
-    try {
-        return callback(value);
-    }
-    catch {
-        return value;
-    }
+	try {
+		return callback(value);
+	} catch {
+		return value;
+	}
 }
 function tryDecode(value) {
-    return tryCallback(value, decodeURIComponent);
+	return tryCallback(value, decodeURIComponent);
 }
 function tryEncode(value) {
-    return tryCallback(value, encodeURIComponent);
+	return tryCallback(value, encodeURIComponent);
 }
-/**
- * Split a string into words _(and other readable parts)_
- * @param value Original string
- * @returns Array of words found in the string
- */
 function words(value) {
-    return typeof value === 'string' ? (value.match(EXPRESSION_WORDS) ?? []) : [];
+	return typeof value === "string" ? value.match(EXPRESSION_WORDS) ?? [] : [];
 }
-//
 const EXPRESSION_IGNORED = /(^|\.)(__proto__|constructor|prototype)(\.|$)/i;
-// biome-ignore lint/suspicious/noControlCharactersInRegex: Lodash uses it, so it's fine ;-)
 const EXPRESSION_WORDS = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
-
-/**
- * Compare two values _(for sorting purposes)_
- * @param first First value
- * @param second Second value
- * @returns `0` if equal; `-1` first comes before second; `1` first comes after second
- */
 function compare(first, second) {
-    if (Object.is(first, second)) {
-        return 0;
-    }
-    if (first == null) {
-        return -1;
-    }
-    if (second == null) {
-        return 1;
-    }
-    const comparison = compareValue(first, second, false);
-    if (comparison != null) {
-        return comparison;
-    }
-    const firstParts = getParts$1(first);
-    const secondParts = getParts$1(second);
-    const length = max([firstParts.length, secondParts.length]);
-    const lastIndex = length - 1;
-    for (let index = 0; index < length; index += 1) {
-        const firstPart = firstParts[index];
-        const secondPart = secondParts[index];
-        const comparison = compareValue(firstPart, secondPart, true);
-        if (comparison === 0) {
-            if (index === lastIndex) {
-                break;
-            }
-            continue;
-        }
-        return comparison;
-    }
-    return 0;
+	if (Object.is(first, second)) return 0;
+	if (first == null) return -1;
+	if (second == null) return 1;
+	const comparison = compareValue(first, second, false);
+	if (comparison != null) return comparison;
+	const firstParts = getParts$1(first);
+	const secondParts = getParts$1(second);
+	const length = max([firstParts.length, secondParts.length]);
+	const lastIndex = length - 1;
+	for (let index = 0; index < length; index += 1) {
+		const firstPart = firstParts[index];
+		const secondPart = secondParts[index];
+		const comparison$1 = compareValue(firstPart, secondPart, true);
+		if (comparison$1 === 0) {
+			if (index === lastIndex) break;
+			continue;
+		}
+		return comparison$1;
+	}
+	return 0;
 }
 function compareNumbers(first, second) {
-    const firstNumber = Number(first);
-    const secondNumber = Number(second);
-    if (firstNumber === secondNumber) {
-        return 0;
-    }
-    return firstNumber > secondNumber ? 1 : -1;
+	const firstNumber = Number(first);
+	const secondNumber = Number(second);
+	if (firstNumber === secondNumber) return 0;
+	return firstNumber > secondNumber ? 1 : -1;
 }
 function compareSymbols(first, second) {
-    return getString(first.description ?? first).localeCompare(getString(second.description ?? second));
+	return getString(first.description ?? first).localeCompare(getString(second.description ?? second));
 }
 function compareValue(first, second, compareStrings) {
-    const firstType = typeof first;
-    const secondType = typeof second;
-    if (firstType === secondType && firstType in comparators) {
-        return comparators[firstType](first, second);
-    }
-    if (first instanceof Date && second instanceof Date) {
-        return compareNumbers(first.getTime(), second.getTime());
-    }
-    if (compareStrings) {
-        return getString(first).localeCompare(getString(second));
-    }
+	const firstType = typeof first;
+	if (firstType === typeof second && firstType in comparators) return comparators[firstType](first, second);
+	if (first instanceof Date && second instanceof Date) return compareNumbers(first.getTime(), second.getTime());
+	if (compareStrings) return getString(first).localeCompare(getString(second));
 }
 function getParts$1(value) {
-    if (Array.isArray(value)) {
-        return value;
-    }
-    return typeof value === 'object' ? [value] : words(getString(value));
+	if (Array.isArray(value)) return value;
+	return typeof value === "object" ? [value] : words(getString(value));
 }
-//
 const comparators = {
-    bigint: compareNumbers,
-    boolean: compareNumbers,
-    number: compareNumbers,
-    symbol: compareSymbols,
+	bigint: compareNumbers,
+	boolean: compareNumbers,
+	number: compareNumbers,
+	symbol: compareSymbols
 };
-
-/**
- * Is the array or object completely empty, or only containing `null` or `undefined` values?
- * @param value Array or object to check
- * @returns `true` if the value is considered empty, otherwise `false`
- */
 function isEmpty(value) {
-    const values = Object.values(value);
-    const { length } = values;
-    for (let index = 0; index < length; index += 1) {
-        if (values[index] != null) {
-            return false;
-        }
-    }
-    return true;
-}
-/**
- * Is the value `undefined` or `null`?
- * @param value Value to check
- * @returns `true` if the value is `undefined` or `null`, otherwise `false`
- */
+	const values = Object.values(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;
+	return value == null;
 }
-/**
- * Is the value `undefined`, `null`, or an empty _(no whitespace)_ string?
- * @param value Value to check
- * @returns `true` if the value is nullable or an empty string, otherwise `false`
- */
 function isNullableOrEmpty(value) {
-    return value == null || getString(value) === '';
+	return value == null || getString(value) === "";
 }
-/**
- * Is the value `undefined`, `null`, or a whitespace-only string?
- * @param value Value to check
- * @returns `true` if the value is nullable or a whitespace-only string, otherwise `false`
- */
 function isNullableOrWhitespace(value) {
-    return value == null || EXPRESSION_WHITESPACE.test(getString(value));
+	return value == null || EXPRESSION_WHITESPACE.test(getString(value));
 }
-/**
- * Is the value a number or a number-like string?
- * @param value Value to check
- * @returns `true` if the value is a number or a parseable string, otherwise `false`
- */
 function isNumerical(value) {
-    return (isNumber(value) ||
-        (typeof value === 'string' &&
-            value.trim().length > 0 &&
-            !Number.isNaN(+value)));
-}
-/**
- * Is the value an object _(or function)_?
- * @param value Value to check
- * @returns `true` if the value matches, otherwise `false`
- */
-function isObject$1(value) {
-    return ((typeof value === 'object' && value !== null) || typeof value === 'function');
-}
-/**
- * - Is the value a primitive value?
- * @param value Value to check
- * @returns `true` if the value matches, otherwise `false`
- */
+	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);
+	return value == null || EXPRESSION_PRIMITIVE.test(typeof value);
 }
-//
 const EXPRESSION_PRIMITIVE = /^(bigint|boolean|number|string|symbol)$/;
 const EXPRESSION_WHITESPACE = /^\s*$/;
-
-//
-function getCallback(value, key, isObject) {
-    if (key != null) {
-        return;
-    }
-    if (isObject && typeof value.value === 'function') {
-        return value.value;
-    }
-    return typeof value === 'function' ? value : undefined;
-}
-function getKey(value, isObject) {
-    if (isObject && typeof value.key === 'string') {
-        return value.key;
-    }
-    return typeof value === 'string' ? value : undefined;
-}
-function getModifier(value, modifier, isObject) {
-    if (!isObject || typeof value.direction !== 'string') {
-        return modifier;
-    }
-    if (value.direction === 'ascending') {
-        return 1;
-    }
-    return value.direction === 'descending' ? -1 : modifier;
+function getCallback(value, key, isObject$2) {
+	if (key != null) return;
+	if (isObject$2 && typeof value.value === "function") return value.value;
+	return typeof value === "function" ? value : void 0;
+}
+function getKey(value, isObject$2) {
+	if (isObject$2 && typeof value.key === "string") return value.key;
+	return typeof value === "string" ? value : void 0;
+}
+function getModifier(value, modifier, isObject$2) {
+	if (!isObject$2 || typeof value.direction !== "string") return modifier;
+	if (value.direction === "ascending") return 1;
+	return value.direction === "descending" ? -1 : modifier;
 }
 function getSorter(value, modifier) {
-    const isObject = isPlainObject(value);
-    const sorter = {
-        identifier: '',
-        modifier,
-    };
-    sorter.compare =
-        isObject && typeof value.compare === 'function'
-            ? value.compare
-            : undefined;
-    sorter.key = getKey(value, isObject);
-    sorter.modifier = getModifier(value, modifier, isObject);
-    sorter.callback = getCallback(value, sorter.key, isObject);
-    if (sorter.key != null || sorter.callback != null) {
-        sorter.identifier = `${sorter.key ?? sorter.callback}`;
-        return sorter;
-    }
+	const isObject$2 = isPlainObject(value);
+	const sorter = {
+		identifier: "",
+		modifier
+	};
+	sorter.compare = isObject$2 && typeof value.compare === "function" ? value.compare : void 0;
+	sorter.key = getKey(value, isObject$2);
+	sorter.modifier = getModifier(value, modifier, isObject$2);
+	sorter.callback = getCallback(value, sorter.key, isObject$2);
+	if (sorter.key != null || sorter.callback != null) {
+		sorter.identifier = `${sorter.key ?? sorter.callback}`;
+		return sorter;
+	}
 }
 function sort(array, first, second) {
-    if (!Array.isArray(array)) {
-        return [];
-    }
-    if (array.length < 2) {
-        return array;
-    }
-    const direction = first === true || second === true ? 'desc' : 'asc';
-    const modifier = direction === 'asc' ? 1 : -1;
-    const sorters = (Array.isArray(first) ? first : [first])
-        .map(item => getSorter(item, modifier))
-        .filter(sorter => sorter != null)
-        .filter((current, index, sorters) => sorters.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];
-        const { callback, key, modifier } = sorter;
-        return array.sort((first, second) => {
-            const firstValue = key == null ? callback?.(first) : first[key];
-            const secondValue = key == null ? callback?.(second) : second[key];
-            return ((sorter.compare?.(first, firstValue, second, secondValue) ??
-                compare(firstValue, secondValue)) * modifier);
-        });
-    }
-    return array.sort((first, second) => {
-        for (let index = 0; index < length; index += 1) {
-            const sorter = sorters[index];
-            const { callback, key, modifier } = sorter;
-            const firstValue = key == null ? callback?.(first) : first[key];
-            const secondValue = key == null ? callback?.(second) : second[key];
-            const compared = (sorter.compare?.(first, firstValue, second, secondValue) ??
-                compare(firstValue, secondValue)) * modifier;
-            if (compared !== 0) {
-                return compared;
-            }
-        }
-        return 0;
-    });
-}
-
+	if (!Array.isArray(array)) return [];
+	if (array.length < 2) return array;
+	const modifier = (first === true || second === true ? "desc" : "asc") === "asc" ? 1 : -1;
+	const sorters = (Array.isArray(first) ? first : [first]).map((item) => getSorter(item, modifier)).filter((sorter) => sorter != null).filter((current, index, sorters$1) => sorters$1.findIndex((next) => next.identifier === current.identifier) === index);
+	const { length } = sorters;
+	if (length === 0) return array.sort((first$1, second$1) => compare(first$1, second$1) * modifier);
+	if (length === 1) {
+		const sorter = sorters[0];
+		const { callback, key, modifier: modifier$1 } = sorter;
+		return array.sort((first$1, second$1) => {
+			const firstValue = key == null ? callback?.(first$1) : first$1[key];
+			const secondValue = key == null ? callback?.(second$1) : second$1[key];
+			return (sorter.compare?.(first$1, firstValue, second$1, secondValue) ?? compare(firstValue, secondValue)) * modifier$1;
+		});
+	}
+	return array.sort((first$1, second$1) => {
+		for (let index = 0; index < length; index += 1) {
+			const sorter = sorters[index];
+			const { callback, key, modifier: modifier$1 } = sorter;
+			const firstValue = key == null ? callback?.(first$1) : first$1[key];
+			const secondValue = key == null ? callback?.(second$1) : second$1[key];
+			const compared = (sorter.compare?.(first$1, firstValue, second$1, secondValue) ?? compare(firstValue, secondValue)) * modifier$1;
+			if (compared !== 0) return compared;
+		}
+		return 0;
+	});
+}
 function splice(array, start, deleteCountOrItems, items) {
-    return insertValues('splice', array, typeof deleteCountOrItems === 'number' ? items : deleteCountOrItems, start, typeof deleteCountOrItems === 'number' ? deleteCountOrItems : 0);
+	return insertValues("splice", array, typeof deleteCountOrItems === "number" ? items : deleteCountOrItems, start, typeof deleteCountOrItems === "number" ? deleteCountOrItems : 0);
 }
-
 function getMapValues(array, first, second, arrays) {
-    if (!Array.isArray(array)) {
-        return new Map();
-    }
-    const { length } = array;
-    const callbacks = getCallbacks(undefined, first, second);
-    const map = new Map();
-    for (let index = 0; index < length; index += 1) {
-        const item = array[index];
-        const key = callbacks?.keyed?.(item, index, array) ?? index;
-        const value = callbacks?.value?.(item, index, array) ?? item;
-        if (arrays) {
-            const existing = map.get(key);
-            if (existing == null) {
-                map.set(key, [value]);
-            }
-            else {
-                existing.push(value);
-            }
-        }
-        else {
-            map.set(key, value);
-        }
-    }
-    return map;
+	if (!Array.isArray(array)) return /* @__PURE__ */ new Map();
+	const { length } = array;
+	const callbacks = getCallbacks(void 0, first, second);
+	const map = /* @__PURE__ */ new Map();
+	for (let index = 0; index < length; index += 1) {
+		const item = array[index];
+		const key = callbacks?.keyed?.(item, index, array) ?? index;
+		const value = callbacks?.value?.(item, index, array) ?? item;
+		if (arrays) {
+			const existing = map.get(key);
+			if (existing == null) map.set(key, [value]);
+			else existing.push(value);
+		} else map.set(key, value);
+	}
+	return map;
 }
 const toMap = ((array, first, second, arrays) => getMapValues(array, first, second, arrays));
 toMap.arrays = ((array, first, second) => getMapValues(array, first, second, true));
-
 const toRecord = ((array, first, second) => groupValues(array, first, second, false));
 toRecord.arrays = ((array, first, second) => groupValues(array, first, second, true));
-
 function toSet(array, value) {
-    if (!Array.isArray(array)) {
-        return new Set();
-    }
-    const callbacks = getCallbacks(undefined, undefined, value);
-    if (callbacks?.value == null) {
-        return new Set(array);
-    }
-    const { length } = array;
-    const set = new Set();
-    for (let index = 0; index < length; index += 1) {
-        set.add(callbacks.value(array[index], index, array));
-    }
-    return set;
-}
-
+	if (!Array.isArray(array)) return /* @__PURE__ */ new Set();
+	const callbacks = getCallbacks(void 0, void 0, value);
+	if (callbacks?.value == null) return new Set(array);
+	const { length } = array;
+	const set = /* @__PURE__ */ new Set();
+	for (let index = 0; index < length; index += 1) set.add(callbacks.value(array[index], index, array));
+	return set;
+}
 function unique(array, key) {
-    if (!Array.isArray(array)) {
-        return [];
-    }
-    return array.length > 1
-        ? findValues('unique', array, [key, undefined])
-        : array;
-}
-
-const ALPHA_FULL_HEX_SHORT = 'f';
+	if (!Array.isArray(array)) return [];
+	return array.length > 1 ? findValues("unique", array, [key, void 0]) : array;
+}
+const ALPHA_FULL_HEX_SHORT = "f";
 const ALPHA_FULL_HEX_LONG = `${ALPHA_FULL_HEX_SHORT}${ALPHA_FULL_HEX_SHORT}`;
 const ALPHA_FULL_VALUE = 1;
-const ALPHA_NONE_HEX = '00';
+const ALPHA_NONE_HEX = "00";
 const ALPHA_NONE_VALUE = 0;
 const DEFAULT_ALPHA = {
-    hex: ALPHA_FULL_HEX_LONG,
-    value: ALPHA_FULL_VALUE,
+	hex: ALPHA_FULL_HEX_LONG,
+	value: ALPHA_FULL_VALUE
 };
 const DEFAULT_HSL = {
-    hue: 0,
-    lightness: 0,
-    saturation: 0,
+	hue: 0,
+	lightness: 0,
+	saturation: 0
 };
 const DEFAULT_RGB = {
-    blue: 0,
-    green: 0,
-    red: 0,
+	blue: 0,
+	green: 0,
+	red: 0
 };
 const EXPRESSION_HEX_LONG = /^#?([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})?$/i;
 const EXPRESSION_HEX_SHORT = /^#?([a-f0-9]{3,4})$/i;
 const EXPRESSION_PREFIX = /^#/;
-const HEX_BLACK = '000000';
-const HEX_WHITE = 'ffffff';
+const HEX_BLACK = "000000";
+const HEX_WHITE = "ffffff";
 const LENGTH_LONG = 6;
 const LENGTH_SHORT = 3;
-const KEYS_HSL = ['hue', 'saturation', 'lightness'];
-const KEYS_HSLA = [...KEYS_HSL, 'alpha'];
-const KEYS_RGB = ['red', 'green', 'blue'];
-const KEYS_RGBA = [...KEYS_RGB, 'alpha'];
+const KEYS_HSL = [
+	"hue",
+	"saturation",
+	"lightness"
+];
+const KEYS_HSLA = [...KEYS_HSL, "alpha"];
+const KEYS_RGB = [
+	"red",
+	"green",
+	"blue"
+];
+const KEYS_RGBA = [...KEYS_RGB, "alpha"];
 const MAX_DEGREE = 360;
 const MAX_HEX = 255;
 const MAX_PERCENT = 100;
-//
-// https://www.w3.org/TR/WCAG20/#relativeluminancedef
-const SRGB_LUMINANCE_BLUE = 0.0722;
+const SRGB_LUMINANCE_BLUE = .0722;
 const SRGB_LUMINANCE_EXPONENT = 2.4;
-const SRGB_LUMINANCE_GREEN = 0.7152;
-const SRGB_LUMINANCE_MINIMUM = 0.03928;
+const SRGB_LUMINANCE_GREEN = .7152;
+const SRGB_LUMINANCE_MINIMUM = .03928;
 const SRGB_LUMINANCE_MODIFIER = 1.055;
 const SRGB_LUMINANCE_MULTIPLIER = 12.92;
-const SRGB_LUMINANCE_OFFSET = 0.055;
-const SRGB_LUMINANCE_RED = 0.2126;
-const SRGB_LUMINANCE_THRESHOLD = 0.625;
-
+const SRGB_LUMINANCE_OFFSET = .055;
+const SRGB_LUMINANCE_RED = .2126;
+const SRGB_LUMINANCE_THRESHOLD = .625;
 function formatColor(space, color, alpha) {
-    const suffix = alpha ? ` / ${color.alpha}` : '';
-    const value = color[space];
-    return `${space}(${join(formattingKeys[space].map(key => value[key]), ' ')}${suffix})`;
+	const suffix = alpha ? ` / ${color.alpha}` : "";
+	const value = color[space];
+	return `${space}(${join(formattingKeys[space].map((key) => value[key]), " ")}${suffix})`;
 }
-//
 const formattingKeys = {
-    hsl: KEYS_HSL,
-    rgb: KEYS_RGB,
+	hsl: KEYS_HSL,
+	rgb: KEYS_RGB
 };
-
 function getAlpha(value) {
-    if (typeof value === 'number') {
-        return getAlphaFromValue(value);
-    }
-    if (typeof value === 'string' && value !== ALPHA_FULL_HEX_LONG) {
-        return {
-            hex: value,
-            value: Number.parseInt(value, 16) / MAX_HEX,
-        };
-    }
-    return { ...DEFAULT_ALPHA };
+	if (typeof value === "number") return getAlphaFromValue(value);
+	if (typeof value === "string" && value !== ALPHA_FULL_HEX_LONG) return {
+		hex: value,
+		value: Number.parseInt(value, 16) / MAX_HEX
+	};
+	return { ...DEFAULT_ALPHA };
 }
 function getAlphaHexadecimal(value) {
-    if (value === ALPHA_NONE_VALUE) {
-        return ALPHA_NONE_HEX;
-    }
-    if (value === ALPHA_FULL_VALUE) {
-        return ALPHA_FULL_HEX_LONG;
-    }
-    return Math.round(value * MAX_HEX).toString(16);
+	if (value === ALPHA_NONE_VALUE) return ALPHA_NONE_HEX;
+	if (value === ALPHA_FULL_VALUE) return ALPHA_FULL_HEX_LONG;
+	return Math.round(value * MAX_HEX).toString(16);
 }
 function getAlphaFromValue(value) {
-    const alpha = getAlphaValue(value);
-    return {
-        hex: getAlphaHexadecimal(alpha),
-        value: alpha,
-    };
+	const alpha = getAlphaValue(value);
+	return {
+		hex: getAlphaHexadecimal(alpha),
+		value: alpha
+	};
 }
 function getAlphaValue(original) {
-    if (Number.isNaN(original) ||
-        original >= MAX_PERCENT ||
-        original === ALPHA_FULL_VALUE) {
-        return ALPHA_FULL_VALUE;
-    }
-    if (original < ALPHA_NONE_VALUE) {
-        return ALPHA_NONE_VALUE;
-    }
-    return original <= ALPHA_FULL_VALUE ? original : original / MAX_PERCENT;
-}
-
-/**
- * Is the number between a minimum and maximum value?
- * @param value Value to check
- * @param minimum Minimum value
- * @param maximum Maximum value
- * @returns `true` if the value is between the minimum and maximum, otherwise `false`
- */
+	if (Number.isNaN(original) || original >= MAX_PERCENT || original === ALPHA_FULL_VALUE) return ALPHA_FULL_VALUE;
+	if (original < ALPHA_NONE_VALUE) return ALPHA_NONE_VALUE;
+	return original <= ALPHA_FULL_VALUE ? original : original / MAX_PERCENT;
+}
 function between(value, minimum, maximum) {
-    if (![value, minimum, maximum].every(isNumber)) {
-        return false;
-    }
-    if (minimum === maximum) {
-        return value === minimum;
-    }
-    const max = maximum > minimum ? maximum : minimum;
-    const min = maximum > minimum ? minimum : maximum;
-    return value >= min && value <= max;
-}
-/**
- * Clamp a number between a minimum and maximum value
- * @param value Value to clamp
- * @param minimum Minimum value
- * @param maximum Maximum value
- * @param loop If `true`, the value will loop around when smaller than the minimum or larger than the maximum _(defaults to `false`)_
- * @returns Clamped value
- */
+	if (![
+		value,
+		minimum,
+		maximum
+	].every(isNumber)) return false;
+	if (minimum === maximum) return value === minimum;
+	return value >= (maximum > minimum ? minimum : maximum) && value <= (maximum > minimum ? maximum : minimum);
+}
 function clamp(value, minimum, maximum, loop) {
-    if (![value, minimum, maximum].every(isNumber)) {
-        return Number.NaN;
-    }
-    if (value < minimum) {
-        return loop === true ? maximum : minimum;
-    }
-    const next = loop === true ? minimum : maximum;
-    return value > maximum ? next : value;
-}
-/**
- * Get the number value from an unknown value _(based on Lodash)_
- * @param value Original value
- * @returns The value as a number, or `NaN` if the value is unable to be parsed
- */
+	if (![
+		value,
+		minimum,
+		maximum
+	].every(isNumber)) return NaN;
+	if (value < minimum) return loop === true ? maximum : minimum;
+	return value > maximum ? loop === true ? minimum : maximum : value;
+}
 function getNumber(value) {
-    if (typeof value === 'number') {
-        return value;
-    }
-    if (typeof value === 'bigint' || typeof value === 'boolean') {
-        return Number(value);
-    }
-    if (value == null || typeof value === 'symbol') {
-        return Number.NaN;
-    }
-    if (typeof value === 'function') {
-        return getNumber(value());
-    }
-    let parsed = value.valueOf();
-    if (typeof parsed === 'object') {
-        parsed = parsed.toString();
-    }
-    if (typeof parsed !== 'string') {
-        return getNumber(parsed);
-    }
-    const trimmed = parsed.trim();
-    if (trimmed.length === 0) {
-        return Number.NaN;
-    }
-    if (EXPRESSION_ZEROISH.test(parsed)) {
-        return 0;
-    }
-    const isBinary = EXPRESSION_BINARY.test(trimmed);
-    if (isBinary || EXPRESSION_OCTAL.test(trimmed)) {
-        return Number.parseInt(trimmed.slice(2), isBinary ? 2 : OCTAL_VALUE);
-    }
-    return Number(EXPRESSION_HEX.test(trimmed)
-        ? trimmed
-        : trimmed.replace(EXPRESSION_UNDERSCORE, ''));
-}
-//
+	if (typeof value === "number") return value;
+	if (typeof value === "bigint" || typeof value === "boolean") return Number(value);
+	if (value == null || typeof value === "symbol") return NaN;
+	if (typeof value === "function") return getNumber(value());
+	let parsed = value.valueOf();
+	if (typeof parsed === "object") parsed = parsed.toString();
+	if (typeof parsed !== "string") return getNumber(parsed);
+	const trimmed = parsed.trim();
+	if (trimmed.length === 0) return NaN;
+	if (EXPRESSION_ZEROISH.test(parsed)) return 0;
+	const isBinary = EXPRESSION_BINARY.test(trimmed);
+	if (isBinary || EXPRESSION_OCTAL.test(trimmed)) return Number.parseInt(trimmed.slice(2), isBinary ? 2 : OCTAL_VALUE);
+	return Number(EXPRESSION_HEX.test(trimmed) ? trimmed : trimmed.replace(EXPRESSION_UNDERSCORE, ""));
+}
 const EXPRESSION_BINARY = /^0b[01]+$/i;
 const EXPRESSION_HEX = /^0x[0-9a-f]+$/i;
 const EXPRESSION_OCTAL = /^0o[0-7]+$/i;
 const EXPRESSION_UNDERSCORE = /_/g;
 const EXPRESSION_ZEROISH = /^\s*0+\s*$/;
 const OCTAL_VALUE = 8;
-
+function hasKeys(value, keys) {
+	return typeof value === "object" && value !== null && keys.every((key) => key in value);
+}
 function isAlpha(value) {
-    return (typeof value === 'number' &&
-        between(value, ALPHA_NONE_VALUE, ALPHA_FULL_VALUE));
+	return typeof value === "number" && between(value, ALPHA_NONE_VALUE, ALPHA_FULL_VALUE);
 }
 function isBytey(value) {
-    return typeof value === 'number' && between(value, 0, MAX_HEX);
+	return typeof value === "number" && between(value, 0, MAX_HEX);
 }
-/**
- * Is the value a Color?
- * @param value The value to check
- * @returns `true` if the value is a Color, otherwise `false`
- */
 function isColor(value) {
-    return (typeof value === 'object' &&
-        value !== null &&
-        '$color' in value &&
-        value.$color === true);
+	return typeof value === "object" && value !== null && "$color" in value && value.$color === true;
 }
 function isDegree(value) {
-    return typeof value === 'number' && between(value, 0, MAX_DEGREE);
-}
-/**
- * Is the value a hex color?
- * @param value The value to check
- * @param alpha Allow alpha channel? _(defaults to `true`)_
- * @returns `true` if the value is a hex color, otherwise `false`
- */
+	return typeof value === "number" && between(value, 0, MAX_DEGREE);
+}
 function isHexColor(value, alpha) {
-    if (typeof value !== 'string') {
-        return false;
-    }
-    if (!(EXPRESSION_HEX_SHORT.test(value) || EXPRESSION_HEX_LONG.test(value))) {
-        return false;
-    }
-    if (alpha === false) {
-        return value.length === LENGTH_SHORT || value.length === LENGTH_LONG;
-    }
-    return true;
-}
-/**
- * Is the value an HSLA color?
- * @param value The value to check
- * @returns `true` if the value is an HSLA color, otherwise `false`
- */
+	if (typeof value !== "string") return false;
+	if (!(EXPRESSION_HEX_SHORT.test(value) || EXPRESSION_HEX_LONG.test(value))) return false;
+	if (alpha === false) return value.length === LENGTH_SHORT || value.length === LENGTH_LONG;
+	return true;
+}
 function isHslaColor(value) {
-    return isObject(value, KEYS_HSLA);
+	return isObject$1(value, KEYS_HSLA);
 }
-/**
- * Is the value an HSL color?
- * @param value The value to check
- * @returns `true` if the value is an HSL color, otherwise `false`
- */
 function isHslColor(value) {
-    return isObject(value, KEYS_HSLA) || isObject(value, KEYS_HSL);
+	return isObject$1(value, KEYS_HSLA) || isObject$1(value, KEYS_HSL);
+}
+function isHslLike(value) {
+	return hasKeys(value, KEYS_HSL);
 }
-/**
- * Is the value an RGBA color?
- * @param value The value to check
- * @returns `true` if the value is an RGBA color, otherwise `false`
- */
 function isRgbaColor(value) {
-    return isObject(value, KEYS_RGBA);
+	return isObject$1(value, KEYS_RGBA);
 }
-/**
- * Is the value an RGB color?
- * @param value The value to check
- * @returns `true` if the value is an RGB color, otherwise `false`
- */
 function isRgbColor(value) {
-    return isObject(value, KEYS_RGBA) || isObject(value, KEYS_RGB);
-}
-function isObject(obj, properties) {
-    if (typeof obj !== 'object' || obj === null) {
-        return false;
-    }
-    const keys = Object.keys(obj);
-    const { length } = keys;
-    if (length !== properties.length) {
-        return false;
-    }
-    for (let index = 0; index < length; index += 1) {
-        const key = keys[index];
-        if (!(properties.includes(key) &&
-            validators[key](obj[key]))) {
-            return false;
-        }
-    }
-    return true;
+	return isObject$1(value, KEYS_RGBA) || isObject$1(value, KEYS_RGB);
+}
+function isRgbLike(value) {
+	return hasKeys(value, KEYS_RGB);
+}
+function isObject$1(obj, properties) {
+	if (typeof obj !== "object" || obj === null) return false;
+	const keys = Object.keys(obj);
+	const { length } = keys;
+	if (length !== properties.length) return false;
+	for (let index = 0; index < length; index += 1) {
+		const key = keys[index];
+		if (!(properties.includes(key) && validators[key](obj[key]))) return false;
+	}
+	return true;
 }
 function isPercentage(value) {
-    return typeof value === 'number' && between(value, 0, MAX_PERCENT);
+	return typeof value === "number" && between(value, 0, MAX_PERCENT);
 }
-//
 const validators = {
-    alpha: isAlpha,
-    blue: isBytey,
-    green: isBytey,
-    hue: isDegree,
-    lightness: isPercentage,
-    saturation: isPercentage,
-    red: isBytey,
+	alpha: isAlpha,
+	blue: isBytey,
+	green: isBytey,
+	hue: isDegree,
+	lightness: isPercentage,
+	saturation: isPercentage,
+	red: isBytey
 };
-
+function getForegroundColor(value) {
+	const { blue, green, red } = getState(value).rgb;
+	const values = [
+		blue / MAX_HEX,
+		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;
+	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) {
+	const { alpha, hex } = getState(value);
+	return `${hex}${alpha.hex}`;
+}
+function getHexColor(value) {
+	return getState(value).hex;
+}
+function getHexValue(value) {
+	return getValue$2(value, 0, MAX_HEX);
+}
+function getDegrees(value) {
+	return getValue$2(value, 0, MAX_DEGREE);
+}
+function getHslaColor(value) {
+	const { alpha, hsl } = getState(value);
+	return {
+		...hsl,
+		alpha: alpha.value
+	};
+}
+function getHslColor(value) {
+	return getState(value).hsl;
+}
+function getPercentage(value) {
+	return getValue$2(value, 0, MAX_PERCENT);
+}
+function getRgbaColor(value) {
+	const { alpha, rgb } = getState(value);
+	return {
+		...rgb,
+		alpha: alpha.value
+	};
+}
+function getRgbColor(value) {
+	return getState(value).rgb;
+}
+function getValue$2(value, minimum, maximum) {
+	return typeof value === "number" ? clamp(value, minimum, maximum) : minimum;
+}
 function convertRgbToHex(rgb, alpha) {
-    const hex = `${join([rgb.red, rgb.green, rgb.blue].map(color => {
-        const hex = color.toString(16);
-        return hex.length === 1 ? `0${hex}` : hex;
-    }))}`;
-    let a = '';
-    if (typeof alpha === 'boolean' && alpha) {
-        a = getAlpha(rgb.alpha).hex;
-    }
-    return `${hex}${a}`;
-}
-function convertRgbToHsla(rgb) {
-    const actual = isRgbColor(rgb) ? rgb : { ...DEFAULT_RGB };
-    const blue = actual.blue / MAX_HEX;
-    const green = actual.green / MAX_HEX;
-    const red = actual.red / MAX_HEX;
-    const max = Math.max(blue, green, red);
-    const min = Math.min(blue, green, red);
-    const delta = max - min;
-    const lightness = (min + max) / 2;
-    let hue = 0;
-    let saturation = 0;
-    if (delta !== 0) {
-        saturation =
-            lightness === 0 || lightness === 1
-                ? 0
-                : (max - lightness) / Math.min(lightness, 1 - lightness);
-        switch (max) {
-            case blue:
-                hue = (red - green) / delta + 4;
-                break;
-            case green:
-                hue = (blue - red) / delta + 2;
-                break;
-            case red:
-                hue = (green - blue) / delta + (green < blue ? 6 : 0);
-                break;
-        }
-        hue *= 60;
-    }
-    if (saturation < 0) {
-        hue += MAX_DEGREE / 2;
-        saturation = Math.abs(saturation);
-    }
-    if (hue >= MAX_DEGREE) {
-        hue -= MAX_DEGREE;
-    }
-    return {
-        alpha: getAlphaValue(rgb.alpha ?? ALPHA_FULL_VALUE),
-        hue: +hue.toFixed(2),
-        lightness: +(lightness * MAX_PERCENT).toFixed(2),
-        saturation: +(saturation * MAX_PERCENT).toFixed(2),
-    };
-}
-/**
- * Convert an RGB(A) color to a hex color _(with optional alpha channel)_
- * @param rgb RGB(A) color
- * @param alpha Include alpha channel? _(defaults to `false`)_
- * @returns Hex color
- */
+	const hex = `${join([
+		rgb.red,
+		rgb.green,
+		rgb.blue
+	].map((color) => {
+		const hex$1 = color.toString(16);
+		return hex$1.length === 1 ? `0${hex$1}` : hex$1;
+	}))}`;
+	let a = "";
+	if (typeof alpha === "boolean" && alpha) a = getAlpha(rgb.alpha).hex;
+	return `${hex}${a}`;
+}
+function convertRgbToHsla(value) {
+	const rgb = isRgbLike(value) ? getRgbValue(value) : { ...DEFAULT_RGB };
+	const blue = rgb.blue / MAX_HEX;
+	const green = rgb.green / MAX_HEX;
+	const red = rgb.red / MAX_HEX;
+	const max$1 = Math.max(blue, green, red);
+	const min$1 = Math.min(blue, green, red);
+	const delta = max$1 - min$1;
+	const lightness = (min$1 + max$1) / 2;
+	let hue = 0;
+	let saturation = 0;
+	if (delta !== 0) {
+		saturation = (max$1 - lightness) / Math.min(lightness, 1 - lightness);
+		switch (max$1) {
+			case blue:
+				hue = (red - green) / delta + 4;
+				break;
+			case green:
+				hue = (blue - red) / delta + 2;
+				break;
+			case red:
+				hue = (green - blue) / delta + (green < blue ? 6 : 0);
+				break;
+		}
+		hue *= 60;
+	}
+	return {
+		alpha: getAlphaValue(value.alpha ?? ALPHA_FULL_VALUE),
+		hue: +hue.toFixed(2),
+		lightness: +(lightness * MAX_PERCENT).toFixed(2),
+		saturation: +(saturation * MAX_PERCENT).toFixed(2)
+	};
+}
+function getRgbValue(value) {
+	return {
+		blue: getHexValue(value.blue),
+		green: getHexValue(value.green),
+		red: getHexValue(value.red)
+	};
+}
 function rgbToHex(rgb, alpha) {
-    return convertRgbToHex(isRgbColor(rgb) ? rgb : { ...DEFAULT_RGB }, alpha ?? false);
-}
-/**
- * Convert an RGB(A) color to an HSL color
- *
- * Thanks, https://github.com/color-js/color.js/blob/main/src/spaces/hsl.js#L26
- * @param rgb RGB(A) color
- * @returns HSL color
- */
+	return convertRgbToHex(isRgbLike(rgb) ? getRgbValue(rgb) : { ...DEFAULT_RGB }, alpha ?? false);
+}
 function rgbToHsl(rgb) {
-    const { hue, lightness, saturation } = convertRgbToHsla(rgb);
-    return {
-        hue,
-        lightness,
-        saturation,
-    };
-}
-/**
- * Convert an RGB(A) color to an HSLA color
- *
- * Thanks, https://github.com/color-js/color.js/blob/main/src/spaces/hsl.js#L26
- * @param rgb RGB(A) color
- * @returns HSLA color
- */
+	const { hue, lightness, saturation } = convertRgbToHsla(rgb);
+	return {
+		hue,
+		lightness,
+		saturation
+	};
+}
 function rgbToHsla(rgb) {
-    return convertRgbToHsla(rgb);
+	return convertRgbToHsla(rgb);
 }
-
 function convertHexToRgba(value) {
-    const normalized = getNormalizedHex(value, true);
-    const pairs = EXPRESSION_HEX_LONG.exec(normalized);
-    const values = [];
-    const { length } = pairs;
-    for (let index = 1; index < length; index += 1) {
-        values.push(Number.parseInt(pairs[index], 16));
-    }
-    return {
-        alpha: values[3] / MAX_HEX,
-        blue: values[2],
-        green: values[1],
-        red: values[0],
-    };
-}
-/**
- * Get the normalized hex color from a value
- * @param value Value to normalize
- * @param alpha Include alpha channel? _(defaults to `false`)_
- * @returns Normalized hex color, or `000000` if the value is unable to be normalized
- */
+	const normalized = getNormalizedHex(value, true);
+	const pairs = EXPRESSION_HEX_LONG.exec(normalized);
+	const values = [];
+	const { length } = pairs;
+	for (let index = 1; index < length; index += 1) values.push(Number.parseInt(pairs[index], 16));
+	return {
+		alpha: values[3] / MAX_HEX,
+		blue: values[2],
+		green: values[1],
+		red: values[0]
+	};
+}
 function getNormalizedHex(value, alpha) {
-    const includeAlpha = alpha ?? false;
-    if (!isHexColor(value)) {
-        return `${HEX_BLACK}${includeAlpha ? ALPHA_FULL_HEX_LONG : ''}`;
-    }
-    const normalized = value.replace(EXPRESSION_PREFIX, '');
-    if (normalized.length < LENGTH_LONG) {
-        const hex = normalized.slice(0, LENGTH_SHORT);
-        const a = includeAlpha
-            ? (normalized[LENGTH_SHORT] ?? ALPHA_FULL_HEX_SHORT)
-            : '';
-        return join(`${hex}${a}`.split('').map(character => character.repeat(2)));
-    }
-    const hex = normalized.slice(0, LENGTH_LONG);
-    const a = includeAlpha
-        ? normalized.slice(LENGTH_LONG) || ALPHA_FULL_HEX_LONG
-        : '';
-    return `${hex}${a}`;
+	const includeAlpha = alpha ?? false;
+	if (!isHexColor(value)) return `${HEX_BLACK}${includeAlpha ? ALPHA_FULL_HEX_LONG : ""}`;
+	const normalized = value.replace(EXPRESSION_PREFIX, "");
+	if (normalized.length < LENGTH_LONG) return join(`${normalized.slice(0, LENGTH_SHORT)}${includeAlpha ? normalized[LENGTH_SHORT] ?? ALPHA_FULL_HEX_SHORT : ""}`.split("").map((character) => character.repeat(2)));
+	return `${normalized.slice(0, LENGTH_LONG)}${includeAlpha ? normalized.slice(LENGTH_LONG) || ALPHA_FULL_HEX_LONG : ""}`;
 }
 function hexToHsl(value) {
-    const { hue, lightness, saturation } = hexToHsla(value);
-    return {
-        hue,
-        lightness,
-        saturation,
-    };
+	const { hue, lightness, saturation } = hexToHsla(value);
+	return {
+		hue,
+		lightness,
+		saturation
+	};
 }
 function hexToHsla(value) {
-    return convertRgbToHsla(convertHexToRgba(value));
+	return convertRgbToHsla(convertHexToRgba(value));
 }
-/**
- * Convert a hex color to an RGB color
- * @param value Original value
- * @returns RGB color
- */
 function hexToRgb(value) {
-    const { blue, green, red } = convertHexToRgba(value);
-    return { blue, green, red };
-}
-/**
- * Convert a hex color to an RGBA color
- * @param value Original value
- * @returns RGBA color
- */
+	const { blue, green, red } = convertHexToRgba(value);
+	return {
+		blue,
+		green,
+		red
+	};
+}
 function hexToRgba(value) {
-    return convertHexToRgba(value);
-}
-
-function convertHslToRgba(hsl) {
-    const actual = isHslColor(hsl) ? hsl : { ...DEFAULT_HSL };
-    let hue = actual.hue % MAX_DEGREE;
-    if (hue < 0) {
-        hue += MAX_DEGREE;
-    }
-    const saturation = actual.saturation / MAX_PERCENT;
-    const lightness = actual.lightness / MAX_PERCENT;
-    return {
-        alpha: getAlphaValue(hsl.alpha ?? ALPHA_FULL_VALUE),
-        blue: clamp(Math.round(getHexyValue(hue, lightness, saturation, 4)), 0, MAX_HEX),
-        green: clamp(Math.round(getHexyValue(hue, lightness, saturation, 8)), 0, MAX_HEX),
-        red: clamp(Math.round(getHexyValue(hue, lightness, saturation, 0)), 0, MAX_HEX),
-    };
+	return convertHexToRgba(value);
+}
+function convertHslToRgba(value) {
+	const hsl = isHslLike(value) ? getHslValue(value) : { ...DEFAULT_HSL };
+	const hue = hsl.hue % MAX_DEGREE;
+	const saturation = hsl.saturation / MAX_PERCENT;
+	const lightness = hsl.lightness / MAX_PERCENT;
+	return {
+		alpha: getAlphaValue(value.alpha ?? ALPHA_FULL_VALUE),
+		blue: getHexValue(Math.round(getHexyValue(hue, lightness, saturation, 4))),
+		green: getHexValue(Math.round(getHexyValue(hue, lightness, saturation, 8))),
+		red: getHexValue(Math.round(getHexyValue(hue, lightness, saturation, 0)))
+	};
 }
 function getHexyValue(hue, lightness, saturation, value) {
-    const part = (value + hue / 30) % 12;
-    const mod = saturation * Math.min(lightness, 1 - lightness);
-    return ((lightness - mod * Math.max(-1, Math.min(part - 3, 9 - part, 1))) * MAX_HEX);
+	const part = (value + hue / 30) % 12;
+	return (lightness - saturation * Math.min(lightness, 1 - lightness) * Math.max(-1, Math.min(part - 3, 9 - part, 1))) * MAX_HEX;
+}
+function getHslValue(value) {
+	return {
+		hue: getDegrees(value.hue),
+		lightness: getPercentage(value.lightness),
+		saturation: getPercentage(value.saturation)
+	};
 }
 function hslToHex(hsl, alpha) {
-    return convertRgbToHex(convertHslToRgba(hsl), alpha ?? false);
-}
-/**
- * Convert an HSL(A) color to an RGB color
- *
- * Thanks, https://github.com/color-js/color.js/blob/main/src/spaces/hsl.js#L61
- * @param hsl HSL(A) color
- * @returns RGB color
- */
+	return convertRgbToHex(convertHslToRgba(hsl), alpha ?? false);
+}
 function hslToRgb(hsl) {
-    const { blue, green, red } = convertHslToRgba(hsl);
-    return {
-        blue,
-        green,
-        red,
-    };
-}
-/**
- * Convert an HSL(A) color to an RGBA color
- *
- * Thanks, https://github.com/color-js/color.js/blob/main/src/spaces/hsl.js#L61
- * @param hsl HSL(A) color
- * @returns RGBA color
- */
+	const { blue, green, red } = convertHslToRgba(hsl);
+	return {
+		blue,
+		green,
+		red
+	};
+}
 function hslToRgba(hsl) {
-    return convertHslToRgba(hsl);
+	return convertHslToRgba(hsl);
 }
-
 function getState(value) {
-    if (typeof value === 'string') {
-        const normalized = getNormalizedHex(value, true);
-        const hex = normalized.slice(0, LENGTH_LONG);
-        const rgb = hexToRgb(hex);
-        return {
-            hex,
-            rgb,
-            alpha: getAlpha(normalized.slice(LENGTH_LONG)),
-            hsl: rgbToHsl(rgb),
-        };
-    }
-    if (isColor(value)) {
-        return {
-            hex: value.hex,
-            hsl: value.hsl,
-            rgb: value.rgb,
-            alpha: getAlpha(value.alpha),
-        };
-    }
-    const state = {};
-    if (typeof value === 'object' && value !== null) {
-        state.alpha = getAlpha(value.alpha);
-        if (isHslColor(value)) {
-            state.hsl = {
-                hue: clamp(value.hue, 0, MAX_DEGREE),
-                lightness: clamp(value.lightness, 0, MAX_PERCENT),
-                saturation: clamp(value.saturation, 0, MAX_PERCENT),
-            };
-            state.rgb = hslToRgb(state.hsl);
-            state.hex = rgbToHex(state.rgb);
-            return state;
-        }
-        if (isRgbColor(value)) {
-            state.rgb = {
-                blue: clamp(value.blue, 0, MAX_HEX),
-                green: clamp(value.green, 0, MAX_HEX),
-                red: clamp(value.red, 0, MAX_HEX),
-            };
-            state.hex = rgbToHex(state.rgb);
-            state.hsl = rgbToHsl(state.rgb);
-            return state;
-        }
-    }
-    state.alpha ??= getAlpha(ALPHA_FULL_VALUE);
-    state.hex ??= String(HEX_BLACK);
-    state.hsl ??= { ...DEFAULT_HSL };
-    state.rgb ??= { ...DEFAULT_RGB };
-    return state;
+	if (typeof value === "string") {
+		const normalized = getNormalizedHex(value, true);
+		const hex = normalized.slice(0, LENGTH_LONG);
+		const rgb = hexToRgb(hex);
+		return {
+			hex,
+			rgb,
+			alpha: getAlpha(normalized.slice(LENGTH_LONG)),
+			hsl: rgbToHsl(rgb)
+		};
+	}
+	if (isColor(value)) return {
+		hex: value.hex,
+		hsl: value.hsl,
+		rgb: value.rgb,
+		alpha: getAlpha(value.alpha)
+	};
+	const state = {};
+	if (typeof value === "object" && value !== null) {
+		state.alpha = getAlpha(value.alpha);
+		if (KEYS_HSL.every((key) => key in value)) {
+			state.hsl = getHslValue(value);
+			state.rgb = hslToRgb(state.hsl);
+			state.hex = rgbToHex(state.rgb);
+			return state;
+		}
+		if (KEYS_RGB.every((key) => key in value)) {
+			state.rgb = getRgbValue(value);
+			state.hex = rgbToHex(state.rgb);
+			state.hsl = rgbToHsl(state.rgb);
+			return state;
+		}
+	}
+	state.alpha ??= getAlpha(ALPHA_FULL_VALUE);
+	state.hex ??= String(HEX_BLACK);
+	state.hsl ??= { ...DEFAULT_HSL };
+	state.rgb ??= { ...DEFAULT_RGB };
+	return state;
 }
 function setHexColor(state, value, alpha) {
-    if (!isHexColor(value) || (!alpha && value === state.hex)) {
-        return;
-    }
-    const normalized = getNormalizedHex(value, true);
-    const hex = normalized.slice(0, LENGTH_LONG);
-    const rgb = hexToRgb(hex);
-    state.hex = hex;
-    state.hsl = rgbToHsl(rgb);
-    state.rgb = rgb;
-    if (alpha) {
-        state.alpha = getAlpha(normalized.slice(LENGTH_LONG));
-    }
+	if (!isHexColor(value) || !alpha && value === state.hex) return;
+	const normalized = getNormalizedHex(value, true);
+	const hex = normalized.slice(0, LENGTH_LONG);
+	const rgb = hexToRgb(hex);
+	state.hex = hex;
+	state.hsl = rgbToHsl(rgb);
+	state.rgb = rgb;
+	if (alpha) state.alpha = getAlpha(normalized.slice(LENGTH_LONG));
 }
 function setHSLColor(state, value, alpha) {
-    if (!isHslColor(value)) {
-        return;
-    }
-    const rgb = hslToRgb(value);
-    state.hex = rgbToHex(rgb);
-    state.hsl = value;
-    state.rgb = rgb;
-    if (alpha) {
-        state.alpha = getAlpha(value.alpha);
-    }
+	if (!isHslLike(value)) return;
+	const hsl = {
+		hue: getDegrees(value.hue),
+		lightness: getPercentage(value.lightness),
+		saturation: getPercentage(value.saturation)
+	};
+	const rgb = hslToRgb(hsl);
+	state.hex = rgbToHex(rgb);
+	state.hsl = hsl;
+	state.rgb = rgb;
+	if (alpha) state.alpha = getAlpha(value.alpha);
 }
 function setRGBColor(state, value, alpha) {
-    if (!isRgbColor(value)) {
-        return;
-    }
-    state.hex = rgbToHex(value);
-    state.hsl = rgbToHsl(value);
-    state.rgb = value;
-    if (alpha) {
-        state.alpha = getAlpha(value.alpha);
-    }
-}
-
-class Color {
-    #state;
-    /**
-     * Get the alpha channel
-     */
-    get alpha() {
-        return this.#state.alpha.value;
-    }
-    /**
-     * Set the alpha channel
-     */
-    set alpha(value) {
-        if (typeof value === 'number' && !Number.isNaN(value)) {
-            this.#state.alpha = getAlpha(value);
-        }
-    }
-    /**
-     * Get the color as a hex color
-     */
-    get hex() {
-        return this.#state.hex;
-    }
-    /**
-     * Set colors from a hex color
-     */
-    set hex(value) {
-        setHexColor(this.#state, value, false);
-    }
-    /**
-     * Get the color as a hex color with an alpha channel
-     */
-    get hexa() {
-        return `${this.#state.hex}${this.#state.alpha.hex}`;
-    }
-    /**
-     * Set colors and alpha from a hex color with an alpha channel
-     */
-    set hexa(value) {
-        setHexColor(this.#state, value, true);
-    }
-    /**
-     * Get the color as an HSL color
-     */
-    get hsl() {
-        return this.#state.hsl;
-    }
-    /**
-     * Set colors from an HSL color
-     */
-    set hsl(value) {
-        setHSLColor(this.#state, value, false);
-    }
-    /**
-     * Get the color as an HSLA color
-     */
-    get hsla() {
-        return {
-            ...this.#state.hsl,
-            alpha: this.#state.alpha.value,
-        };
-    }
-    /**
-     * Set colors and alpha from an HSLA color
-     */
-    set hsla(value) {
-        setHSLColor(this.#state, value, true);
-    }
-    /**
-     * Get the color as an RGB color
-     */
-    get rgb() {
-        return this.#state.rgb;
-    }
-    /**
-     * Set colors from an RGB color
-     */
-    set rgb(value) {
-        setRGBColor(this.#state, value, false);
-    }
-    /**
-     * Get the color as an RGBA color
-     */
-    get rgba() {
-        return {
-            ...this.#state.rgb,
-            alpha: this.#state.alpha.value,
-        };
-    }
-    /**
-     * Set colors and alpha from an RGBA color
-     */
-    set rgba(value) {
-        setRGBColor(this.#state, value, true);
-    }
-    constructor(value) {
-        this.#state = getState(value);
-        Object.defineProperty(this, '$color', {
-            value: true,
-        });
-    }
-    toHexString(alpha) {
-        return `#${alpha === true ? this.hexa : this.hex}`;
-    }
-    toHslString(alpha) {
-        return formatColor('hsl', this, alpha === true);
-    }
-    toRgbString(alpha) {
-        return formatColor('rgb', this, alpha === true);
-    }
-    toString() {
-        return this.toHexString();
-    }
-}
-
-/**
- * Get a foreground color _(usually text)_ based on a background color's luminance
- * @param value Original value
- * @returns Foreground color
- */
-function getForegroundColor(value) {
-    const state = getState(value);
-    const { blue, green, red } = state.rgb;
-    const values = [blue / MAX_HEX, 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 luminance = SRGB_LUMINANCE_RED * values[2] +
-        SRGB_LUMINANCE_GREEN * values[1] +
-        SRGB_LUMINANCE_BLUE * values[0];
-    // Rudimentary and ureliable?; implement APCA for more reliable results?
-    return new Color(luminance > SRGB_LUMINANCE_THRESHOLD ? HEX_BLACK : HEX_WHITE);
-}
-/**
- * Get the hex color _(with alpha channel)_ from any kind of value
- * @param value Original value
- * @returns Hex color
- */
-function getHexaColor(value) {
-    const { alpha, hex } = getState(value);
-    return `${hex}${alpha.hex}`;
-}
-/**
- * Get the hex color from any kind of value
- * @param value Original value
- * @returns Hex color
- */
-function getHexColor(value) {
-    return getState(value).hex;
-}
-/**
- * Get the HSLA color from any kind of value
- * @param value Original value
- * @returns HSLA color
- */
-function getHslaColor(value) {
-    const { alpha, hsl } = getState(value);
-    return {
-        ...hsl,
-        alpha: alpha.value,
-    };
-}
-/**
- * Get the HSL color from any kind of value
- * @param value Original value
- * @returns HSL color
- */
-function getHslColor(value) {
-    return getState(value).hsl;
-}
-/**
- * Get the RGBA color from any kind of value
- * @param value Original value
- * @returns RGBA color
- */
-function getRgbaColor(value) {
-    const { alpha, rgb } = getState(value);
-    return {
-        ...rgb,
-        alpha: alpha.value,
-    };
-}
-/**
- * Get the RGB color from any kind of value
- * @param value Original value
- * @returns RGB color
- */
-function getRgbColor(value) {
-    return getState(value).rgb;
-}
-
-/**
- * Get a Color from any kind of value
- * @param value Original value
- * @returns Color instance
- */
+	if (!isRgbLike(value)) return;
+	const rgb = {
+		blue: getHexValue(value.blue),
+		green: getHexValue(value.green),
+		red: getHexValue(value.red)
+	};
+	state.hex = rgbToHex(rgb);
+	state.hsl = rgbToHsl(rgb);
+	state.rgb = rgb;
+	if (alpha) state.alpha = getAlpha(value.alpha);
+}
+var Color = class {
+	#state;
+	get alpha() {
+		return this.#state.alpha.value;
+	}
+	set alpha(value) {
+		if (typeof value === "number" && !Number.isNaN(value)) this.#state.alpha = getAlpha(value);
+	}
+	get hex() {
+		return this.#state.hex;
+	}
+	set hex(value) {
+		setHexColor(this.#state, value, false);
+	}
+	get hexa() {
+		return `${this.#state.hex}${this.#state.alpha.hex}`;
+	}
+	set hexa(value) {
+		setHexColor(this.#state, value, true);
+	}
+	get hsl() {
+		return this.#state.hsl;
+	}
+	set hsl(value) {
+		setHSLColor(this.#state, value, false);
+	}
+	get hsla() {
+		return {
+			...this.#state.hsl,
+			alpha: this.#state.alpha.value
+		};
+	}
+	set hsla(value) {
+		setHSLColor(this.#state, value, true);
+	}
+	get rgb() {
+		return this.#state.rgb;
+	}
+	set rgb(value) {
+		setRGBColor(this.#state, value, false);
+	}
+	get rgba() {
+		return {
+			...this.#state.rgb,
+			alpha: this.#state.alpha.value
+		};
+	}
+	set rgba(value) {
+		setRGBColor(this.#state, value, true);
+	}
+	constructor(value) {
+		this.#state = getState(value);
+		Object.defineProperty(this, "$color", { value: true });
+	}
+	toHexString(alpha) {
+		return `#${alpha === true ? this.hexa : this.hex}`;
+	}
+	toHslString(alpha) {
+		return formatColor("hsl", this, alpha === true);
+	}
+	toRgbString(alpha) {
+		return formatColor("rgb", this, alpha === true);
+	}
+	toString() {
+		return this.toHexString();
+	}
+};
 function getColor(value) {
-    return isColor(value) ? value : new Color(value);
-}
-
-function calculate() {
-    return new Promise(resolve => {
-        const values = [];
-        let last;
-        function step(now) {
-            if (last != null) {
-                values.push(now - last);
-            }
-            last = now;
-            if (values.length >= CALCULATION_TOTAL) {
-                const median = values
-                    .sort()
-                    .slice(2, -2)
-                    .reduce((first, second) => first + second, 0) /
-                    (values.length - CALCULATION_TRIM);
-                resolve(median);
-            }
-            else {
-                requestAnimationFrame(step);
-            }
-        }
-        requestAnimationFrame(step);
-    });
-}
-/**
- * A function that does nothing, which can be useful, I guess…
- */
-function noop() { }
-//
-const CALCULATION_TOTAL = 10;
-const CALCULATION_TRIM = 4;
-const DEFAULT_FPS = 60;
-const MILLISECONDS_IN_SECOND = 1000;
-/**
- * A calculated average of the refresh rate of the display _(in milliseconds)_
- */
-let milliseconds = MILLISECONDS_IN_SECOND / DEFAULT_FPS;
-calculate().then(value => {
-    milliseconds = value;
-});
-
-class Emitter {
-    #state;
-    /**
-     * Is the emitter active?
-     */
-    get active() {
-        return this.#state.active;
-    }
-    /**
-     * The observable that can be subscribed to
-     */
-    get observable() {
-        return this.#state.observable;
-    }
-    /**
-     * The current value
-     */
-    get value() {
-        return this.#state.value;
-    }
-    constructor(value) {
-        const observers = new Map();
-        this.#state = {
-            observers,
-            value,
-            active: true,
-            observable: new Observable(this, observers),
-        };
-    }
-    /**
-     * Destroy the emitter
-     */
-    destroy() {
-        finishEmitter(this.#state, false);
-    }
-    /**
-     * Emit a new value
-     * @param value Value to set and emit
-     * @param finish Finish the emitter after emitting? _(defaults to `false`)_
-     */
-    emit(value, finish) {
-        this.#on('next', finish ?? false, value);
-    }
-    /**
-     * Emit an error
-     * @param error Error to emit
-     * @param finish Finish the emitter after emitting? _(defaults to `false`)_
-     */
-    error(error, finish) {
-        this.#on('error', finish ?? false, error);
-    }
-    /**
-     * Finish the emitter
-     */
-    finish() {
-        finishEmitter(this.#state, true);
-    }
-    #on(type, finish, value) {
-        if (this.#state.active) {
-            if (type === 'next') {
-                this.#state.value = value;
-            }
-            for (const [, observer] of this.#state.observers) {
-                observer[type]?.(value);
-            }
-            if (finish === true) {
-                finishEmitter(this.#state, true);
-            }
-        }
-    }
-}
-class Observable {
-    #state;
-    constructor(emitter, observers) {
-        this.#state = {
-            emitter,
-            observers,
-            closed: false,
-        };
-    }
-    /**
-     * Destroy the observable
-     */
-    destroy() {
-        this.#state.closed = true;
-    }
-    subscribe(first, second, third) {
-        if (this.#state.closed) {
-            throw new Error('Cannot subscribe to a destroyed observable');
-        }
-        const observer = getObserver(first, second, third);
-        const instance = new Subscription(this.#state);
-        this.#state.observers.set(instance, observer);
-        observer.next?.(this.#state.emitter.value);
-        return instance;
-    }
-}
-class Subscription {
-    #state;
-    constructor(state) {
-        this.#state = {
-            ...state,
-            closed: false,
-        };
-    }
-    /**
-     * Is the subscription closed?
-     */
-    get closed() {
-        return this.#state.closed || !this.#state.emitter.active;
-    }
-    /**
-     * Destroy the subscription
-     */
-    destroy() {
-        if (!this.#state.closed) {
-            this.unsubscribe();
-        }
-    }
-    /**
-     * Unsubscribe from its observable
-     */
-    unsubscribe() {
-        if (!this.#state.closed) {
-            this.#state.closed = true;
-            this.#state.observers.delete(this);
-        }
-    }
-}
-/**
- * Create a new emitter
- * @param value Initial value
- * @returns Emitter instance
- */
+	return isColor(value) ? value : new Color(value);
+}
+function noop() {}
+var Emitter = class {
+	#state;
+	get active() {
+		return this.#state.active;
+	}
+	get observable() {
+		return this.#state.observable;
+	}
+	get value() {
+		return this.#state.value;
+	}
+	constructor(value) {
+		const observers = /* @__PURE__ */ new Map();
+		this.#state = {
+			observers,
+			value,
+			active: true,
+			observable: new Observable(this, observers)
+		};
+	}
+	destroy() {
+		finishEmitter(this.#state, false);
+	}
+	emit(value, finish) {
+		this.#on("next", finish ?? false, value);
+	}
+	error(error, finish) {
+		this.#on("error", finish ?? false, error);
+	}
+	finish() {
+		finishEmitter(this.#state, true);
+	}
+	#on(type, finish, value) {
+		if (this.#state.active) {
+			if (type === "next") this.#state.value = value;
+			for (const [, observer] of this.#state.observers) observer[type]?.(value);
+			if (finish === true) finishEmitter(this.#state, true);
+		}
+	}
+};
+var Observable = class {
+	#state;
+	constructor(emitter$1, observers) {
+		this.#state = {
+			emitter: emitter$1,
+			observers,
+			closed: false
+		};
+	}
+	destroy() {
+		this.#state.closed = true;
+	}
+	subscribe(first, second, third) {
+		if (this.#state.closed) throw new Error("Cannot subscribe to a destroyed observable");
+		const observer = getObserver(first, second, third);
+		const instance = new Subscription(this.#state);
+		this.#state.observers.set(instance, observer);
+		observer.next?.(this.#state.emitter.value);
+		return instance;
+	}
+};
+var Subscription = class {
+	#state;
+	constructor(state) {
+		this.#state = {
+			...state,
+			closed: false
+		};
+	}
+	get closed() {
+		return this.#state.closed || !this.#state.emitter.active;
+	}
+	destroy() {
+		if (!this.#state.closed) this.unsubscribe();
+	}
+	unsubscribe() {
+		if (!this.#state.closed) {
+			this.#state.closed = true;
+			this.#state.observers.delete(this);
+		}
+	}
+};
 function emitter(value) {
-    return new Emitter(value);
+	return new Emitter(value);
 }
 function finishEmitter(state, emit) {
-    if (state.active) {
-        state.active = false;
-        const entries = [...state.observers.entries()];
-        const { length } = entries;
-        for (let index = 0; index < length; index += 1) {
-            const [subscription, observer] = entries[index];
-            if (emit) {
-                observer.complete?.();
-            }
-            subscription.destroy();
-        }
-        state.observable?.destroy();
-        state.observers.clear();
-    }
+	if (state.active) {
+		state.active = false;
+		const entries = [...state.observers.entries()];
+		const { length } = entries;
+		for (let index = 0; index < length; index += 1) {
+			const [subscription, observer] = entries[index];
+			if (emit) observer.complete?.();
+			subscription.destroy();
+		}
+		state.observable?.destroy();
+		state.observers.clear();
+	}
 }
 function getFunction(value, defaultValue) {
-    return typeof value === 'function' ? value : defaultValue;
+	return typeof value === "function" ? value : defaultValue;
 }
 function getObserver(first, second, third) {
-    let observer = {
-        next: noop,
-    };
-    if (typeof first === 'function') {
-        observer = {
-            error: getFunction(second, noop),
-            next: getFunction(first, noop),
-            complete: getFunction(third, noop),
-        };
-    }
-    else if (typeof first === 'object') {
-        observer.complete = getFunction(first?.complete, noop);
-        observer.error = getFunction(first?.error, noop);
-        observer.next = getFunction(first?.next, noop);
-    }
-    return observer;
-}
-
-/**
- * A Map with a maximum size
- *
- * Behaviour is similar to a _LRU_-cache, where the least recently used entries are removed
- */
-class SizedMap extends Map {
-    /**
-     * The maximum size of the Map
-     */
-    #maximumSize;
-    /**
-     * Is the Map full?
-     */
-    get full() {
-        return this.size >= this.#maximumSize;
-    }
-    get maximum() {
-        return this.#maximumSize;
-    }
-    constructor(first, second) {
-        const maximum = getMaximum(first, second);
-        super();
-        this.#maximumSize = maximum;
-        if (Array.isArray(first)) {
-            const { length } = first;
-            if (length <= maximum) {
-                for (let index = 0; index < length; index += 1) {
-                    this.set(...first[index]);
-                }
-            }
-            else {
-                for (let index = 0; index < maximum; index += 1) {
-                    this.set(...first[length - maximum + index]);
-                }
-            }
-        }
-    }
-    /**
-     * @inheritdoc
-     */
-    get(key) {
-        const value = super.get(key);
-        if (value !== undefined || this.has(key)) {
-            this.set(key, value);
-        }
-        return value;
-    }
-    /**
-     * @inheritdoc
-     */
-    set(key, value) {
-        if (this.has(key)) {
-            this.delete(key);
-        }
-        else if (this.size >= this.#maximumSize) {
-            this.delete(this.keys().next().value);
-        }
-        return super.set(key, value);
-    }
-}
-/**
- * - A Set with a maximum size
- * - Behaviour is similar to a _LRU_-cache, where the oldest values are removed
- */
-class SizedSet extends Set {
-    /**
-     * The maximum size of the Set
-     */
-    #maximumSize;
-    /**
-     * Is the Set full?
-     */
-    get full() {
-        return this.size >= this.#maximumSize;
-    }
-    get maximum() {
-        return this.#maximumSize;
-    }
-    constructor(first, second) {
-        const maximum = getMaximum(first, second);
-        super();
-        this.#maximumSize = maximum;
-        if (Array.isArray(first)) {
-            const { length } = first;
-            if (length <= maximum) {
-                for (let index = 0; index < length; index += 1) {
-                    this.add(first[index]);
-                }
-            }
-            else {
-                for (let index = 0; index < maximum; index += 1) {
-                    this.add(first[length - maximum + index]);
-                }
-            }
-        }
-    }
-    /**
-     * @inheritdoc
-     */
-    add(value) {
-        if (this.has(value)) {
-            this.delete(value);
-        }
-        else if (this.size >= this.#maximumSize) {
-            this.delete(this.values().next().value);
-        }
-        return super.add(value);
-    }
-    /**
-     * Get a value from the SizedSet, if it exists _(and move it to the end)_
-     * @param value Value to get from the SizedSet
-     * @param update Update the value's position in the SizedSet? _(defaults to `false`)_
-     * @returns The value if it exists, otherwise `undefined`
-     */
-    get(value, update) {
-        if (this.has(value)) {
-            if (update ?? false) {
-                this.delete(value);
-                this.add(value);
-            }
-            return value;
-        }
-    }
-}
+	let observer = { next: noop };
+	if (typeof first === "function") observer = {
+		error: getFunction(second, noop),
+		next: getFunction(first, noop),
+		complete: getFunction(third, noop)
+	};
+	else if (typeof first === "object") {
+		observer.complete = getFunction(first?.complete, noop);
+		observer.error = getFunction(first?.error, noop);
+		observer.next = getFunction(first?.next, noop);
+	}
+	return observer;
+}
+var SizedMap = class extends Map {
+	#maximumSize;
+	get full() {
+		return this.size >= this.#maximumSize;
+	}
+	get maximum() {
+		return this.#maximumSize;
+	}
+	constructor(first, second) {
+		const maximum = getMaximum(first, second);
+		super();
+		this.#maximumSize = maximum;
+		if (Array.isArray(first)) {
+			const { length } = first;
+			if (length <= maximum) for (let index = 0; index < length; index += 1) this.set(...first[index]);
+			else for (let index = 0; index < maximum; index += 1) this.set(...first[length - maximum + index]);
+		}
+	}
+	get(key) {
+		const value = super.get(key);
+		if (value !== void 0 || this.has(key)) this.set(key, value);
+		return value;
+	}
+	set(key, value) {
+		if (this.has(key)) this.delete(key);
+		else if (this.size >= this.#maximumSize) this.delete(this.keys().next().value);
+		return super.set(key, value);
+	}
+};
+var SizedSet = class extends Set {
+	#maximumSize;
+	get full() {
+		return this.size >= this.#maximumSize;
+	}
+	get maximum() {
+		return this.#maximumSize;
+	}
+	constructor(first, second) {
+		const maximum = getMaximum(first, second);
+		super();
+		this.#maximumSize = maximum;
+		if (Array.isArray(first)) {
+			const { length } = first;
+			if (length <= maximum) for (let index = 0; index < length; index += 1) this.add(first[index]);
+			else for (let index = 0; index < maximum; index += 1) this.add(first[length - maximum + index]);
+		}
+	}
+	add(value) {
+		if (this.has(value)) this.delete(value);
+		else if (this.size >= this.#maximumSize) this.delete(this.values().next().value);
+		return super.add(value);
+	}
+	get(value, update) {
+		if (this.has(value)) {
+			if (update ?? false) {
+				this.delete(value);
+				this.add(value);
+			}
+			return value;
+		}
+	}
+};
 function getMaximum(first, second) {
-    let actual;
-    if (typeof first === 'number') {
-        actual = first;
-    }
-    else {
-        actual = typeof second === 'number' ? second : MAXIMUM_DEFAULT;
-    }
-    return clamp(actual, 1, MAXIMUM_ABSOLUTE);
-}
-//
-const MAXIMUM_ABSOLUTE = 16_777_216;
-const MAXIMUM_DEFAULT = 1_048_576;
-
-class Memoized {
-    #state;
-    /**
-     * Maximum cache size
-     */
-    get maximum() {
-        return this.#state.cache?.maximum ?? Number.NaN;
-    }
-    /**
-     * Current cache size
-     */
-    get size() {
-        return this.#state.cache?.size ?? Number.NaN;
-    }
-    constructor(callback, size) {
-        const cache = new SizedMap(size);
-        const getter = (...parameters) => {
-            const key = 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);
-            return value;
-        };
-        this.#state = { cache, getter };
-    }
-    /**
-     * Clear the cache
-     */
-    clear() {
-        this.#state.cache?.clear();
-    }
-    /**
-     * Delete a result from the cache
-     * @param key Key to delete
-     * @returns `true` if the key existed and was removed, otherwise `false`
-     */
-    delete(key) {
-        return this.#state.cache?.delete(key) ?? false;
-    }
-    /**
-     * Destroy the instance _(clearing its cache and removing its callback)_
-     */
-    destroy() {
-        this.#state.cache?.clear();
-        this.#state.cache = undefined;
-        this.#state.getter = undefined;
-    }
-    /**
-     * Get a result from the cache
-     * @param key Key to get
-     * @returns The cached result or `undefined` if it does not exist
-     */
-    get(key) {
-        return this.#state.cache?.get(key);
-    }
-    /**
-     * Does the result exist?
-     * @param key Key to check
-     * @returns `true` if the result exists, otherwise `false`
-     */
-    has(key) {
-        return this.#state.cache?.has(key) ?? false;
-    }
-    /**
-     * Run the callback with the provided parameters
-     * @param parameters Parameters to pass to the callback
-     * @returns Cached or computed _(then cached)_ result
-     */
-    run(...parameters) {
-        if (this.#state.cache == null || this.#state.getter == null) {
-            /* istanbul ignore next */
-            throw new Error('The Memoized instance has been destroyed');
-        }
-        return this.#state.getter(...parameters);
-    }
-}
-/**
- * Debounce a function, ensuring it is only called after `time` milliseconds have passed
- *
- * On subsequent calls, the timer is reset and will wait another `time` milliseconds _(and so on...)_
- * @param callback Callback to debounce
- * @param time Time in milliseconds to wait before calling the callback _(defaults to match frame rate)_
- * @returns Debounced callback with a `cancel` method
- */
+	let actual;
+	if (typeof first === "number") actual = first;
+	else actual = typeof second === "number" ? second : MAXIMUM_DEFAULT;
+	return clamp(actual, 1, MAXIMUM_ABSOLUTE);
+}
+const MAXIMUM_ABSOLUTE = 16777216;
+const MAXIMUM_DEFAULT = 1048576;
+var Memoized = class {
+	#state;
+	get maximum() {
+		return this.#state.cache?.maximum ?? NaN;
+	}
+	get size() {
+		return this.#state.cache?.size ?? NaN;
+	}
+	constructor(callback, size) {
+		const cache = new SizedMap(size);
+		const getter = (...parameters) => {
+			const key = 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);
+			return value;
+		};
+		this.#state = {
+			cache,
+			getter
+		};
+	}
+	clear() {
+		this.#state.cache?.clear();
+	}
+	delete(key) {
+		return this.#state.cache?.delete(key) ?? false;
+	}
+	destroy() {
+		this.#state.cache?.clear();
+		this.#state.cache = void 0;
+		this.#state.getter = void 0;
+	}
+	get(key) {
+		return this.#state.cache?.get(key);
+	}
+	has(key) {
+		return this.#state.cache?.has(key) ?? false;
+	}
+	run(...parameters) {
+		if (this.#state.cache == null || this.#state.getter == null) throw new Error("The Memoized instance has been destroyed");
+		return this.#state.getter(...parameters);
+	}
+};
 function debounce(callback, time) {
-    const interval = typeof time === 'number' && time >= milliseconds ? time : milliseconds;
-    function step(now, parameters) {
-        if (interval === milliseconds || 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 - milliseconds;
-            step(now, parameters);
-        });
-    };
-    debounced.cancel = () => {
-        if (frame != null) {
-            cancelAnimationFrame(frame);
-            frame = undefined;
-        }
-    };
-    return debounced;
-}
-/**
- * Memoize a function, caching and retrieving results based on the first parameter
- * @param callback Callback to memoize
- * @param cacheSize Size of the cache
- * @returns Memoized instance
- */
+	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;
+}
 function memoize(callback, cacheSize) {
-    return new Memoized(callback, typeof cacheSize === 'number' && cacheSize > 0
-        ? cacheSize
-        : DEFAULT_CACHE_SIZE);
-}
-/**
- * Throttle a function, ensuring it is only called once every `time` milliseconds
- * @param callback Callback to throttle
- * @param time Time in milliseconds to wait before calling the callback again _(defaults to match frame rate)_
- * @returns Throttled callback with a `cancel` method
- */
+	return new Memoized(callback, typeof cacheSize === "number" && cacheSize > 0 ? cacheSize : DEFAULT_CACHE_SIZE);
+}
 function throttle(callback, time) {
-    const interval = typeof time === 'number' && time >= milliseconds ? time : milliseconds;
-    function step(now, parameters) {
-        if (interval === milliseconds || now - last >= interval) {
-            last = now;
-            callback(...parameters);
-        }
-        else {
-            frame = requestAnimationFrame(next => {
-                step(next, parameters);
-            });
-        }
-    }
-    let last;
-    let frame;
-    const throttler = (...parameters) => {
-        throttler.cancel();
-        frame = requestAnimationFrame(now => {
-            last ??= now - milliseconds;
-            step(now, parameters);
-        });
-    };
-    throttler.cancel = () => {
-        if (frame != null) {
-            cancelAnimationFrame(frame);
-            frame = undefined;
-        }
-    };
-    return throttler;
-}
-//
-const DEFAULT_CACHE_SIZE = 65_536;
-
+	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;
+			callback(...parameters);
+		} else frame = requestAnimationFrame((next) => {
+			step(next, parameters);
+		});
+	}
+	let last;
+	let frame;
+	const throttler = (...parameters) => {
+		throttler.cancel();
+		frame = requestAnimationFrame((now) => {
+			last ??= now - frame_rate_default;
+			step(now, parameters);
+		});
+	};
+	throttler.cancel = () => {
+		if (frame != null) {
+			cancelAnimationFrame(frame);
+			frame = void 0;
+		}
+	};
+	return throttler;
+}
+const DEFAULT_CACHE_SIZE = 65536;
 let enabled = true;
-class Logger {
-    /**
-     * Log any number of values at the "debug" log level
-     */
-    get debug() {
-        return enabled ? console.debug : noop;
-    }
-    /**
-     * Log the value and shows all its properties
-     */
-    get dir() {
-        return enabled ? console.dir : noop;
-    }
-    /**
-     * Is logging to the console enabled? _(defaults to `true`)_
-     */
-    get enabled() {
-        return enabled;
-    }
-    /**
-     * Enable or disable logging to the console
-     */
-    set enabled(value) {
-        enabled = typeof value === 'boolean' ? value : enabled;
-    }
-    /**
-     * Log any number of values at the "error" log level
-     */
-    get error() {
-        return enabled ? console.error : noop;
-    }
-    /**
-     * Log any number of values at the "info" log level
-     */
-    get info() {
-        return enabled ? console.info : noop;
-    }
-    /**
-     * Log any number of values at the "log" log level
-     */
-    get log() {
-        return enabled ? console.log : noop;
-    }
-    /**
-     * Log data as a table, with optional properties to use as columns
-     */
-    get table() {
-        return enabled ? console.table : noop;
-    }
-    /**
-     * Log any number of values together with a trace from where it was called
-     */
-    get trace() {
-        return enabled ? console.trace : noop;
-    }
-    /**
-     * Log any number of values at the "warn" log level
-     */
-    get warn() {
-        return enabled ? console.warn : noop;
-    }
-    /**
-     * Start a logged timer with a label
-     * @param label Label for the timer
-     * @returns Time instance
-     */
-    time(label) {
-        return new Time(label);
-    }
-}
-class Time {
-    #state;
-    constructor(label) {
-        this.#state = {
-            label,
-            started: enabled,
-            stopped: false,
-        };
-        if (this.#state.started) {
-            console.time(label);
-        }
-    }
-    /**
-     * Log the current duration of the timer _(ignored if logging is disabled)_
-     */
-    log() {
-        if (this.#state.started && !this.#state.stopped && enabled) {
-            console.timeLog(this.#state.label);
-        }
-    }
-    /**
-     * Stop the timer and logs the total duration
-     *
-     * _(Will always log the total duration, even if logging is disabled)_
-     */
-    stop() {
-        if (this.#state.started && !this.#state.stopped) {
-            this.#state.stopped = true;
-            console.timeEnd(this.#state.label);
-        }
-    }
-}
+var Logger = class {
+	get debug() {
+		return enabled ? console.debug : noop;
+	}
+	get dir() {
+		return enabled ? console.dir : noop;
+	}
+	get enabled() {
+		return enabled;
+	}
+	set enabled(value) {
+		enabled = typeof value === "boolean" ? value : enabled;
+	}
+	get error() {
+		return enabled ? console.error : noop;
+	}
+	get info() {
+		return enabled ? console.info : noop;
+	}
+	get log() {
+		return enabled ? console.log : noop;
+	}
+	get table() {
+		return enabled ? console.table : noop;
+	}
+	get trace() {
+		return enabled ? console.trace : noop;
+	}
+	get warn() {
+		return enabled ? console.warn : noop;
+	}
+	time(label) {
+		return new Time(label);
+	}
+};
+var Time = class {
+	#state;
+	constructor(label) {
+		this.#state = {
+			label,
+			started: enabled,
+			stopped: false
+		};
+		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);
+		}
+	}
+};
 const logger = new Logger();
-
 function average(array, key) {
-    const aggregated = aggregate('average', array, key);
-    return aggregated.count > 0
-        ? aggregated.value / aggregated.count
-        : Number.NaN;
+	const aggregated = aggregate("average", array, key);
+	return aggregated.count > 0 ? aggregated.value / aggregated.count : NaN;
 }
 function count(array, key, value) {
-    if (!Array.isArray(array)) {
-        return Number.NaN;
-    }
-    const { length } = array;
-    if (key == null) {
-        return length;
-    }
-    if (typeof key !== 'string' && typeof key !== 'function') {
-        return Number.NaN;
-    }
-    const callback = typeof key === 'function'
-        ? key
-        : (item) => item[key];
-    let count = 0;
-    for (let index = 0; index < length; index += 1) {
-        const item = array[index];
-        if (Object.is(callback(item, index, array), value)) {
-            count += 1;
-        }
-    }
-    return count;
+	if (!Array.isArray(array)) return NaN;
+	const { length } = array;
+	if (key == null) return length;
+	if (typeof key !== "string" && typeof key !== "function") return NaN;
+	const callback = typeof key === "function" ? key : (item) => item[key];
+	let count$1 = 0;
+	for (let index = 0; index < length; index += 1) {
+		const item = array[index];
+		if (Object.is(callback(item, index, array), value)) count$1 += 1;
+	}
+	return count$1;
 }
 function min(array, key) {
-    const aggregated = aggregate('min', array, key);
-    return aggregated.count > 0 ? aggregated.value : Number.NaN;
-}
-/**
- * Round a number
- * @param value Number to round
- * @param decimals Number of decimal places to round to _(defaults to `0`)_
- * @returns Rounded number, or `NaN` if the value if unable to be rounded
- */
+	const aggregated = aggregate("min", array, key);
+	return aggregated.count > 0 ? aggregated.value : NaN;
+}
 function round(value, decimals) {
-    if (typeof value !== 'number') {
-        return Number.NaN;
-    }
-    if (typeof decimals !== 'number' || decimals < 1) {
-        return Math.round(value);
-    }
-    const mod = 10 ** decimals;
-    return Math.round((value + Number.EPSILON) * mod) / mod;
+	if (typeof value !== "number") return NaN;
+	if (typeof decimals !== "number" || decimals < 1) return Math.round(value);
+	const mod = 10 ** 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 : Number.NaN;
+	const aggregated = aggregate("sum", array, key);
+	return aggregated.count > 0 ? aggregated.value : NaN;
 }
-
 function findKey(needle, haystack) {
-    const keys = Object.keys(haystack);
-    const normalized = keys.map(key => key.toLowerCase());
-    const index = normalized.indexOf(needle.toLowerCase());
-    return index > -1 ? keys[index] : needle;
+	const keys = Object.keys(haystack);
+	const index = keys.map((key) => key.toLowerCase()).indexOf(needle.toLowerCase());
+	return index > -1 ? keys[index] : needle;
 }
 function getPaths(path, lowercase) {
-    const normalized = lowercase ? path.toLowerCase() : path;
-    if (!EXPRESSION_NESTED.test(normalized)) {
-        return normalized;
-    }
-    return normalized
-        .replace(EXPRESSION_BRACKET, '.$1')
-        .replace(EXPRESSION_DOTS, '')
-        .split('.');
+	const normalized = lowercase ? path.toLowerCase() : path;
+	if (!EXPRESSION_NESTED.test(normalized)) return normalized;
+	return normalized.replace(EXPRESSION_BRACKET, ".$1").replace(EXPRESSION_DOTS, "").split(".");
 }
 function handleValue(data, path, value, get, ignoreCase) {
-    if (typeof data === 'object' && data !== null && !ignoreKey(path)) {
-        const key = ignoreCase ? findKey(path, data) : path;
-        if (get) {
-            return data[key];
-        }
-        data[key] = value;
-    }
-}
-//
+	if (typeof data === "object" && data !== null && !ignoreKey(path)) {
+		const key = ignoreCase ? findKey(path, data) : path;
+		if (get) return data[key];
+		data[key] = value;
+	}
+}
 const EXPRESSION_BRACKET = /\[(\w+)\]/g;
 const EXPRESSION_DOTS = /^\.|\.$/g;
 const EXPRESSION_NESTED = /\.|\[\w+\]/;
-
 function setValue(data, path, value, ignoreCase) {
-    if (typeof data !== 'object' ||
-        data === null ||
-        typeof path !== 'string' ||
-        path.trim().length === 0) {
-        return data;
-    }
-    const shouldIgnoreCase = ignoreCase === true;
-    const paths = getPaths(path, shouldIgnoreCase);
-    if (typeof paths === 'string') {
-        handleValue(data, paths, value, false, shouldIgnoreCase);
-        return data;
-    }
-    const { length } = paths;
-    const lastIndex = length - 1;
-    let target = data;
-    for (let index = 0; index < length; index += 1) {
-        const path = paths[index];
-        if (index === lastIndex) {
-            handleValue(target, path, value, false, shouldIgnoreCase);
-            break;
-        }
-        let next = handleValue(target, path, null, true, shouldIgnoreCase);
-        if (typeof next !== 'object' || next === null) {
-            const nextPath = paths[index + 1];
-            if (EXPRESSION_INDEX.test(nextPath)) {
-                const length = Number.parseInt(nextPath, 10) + 1;
-                next = Array.from({ length }, () => undefined);
-            }
-            else {
-                next = {};
-            }
-            target[path] = next;
-        }
-        target = next;
-    }
-    return data;
-}
-//
+	if (typeof data !== "object" || data === null || typeof path !== "string" || path.trim().length === 0) return data;
+	const shouldIgnoreCase = ignoreCase === true;
+	const paths = getPaths(path, shouldIgnoreCase);
+	if (typeof paths === "string") {
+		handleValue(data, paths, value, false, shouldIgnoreCase);
+		return data;
+	}
+	const { length } = paths;
+	const lastIndex = length - 1;
+	let target = data;
+	for (let index = 0; index < length; index += 1) {
+		const path$1 = paths[index];
+		if (index === lastIndex) {
+			handleValue(target, path$1, value, false, shouldIgnoreCase);
+			break;
+		}
+		let next = handleValue(target, path$1, null, true, shouldIgnoreCase);
+		if (typeof next !== "object" || next === null) {
+			const nextPath = paths[index + 1];
+			if (EXPRESSION_INDEX.test(nextPath)) {
+				const length$1 = Number.parseInt(nextPath, 10) + 1;
+				next = Array.from({ length: length$1 }, () => void 0);
+			} else next = {};
+			target[path$1] = next;
+		}
+		target = next;
+	}
+	return data;
+}
 const EXPRESSION_INDEX = /^\d+$/;
-
-/**
- * Convert a query string to a plain _(nested)_ object
- * @param query Query string to convert
- * @returns Plain object representation of the query string
- */
 function fromQuery(query) {
-    if (typeof query !== 'string' || query.trim().length === 0) {
-        return {};
-    }
-    const parts = query.split('&');
-    const { length } = parts;
-    const parameters = {};
-    for (let index = 0; index < length; index += 1) {
-        const decoded = parts[index].split('=').map(tryDecode);
-        const key = decoded[0].replace(EXPRESSION_ARRAY_SUFFIX, '');
-        if (!ignoreKey(key)) {
-            setQueryValue(parameters, key, decoded[1]);
-        }
-    }
-    return parameters;
+	if (typeof query !== "string" || query.trim().length === 0) return {};
+	const parts = query.split("&");
+	const { length } = parts;
+	const parameters = {};
+	for (let index = 0; index < length; index += 1) {
+		const decoded = parts[index].split("=").map(tryDecode);
+		const key = decoded[0].replace(EXPRESSION_ARRAY_SUFFIX, "");
+		if (!ignoreKey(key)) setQueryValue(parameters, key, decoded[1]);
+	}
+	return parameters;
 }
 function getParts(value, fromArray, prefix) {
-    const keys = Object.keys(value);
-    const { length } = keys;
-    const parts = [];
-    for (let index = 0; index < length; index += 1) {
-        const key = keys[index];
-        const val = value[key];
-        const full = join([prefix, fromArray ? undefined : key], '.');
-        if (Array.isArray(val)) {
-            parts.push(...getParts(val, true, full));
-        }
-        else if (isPlainObject(val)) {
-            parts.push(...getParts(val, false, full));
-        }
-        else if (isDecodable(val)) {
-            parts.push(`${tryEncode(full)}=${tryEncode(val)}`);
-        }
-        else if (val instanceof Date) {
-            parts.push(`${tryEncode(full)}=${val.toJSON()}`);
-        }
-    }
-    return parts;
+	const keys = Object.keys(value);
+	const { length } = keys;
+	const parts = [];
+	for (let index = 0; index < length; index += 1) {
+		const key = keys[index];
+		const val = value[key];
+		const full = join([prefix, fromArray ? void 0 : key], ".");
+		if (Array.isArray(val)) parts.push(...getParts(val, true, full));
+		else if (isPlainObject(val)) parts.push(...getParts(val, false, full));
+		else if (isDecodable(val)) parts.push(`${tryEncode(full)}=${tryEncode(val)}`);
+		else if (val instanceof Date) parts.push(`${tryEncode(full)}=${val.toJSON()}`);
+	}
+	return parts;
 }
 function getValue$1(value) {
-    if (EXPRESSION_BOOLEAN.test(value)) {
-        return value === 'true';
-    }
-    const asNumber = getNumber(value);
-    if (!Number.isNaN(asNumber)) {
-        return asNumber;
-    }
-    const parsed = Date.parse(value);
-    if (Number.isNaN(parsed)) {
-        return value;
-    }
-    const date = new Date(parsed);
-    return date.toJSON() === value ? date : value;
+	if (EXPRESSION_BOOLEAN.test(value)) return value === "true";
+	const asNumber = getNumber(value);
+	if (!Number.isNaN(asNumber)) return asNumber;
+	const parsed = Date.parse(value);
+	if (Number.isNaN(parsed)) return value;
+	const date = new Date(parsed);
+	return date.toJSON() === value ? date : value;
 }
 function isDecodable(value) {
-    return TYPES.has(typeof value);
+	return TYPES.has(typeof value);
 }
 function setQueryValue(parameters, key, value) {
-    if (key.includes('.')) {
-        setValue(parameters, key, getValue$1(value));
-    }
-    else {
-        if (key in parameters) {
-            if (!Array.isArray(parameters[key])) {
-                parameters[key] = [parameters[key]];
-            }
-            parameters[key].push(getValue$1(value));
-        }
-        else {
-            parameters[key] = getValue$1(value);
-        }
-    }
-}
-/**
- * Convert a plain _(nested)_ object to a query string
- * @param parameters Plain object to convert
- * @returns Query string representation of the object
- */
+	if (key.includes(".")) setValue(parameters, key, getValue$1(value));
+	else if (key in parameters) {
+		if (!Array.isArray(parameters[key])) parameters[key] = [parameters[key]];
+		parameters[key].push(getValue$1(value));
+	} else parameters[key] = getValue$1(value);
+}
 function toQuery(parameters) {
-    return isPlainObject(parameters)
-        ? join(getParts(parameters, false).filter(part => part.length > 0), '&')
-        : '';
+	return isPlainObject(parameters) ? join(getParts(parameters, false).filter((part) => part.length > 0), "&") : "";
 }
-//
 const EXPRESSION_ARRAY_SUFFIX = /\[\]$/;
 const EXPRESSION_BOOLEAN = /^(false|true)$/;
-const TYPES = new Set(['boolean', 'number', 'string']);
-
-/**
- * Get a random boolean
- * @return Random boolean
- */
+const TYPES = new Set([
+	"boolean",
+	"number",
+	"string"
+]);
 function getRandomBoolean() {
-    return Math.random() > BOOLEAN_MODIFIER;
-}
-/**
- * Get a random string of characters with a specified length
- * @param length Length of random string
- * @param selection String of characters to select from _(defaults to lowercase English alphabet)_
- * @returns Random string of characters
- */
+	return Math.random() > BOOLEAN_MODIFIER;
+}
 function getRandomCharacters(length, selection) {
-    if (typeof length !== 'number' || length <= 0) {
-        return '';
-    }
-    const actual = typeof selection === 'string' && selection.length > 0
-        ? selection
-        : ALPHABET;
-    let result = '';
-    for (let index = 0; index < length; index += 1) {
-        result += actual.charAt(getRandomInteger(0, actual.length - 1));
-    }
-    return result;
-}
-/**
- * Get a random hexadecimal color
- * @param prefix Prefix the color with `#`? _(defaults to `false`)_
- * @returns Random hexadecimal color string in the format `(#)RRGGBB`
- */
+	if (typeof length !== "number" || length <= 0) return "";
+	const actual = typeof selection === "string" && selection.length > 0 ? selection : ALPHABET;
+	let result = "";
+	for (let index = 0; index < length; index += 1) result += actual.charAt(getRandomInteger(0, actual.length - 1));
+	return result;
+}
 function getRandomColor(prefix) {
-    return `${prefix === true ? '#' : ''}${join(Array.from({ length: 6 }, getRandomHex))}`;
+	return `${prefix === true ? "#" : ""}${join(Array.from({ length: 6 }, getRandomHex))}`;
 }
-/**
- * Get a random hexadecimal character
- * @returns Random hexadecimal character from `0-9` and `A-F`
- */
 function getRandomHex() {
-    return HEX_CHARACTERS[getRandomInteger(0, HEX_MAXIMUM)];
+	return HEX_CHARACTERS[getRandomInteger(0, HEX_MAXIMUM)];
 }
-/**
- * Get a random item from an array
- * @param array Array to get a random item from
- * @returns Random item from the array, or `undefined` if unable to retrieve one
- */
 function getRandomItem(array) {
-    if (!Array.isArray(array) || array.length === 0) {
-        return;
-    }
-    return array.length === 1
-        ? array[0]
-        : array[getRandomInteger(0, array.length - 1)];
+	if (!Array.isArray(array) || array.length === 0) return;
+	return array.length === 1 ? array[0] : array[getRandomInteger(0, array.length - 1)];
 }
 function getRandomItems(array, amount) {
-    if (!Array.isArray(array) || array.length === 0 || amount === 0) {
-        return [];
-    }
-    if (array.length < 2) {
-        return array;
-    }
-    if (amount === 1) {
-        return [array[getRandomInteger(0, array.length - 1)]];
-    }
-    return typeof amount !== 'number' || amount <= 0 || amount >= array.length
-        ? shuffle(array)
-        : shuffle(array).slice(0, amount);
-}
-//
-const ALPHABET = 'abcdefghijklmnopqrstuvwxyz';
-const BOOLEAN_MODIFIER = 0.5;
-const HEX_CHARACTERS = '0123456789ABCDEF';
+	if (!Array.isArray(array) || array.length === 0 || amount === 0) return [];
+	if (array.length < 2) return array;
+	if (amount === 1) return [array[getRandomInteger(0, array.length - 1)]];
+	return typeof amount !== "number" || amount <= 0 || amount >= array.length ? shuffle(array) : shuffle(array).slice(0, amount);
+}
+const ALPHABET = "abcdefghijklmnopqrstuvwxyz";
+const BOOLEAN_MODIFIER = .5;
+const HEX_CHARACTERS = "0123456789ABCDEF";
 const HEX_MAXIMUM = 15;
-
-/**
- * Convert a string to camel case _(thisIsCamelCase)_
- * @param value String to convert to camel case
- * @returns Camel-cased string
- */
 function camelCase(value) {
-    return toCase(value, '', true, false);
+	return toCase(value, "", true, false);
 }
-/**
- * Capitalize the first letter of a string _(and lowercase the rest)_
- * @param value String to capitalize
- * @returns Capitalized string
- */
 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()}`;
-}
-/**
- * Convert a string to kebab case _(this-is-kebab-case)_
- * @param value String to convert to kebab case
- * @returns Kebab-cased string
- */
+	if (typeof value !== "string" || value.length === 0) return "";
+	return value.length === 1 ? value.toLocaleUpperCase() : `${value.charAt(0).toLocaleUpperCase()}${value.slice(1).toLocaleLowerCase()}`;
+}
 function kebabCase(value) {
-    return toCase(value, '-', false, false);
+	return toCase(value, "-", false, false);
 }
-/**
- * Convert a string to pascal case _(ThisIsPascalCase)_
- * @param value String to convert to pascal case
- * @returns Pascal-cased string
- */
 function pascalCase(value) {
-    return toCase(value, '', true, true);
+	return toCase(value, "", true, true);
 }
-/**
- * Convert a string to snake case _(this_is_snake_case)_
- * @param value String to convert to snake case
- * @returns Snake-cased string
- */
 function snakeCase(value) {
-    return toCase(value, '_', false, false);
+	return toCase(value, "_", false, false);
 }
-/**
- * Convert a string to title case _(Capitalizing Every Word)_
- * @param value String to convert to title case
- * @returns Title-cased string
- */
 function titleCase(value) {
-    if (typeof value !== 'string') {
-        return '';
-    }
-    return value.length < 1
-        ? capitalize(value)
-        : join(words(value).map(capitalize), ' ');
+	if (typeof value !== "string") return "";
+	return value.length < 1 ? capitalize(value) : join(words(value).map(capitalize), " ");
 }
 function toCase(value, delimiter, capitalizeAny, capitalizeFirst) {
-    if (typeof value !== 'string') {
-        return '';
-    }
-    if (value.length < 1) {
-        return value;
-    }
-    const parts = words(value);
-    const partsLength = parts.length;
-    const result = [];
-    for (let partIndex = 0; partIndex < partsLength; partIndex += 1) {
-        const part = parts[partIndex];
-        const acronymParts = part.replace(EXPRESSION_ACRONYM, (full, one, two, three) => three === 's' ? full : `${one}-${two}${three}`);
-        const camelCaseParts = acronymParts.replace(EXPRESSION_CAMEL_CASE, '$1-$2');
-        const items = camelCaseParts.split('-');
-        const itemsLength = items.length;
-        const partResult = [];
-        let itemCount = 0;
-        for (let itemIndex = 0; itemIndex < itemsLength; itemIndex += 1) {
-            const item = items[itemIndex];
-            if (item.length === 0) {
-                continue;
-            }
-            if (!capitalizeAny ||
-                (itemCount === 0 && partIndex === 0 && !capitalizeFirst)) {
-                partResult.push(item.toLocaleLowerCase());
-            }
-            else {
-                partResult.push(capitalize(item));
-            }
-            itemCount += 1;
-        }
-        result.push(join(partResult, delimiter));
-    }
-    return join(result, delimiter);
-}
-//
+	if (typeof value !== "string") return "";
+	if (value.length < 1) return value;
+	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 itemsLength = items.length;
+		const partResult = [];
+		let itemCount = 0;
+		for (let itemIndex = 0; itemIndex < itemsLength; itemIndex += 1) {
+			const item = items[itemIndex];
+			if (item.length === 0) continue;
+			if (!capitalizeAny || itemCount === 0 && partIndex === 0 && !capitalizeFirst) partResult.push(item.toLocaleLowerCase());
+			else partResult.push(capitalize(item));
+			itemCount += 1;
+		}
+		result.push(join(partResult, delimiter));
+	}
+	return join(result, delimiter);
+}
 const EXPRESSION_CAMEL_CASE = /(\p{Ll})(\p{Lu})/gu;
 const EXPRESSION_ACRONYM = /(\p{Lu}*)(\p{Lu})(\p{Ll}+)/gu;
-
-/**
- * Create a new UUID-string
- * @returns UUID string
- */
 function createUuid() {
-    return TEMPLATE_UUID.replace(EXPRESSION_UUID_PART, (substring) => {
-        const digit = Number.parseInt(substring, 10);
-        const random = crypto.getRandomValues(new Uint8Array(1))[0];
-        return (digit ^ (random & (15 >> (digit / 4)))).toString(16);
-    });
-}
-/**
- * Parse a JSON string into its proper value _(or `undefined` if it fails)_
- * @param value JSON string to parse
- * @param reviver Reviver function to transform the parsed values
- * @returns Parsed value or `undefined` if parsing fails
- */
+	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);
+	});
+}
 function parse(value, reviver) {
-    try {
-        return JSON.parse(value, reviver);
-    }
-    catch {
-        return undefined;
-    }
-}
-/**
- * Truncate a string to a specified length, when possible
- * @param value String to truncate
- * @param length Maximum length of the string after truncation
- * @param suffix Suffix to append to the truncated string
- * @returns Truncated string
- */
+	try {
+		return JSON.parse(value, reviver);
+	} catch {
+		return;
+	}
+}
 function truncate(value, length, suffix) {
-    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;
-    return `${value.slice(0, truncatedLength)}${actualSuffix}`;
-}
-//
+	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;
+	return `${value.slice(0, truncatedLength)}${actualSuffix}`;
+}
 const EXPRESSION_UUID_PART = /[018]/g;
-const TEMPLATE_UUID = '10000000-1000-4000-8000-100000000000';
-
+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;
-    const paths = getPaths(path, shouldIgnoreCase);
-    if (typeof paths === 'string') {
-        return handleValue(data, paths, null, true, shouldIgnoreCase);
-    }
-    const { length } = paths;
-    let index = 0;
-    let value = data;
-    while (index < length && value != null) {
-        value = handleValue(value, paths[index++], null, true, shouldIgnoreCase);
-    }
-    return value;
-}
-
-/**
- * Render a string from a template with variables
- * @param value Template string
- * @param variables Variables to use
- * @param options Templating options
- * @returns Templated string
- */
+	if (typeof data !== "object" || data === null || typeof path !== "string" || path.trim().length === 0) return;
+	const shouldIgnoreCase = ignoreCase === true;
+	const paths = getPaths(path, shouldIgnoreCase);
+	if (typeof paths === "string") return handleValue(data, paths, null, true, shouldIgnoreCase);
+	const { length } = paths;
+	let index = 0;
+	let value = data;
+	while (index < length && value != null) value = handleValue(value, paths[index++], null, true, shouldIgnoreCase);
+	return value;
+}
 function template(value, variables, options) {
-    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 value = getValue(variables, key, ignoreCase);
-        const nullish = value == null;
-        values[key] = nullish ? '' : getString(value);
-        return values[key];
-    });
-}
-//
+	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 value$1 = getValue(variables, key, ignoreCase);
+		values[key] = value$1 == null ? "" : getString(value$1);
+		return values[key];
+	});
+}
 const EXPRESSION_VARIABLE = /{{([\s\S]+?)}}/g;
-
 function equal(first, second, options) {
-    return equalValue(first, second, getOptions$1(options));
+	return equalValue(first, second, getOptions$1(options));
 }
-// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: Extracting to smaller functions had unintended results for return-early statements, so leaving as-is for now
 function equalArray(first, second, options) {
-    const { length } = first;
-    if (length !== second.length) {
-        return false;
-    }
-    let offset = 0;
-    if (length >= ARRAY_THRESHOLD) {
-        offset = Math.round(length / ARRAY_PEEK_PERCENTAGE);
-        offset = offset > ARRAY_THRESHOLD ? ARRAY_THRESHOLD : offset;
-        for (let index = 0; index < offset; index += 1) {
-            if (!(equalValue(first[index], second[index], options) &&
-                equalValue(first[length - index - 1], second[length - index - 1], options))) {
-                return false;
-            }
-        }
-    }
-    const firstChunks = chunk(first.slice(offset, length - offset), ARRAY_THRESHOLD);
-    const secondChunks = chunk(second.slice(offset, length - offset), ARRAY_THRESHOLD);
-    const chunksLength = firstChunks.length;
-    for (let chunkIndex = 0; chunkIndex < chunksLength; chunkIndex += 1) {
-        const firstChunk = firstChunks[chunkIndex];
-        const secondChunk = secondChunks[chunkIndex];
-        const chunkLength = firstChunk.length;
-        for (let index = 0; index < chunkLength; index += 1) {
-            if (!equalValue(firstChunk[index], secondChunk[index], options)) {
-                return false;
-            }
-        }
-    }
-    return true;
+	const { length } = first;
+	if (length !== second.length) return false;
+	let offset = 0;
+	if (length >= ARRAY_THRESHOLD) {
+		offset = Math.round(length / ARRAY_PEEK_PERCENTAGE);
+		offset = offset > ARRAY_THRESHOLD ? ARRAY_THRESHOLD : offset;
+		for (let index = 0; index < offset; index += 1) if (!(equalValue(first[index], second[index], options) && equalValue(first[length - index - 1], second[length - index - 1], options))) return false;
+	}
+	const firstChunks = chunk(first.slice(offset, length - offset), ARRAY_THRESHOLD);
+	const secondChunks = chunk(second.slice(offset, length - offset), ARRAY_THRESHOLD);
+	const chunksLength = firstChunks.length;
+	for (let chunkIndex = 0; chunkIndex < chunksLength; chunkIndex += 1) {
+		const firstChunk = firstChunks[chunkIndex];
+		const secondChunk = secondChunks[chunkIndex];
+		const chunkLength = firstChunk.length;
+		for (let index = 0; index < chunkLength; index += 1) if (!equalValue(firstChunk[index], secondChunk[index], options)) return false;
+	}
+	return true;
 }
 function equalArrayBuffer(first, second, options) {
-    return first.byteLength === second.byteLength
-        ? equalArray(new Uint8Array(first), new Uint8Array(second), options)
-        : false;
+	return first.byteLength === second.byteLength ? equalArray(new Uint8Array(first), new Uint8Array(second), options) : false;
 }
 function equalDataView(first, second, options) {
-    return first.byteOffset === second.byteOffset
-        ? equalArrayBuffer(first.buffer, second.buffer, options)
-        : false;
+	return first.byteOffset === second.byteOffset ? equalArrayBuffer(first.buffer, second.buffer, options) : false;
 }
 function equalMap(first, second, options) {
-    const { size } = first;
-    if (size !== second.size) {
-        return false;
-    }
-    const firstKeys = [...first.keys()];
-    const secondKeys = [...second.keys()];
-    if (firstKeys.some(key => !secondKeys.includes(key))) {
-        return false;
-    }
-    for (let index = 0; index < size; index += 1) {
-        const key = firstKeys[index];
-        if (!equalValue(first.get(key), second.get(key), options)) {
-            return false;
-        }
-    }
-    return true;
+	const { size } = first;
+	if (size !== second.size) return false;
+	const firstKeys = [...first.keys()];
+	const secondKeys = [...second.keys()];
+	if (firstKeys.some((key) => !secondKeys.includes(key))) return false;
+	for (let index = 0; index < size; index += 1) {
+		const key = firstKeys[index];
+		if (!equalValue(first.get(key), second.get(key), options)) return false;
+	}
+	return true;
 }
 function equalObject(first, second, options) {
-    const firstKeys = [
-        ...Object.keys(first),
-        ...Object.getOwnPropertySymbols(first),
-    ].filter(key => filterKey(key, options));
-    const secondKeys = [
-        ...Object.keys(second),
-        ...Object.getOwnPropertySymbols(second),
-    ].filter(key => filterKey(key, options));
-    const { length } = firstKeys;
-    if (length !== secondKeys.length ||
-        firstKeys.some(key => !secondKeys.includes(key))) {
-        return false;
-    }
-    for (let index = 0; index < length; index += 1) {
-        const key = firstKeys[index];
-        if (!equalValue(first[key], second[key], options)) {
-            return false;
-        }
-    }
-    return true;
+	const firstKeys = [...Object.keys(first), ...Object.getOwnPropertySymbols(first)].filter((key) => filterKey(key, options));
+	const secondKeys = [...Object.keys(second), ...Object.getOwnPropertySymbols(second)].filter((key) => filterKey(key, options));
+	const { length } = firstKeys;
+	if (length !== secondKeys.length || firstKeys.some((key) => !secondKeys.includes(key))) return false;
+	for (let index = 0; index < length; index += 1) {
+		const key = firstKeys[index];
+		if (!equalValue(first[key], second[key], options)) return false;
+	}
+	return true;
 }
 function equalProperties(first, second, properties, options) {
-    const { length } = properties;
-    for (let index = 0; index < length; index += 1) {
-        const property = properties[index];
-        if (!equalValue(first[property], second[property], options)) {
-            return false;
-        }
-    }
-    return true;
+	const { length } = properties;
+	for (let index = 0; index < length; index += 1) {
+		const property = properties[index];
+		if (!equalValue(first[property], second[property], options)) return false;
+	}
+	return true;
 }
 function equalSet(first, second, options) {
-    const { size } = first;
-    if (size !== second.size) {
-        return false;
-    }
-    const firstValues = [...first];
-    const secondValues = [...second];
-    for (let index = 0; index < size; index += 1) {
-        const firstValue = firstValues[index];
-        if (!secondValues.some(secondValue => equalValue(firstValue, secondValue, options))) {
-            return false;
-        }
-    }
-    return true;
+	const { size } = first;
+	if (size !== second.size) return false;
+	const firstValues = [...first];
+	const secondValues = [...second];
+	for (let index = 0; index < size; index += 1) {
+		const firstValue = firstValues[index];
+		if (!secondValues.some((secondValue) => equalValue(firstValue, secondValue, options))) return false;
+	}
+	return true;
 }
 function equalTypedArray(first, second) {
-    if (first.constructor !== second.constructor) {
-        return false;
-    }
-    if (first.byteLength !== second.byteLength) {
-        return false;
-    }
-    const { length } = first;
-    for (let index = 0; index < length; index += 1) {
-        if (first[index] !== second[index]) {
-            return false;
-        }
-    }
-    return true;
+	if (first.constructor !== second.constructor) return false;
+	if (first.byteLength !== second.byteLength) return false;
+	const { length } = first;
+	for (let index = 0; index < length; index += 1) if (first[index] !== second[index]) return false;
+	return true;
 }
 function equalValue(first, second, options) {
-    if (options.relaxedNullish === true && first == null && second == null) {
-        return true;
-    }
-    switch (true) {
-        case Object.is(first, second):
-            return true;
-        case first == null || second == null:
-            return first === second;
-        case typeof first !== typeof second:
-            return false;
-        case typeof first === 'string' && options.ignoreCase === true:
-            return Object.is(first.toLocaleLowerCase(), second.toLocaleLowerCase());
-        case first instanceof ArrayBuffer && second instanceof ArrayBuffer:
-            return equalArrayBuffer(first, second, options);
-        case first instanceof Date && second instanceof Date:
-            return Object.is(Number(first), Number(second));
-        case first instanceof DataView && second instanceof DataView:
-            return equalDataView(first, second, options);
-        case first instanceof Error && second instanceof Error:
-            return equalProperties(first, second, ['name', 'message'], options);
-        case first instanceof Map && second instanceof Map:
-            return equalMap(first, second, options);
-        case first instanceof RegExp && second instanceof RegExp:
-            return equalProperties(first, second, ['source', 'flags'], options);
-        case first instanceof Set && second instanceof Set:
-            return equalSet(first, second, options);
-        case Array.isArray(first) && Array.isArray(second):
-            return equalArray(first, second, options);
-        case isPlainObject(first) && isPlainObject(second):
-            return equalObject(first, second, options);
-        case isTypedArray(first) && isTypedArray(second):
-            return equalTypedArray(first, second);
-        default:
-            return Object.is(first, second);
-    }
+	if (options.relaxedNullish === true && first == null && second == null) return true;
+	switch (true) {
+		case Object.is(first, second): return true;
+		case first == null || second == null: return first === second;
+		case typeof first !== typeof second: return false;
+		case typeof first === "string" && options.ignoreCase === true: return Object.is(first.toLocaleLowerCase(), second.toLocaleLowerCase());
+		case first instanceof ArrayBuffer && second instanceof ArrayBuffer: return equalArrayBuffer(first, second, options);
+		case first instanceof Date && second instanceof Date: return Object.is(Number(first), Number(second));
+		case first instanceof DataView && second instanceof DataView: return equalDataView(first, second, options);
+		case first instanceof Error && second instanceof Error: return equalProperties(first, second, ["name", "message"], options);
+		case first instanceof Map && second instanceof Map: return equalMap(first, second, options);
+		case first instanceof RegExp && second instanceof RegExp: return equalProperties(first, second, ["source", "flags"], options);
+		case first instanceof Set && second instanceof Set: return equalSet(first, second, options);
+		case Array.isArray(first) && Array.isArray(second): return equalArray(first, second, options);
+		case isPlainObject(first) && isPlainObject(second): return equalObject(first, second, options);
+		case isTypedArray(first) && isTypedArray(second): return equalTypedArray(first, second);
+		default: return Object.is(first, second);
+	}
 }
 function filterKey(key, options) {
-    if (typeof key !== 'string') {
-        return true;
-    }
-    if (options.ignoreExpressions.enabled &&
-        options.ignoreExpressions.values.some(expression => expression.test(key))) {
-        return false;
-    }
-    if (options.ignoreKeys.enabled && options.ignoreKeys.values.has(key)) {
-        return false;
-    }
-    return true;
+	if (typeof key !== "string") return true;
+	if (options.ignoreExpressions.enabled && options.ignoreExpressions.values.some((expression) => expression.test(key))) return false;
+	if (options.ignoreKeys.enabled && options.ignoreKeys.values.has(key)) return false;
+	return true;
 }
 function getOptions$1(input) {
-    const options = {
-        ignoreCase: false,
-        ignoreExpressions: {
-            enabled: false,
-            values: [],
-        },
-        ignoreKeys: {
-            enabled: false,
-            values: new Set(),
-        },
-        relaxedNullish: false,
-    };
-    if (typeof input === 'boolean') {
-        options.ignoreCase = input;
-        return options;
-    }
-    if (!isPlainObject(input)) {
-        return options;
-    }
-    options.ignoreCase =
-        typeof input.ignoreCase === 'boolean' ? input.ignoreCase : false;
-    options.ignoreExpressions.values = (Array.isArray(input.ignoreKeys) ? input.ignoreKeys : [input.ignoreKeys]).filter(key => key instanceof RegExp);
-    options.ignoreKeys.values = new Set((Array.isArray(input.ignoreKeys)
-        ? input.ignoreKeys
-        : [input.ignoreKeys]).filter(key => typeof key === 'string'));
-    options.ignoreExpressions.enabled =
-        options.ignoreExpressions.values.length > 0;
-    options.ignoreKeys.enabled = options.ignoreKeys.values.size > 0;
-    options.relaxedNullish = input.relaxedNullish === true;
-    return options;
-}
-//
+	const options = {
+		ignoreCase: false,
+		ignoreExpressions: {
+			enabled: false,
+			values: []
+		},
+		ignoreKeys: {
+			enabled: false,
+			values: /* @__PURE__ */ new Set()
+		},
+		relaxedNullish: false
+	};
+	if (typeof input === "boolean") {
+		options.ignoreCase = input;
+		return options;
+	}
+	if (!isPlainObject(input)) return options;
+	options.ignoreCase = typeof input.ignoreCase === "boolean" ? input.ignoreCase : false;
+	options.ignoreExpressions.values = (Array.isArray(input.ignoreKeys) ? input.ignoreKeys : [input.ignoreKeys]).filter((key) => key instanceof RegExp);
+	options.ignoreKeys.values = new Set((Array.isArray(input.ignoreKeys) ? input.ignoreKeys : [input.ignoreKeys]).filter((key) => typeof key === "string"));
+	options.ignoreExpressions.enabled = options.ignoreExpressions.values.length > 0;
+	options.ignoreKeys.enabled = options.ignoreKeys.values.size > 0;
+	options.relaxedNullish = input.relaxedNullish === true;
+	return options;
+}
 const ARRAY_PEEK_PERCENTAGE = 10;
 const ARRAY_THRESHOLD = 100;
-
 function clone(value) {
-    return cloneValue(value, 0, new WeakMap());
+	return cloneValue(value, 0, /* @__PURE__ */ new WeakMap());
 }
 function cloneArrayBuffer(value, depth, references) {
-    if (typeof depth === 'number' && depth >= MAX_DEPTH$1) {
-        return value;
-    }
-    const cloned = new ArrayBuffer(value.byteLength);
-    new Uint8Array(cloned).set(new Uint8Array(value));
-    references?.set(value, cloned);
-    return cloned;
+	if (typeof depth === "number" && depth >= MAX_DEPTH$1) return value;
+	const cloned = new ArrayBuffer(value.byteLength);
+	new Uint8Array(cloned).set(new Uint8Array(value));
+	references?.set(value, cloned);
+	return cloned;
 }
 function cloneDataView(value, depth, references) {
-    if (depth >= MAX_DEPTH$1) {
-        return value;
-    }
-    const buffer = cloneArrayBuffer(value.buffer);
-    const cloned = new DataView(buffer, value.byteOffset, value.byteLength);
-    references.set(value, cloned);
-    return cloned;
+	if (depth >= MAX_DEPTH$1) return value;
+	const buffer = cloneArrayBuffer(value.buffer);
+	const cloned = new DataView(buffer, value.byteOffset, value.byteLength);
+	references.set(value, cloned);
+	return cloned;
 }
 function cloneMapOrSet(value, depth, references) {
-    if (depth >= MAX_DEPTH$1) {
-        return value;
-    }
-    const isMap = value instanceof Map;
-    const cloned = isMap ? new Map() : new Set();
-    const entries = [...value.entries()];
-    const { length } = entries;
-    for (let index = 0; index < length; index += 1) {
-        const entry = entries[index];
-        if (isMap) {
-            cloned.set(cloneValue(entry[0], depth + 1, references), cloneValue(entry[1], depth + 1, references));
-        }
-        else {
-            cloned.add(cloneValue(entry[0], depth + 1, references));
-        }
-    }
-    references.set(value, cloned);
-    return cloned;
+	if (depth >= MAX_DEPTH$1) return value;
+	const isMap = value instanceof Map;
+	const cloned = isMap ? /* @__PURE__ */ new Map() : /* @__PURE__ */ new Set();
+	const entries = [...value.entries()];
+	const { length } = entries;
+	for (let index = 0; index < length; index += 1) {
+		const entry = entries[index];
+		if (isMap) cloned.set(cloneValue(entry[0], depth + 1, references), cloneValue(entry[1], depth + 1, references));
+		else cloned.add(cloneValue(entry[0], depth + 1, references));
+	}
+	references.set(value, cloned);
+	return cloned;
 }
 function cloneNode(node, depth, references) {
-    if (depth >= MAX_DEPTH$1) {
-        return node;
-    }
-    const cloned = node.cloneNode(true);
-    references.set(node, cloned);
-    return cloned;
+	if (depth >= MAX_DEPTH$1) return node;
+	const cloned = node.cloneNode(true);
+	references.set(node, cloned);
+	return cloned;
 }
 function cloneObject(value, depth, references) {
-    if (depth >= MAX_DEPTH$1) {
-        return Array.isArray(value) ? [...value] : { ...value };
-    }
-    const cloned = (Array.isArray(value) ? [] : {});
-    const keys = [...Object.keys(value), ...Object.getOwnPropertySymbols(value)];
-    const { length } = keys;
-    for (let index = 0; index < length; index += 1) {
-        const key = keys[index];
-        cloned[key] = cloneValue(value[key], depth + 1, references);
-    }
-    references.set(value, cloned);
-    return cloned;
+	if (depth >= MAX_DEPTH$1) return Array.isArray(value) ? [...value] : { ...value };
+	const cloned = Array.isArray(value) ? [] : {};
+	const keys = [...Object.keys(value), ...Object.getOwnPropertySymbols(value)];
+	const { length } = keys;
+	for (let index = 0; index < length; index += 1) {
+		const key = keys[index];
+		cloned[key] = cloneValue(value[key], depth + 1, references);
+	}
+	references.set(value, cloned);
+	return cloned;
 }
 function cloneRegularExpression(value, depth, references) {
-    if (depth >= MAX_DEPTH$1) {
-        return value;
-    }
-    const cloned = new RegExp(value.source, value.flags);
-    cloned.lastIndex = value.lastIndex;
-    references.set(value, cloned);
-    return cloned;
+	if (depth >= MAX_DEPTH$1) return value;
+	const cloned = new RegExp(value.source, value.flags);
+	cloned.lastIndex = value.lastIndex;
+	references.set(value, cloned);
+	return cloned;
 }
 function cloneTypedArray(value, depth, references) {
-    if (depth >= MAX_DEPTH$1) {
-        return value;
-    }
-    const cloned = new value.constructor(value);
-    references.set(value, cloned);
-    return cloned;
+	if (depth >= MAX_DEPTH$1) return value;
+	const cloned = new value.constructor(value);
+	references.set(value, cloned);
+	return cloned;
 }
 function cloneValue(value, depth, references) {
-    switch (true) {
-        case value == null:
-            return value;
-        case typeof value === 'bigint':
-            return BigInt(value);
-        case typeof value === 'boolean':
-            return Boolean(value);
-        case typeof value === 'function':
-            return;
-        case typeof value === 'number':
-            return Number(value);
-        case typeof value === 'string':
-            return String(value);
-        case typeof value === 'symbol':
-            return Symbol(value.description);
-        case references.has(value):
-            return references.get(value);
-        case value instanceof ArrayBuffer:
-            return cloneArrayBuffer(value, depth, references);
-        case value instanceof DataView:
-            return cloneDataView(value, depth, references);
-        case value instanceof RegExp:
-            return cloneRegularExpression(value, depth, references);
-        case value instanceof Map:
-        case value instanceof Set:
-            return cloneMapOrSet(value, depth, references);
-        case value instanceof Node:
-            return cloneNode(value, depth, references);
-        case isArrayOrPlainObject(value):
-            return cloneObject(value, depth, references);
-        case isTypedArray(value):
-            return cloneTypedArray(value, depth, references);
-        default:
-            return tryStructuredClone(value, depth, references);
-    }
+	switch (true) {
+		case value == null: return value;
+		case typeof value === "bigint": return BigInt(value);
+		case typeof value === "boolean": return Boolean(value);
+		case typeof value === "function": return;
+		case typeof value === "number": return Number(value);
+		case typeof value === "string": return String(value);
+		case typeof value === "symbol": return Symbol(value.description);
+		case references.has(value): return references.get(value);
+		case value instanceof ArrayBuffer: return cloneArrayBuffer(value, depth, references);
+		case value instanceof DataView: return cloneDataView(value, depth, references);
+		case value instanceof RegExp: return cloneRegularExpression(value, depth, references);
+		case value instanceof Map:
+		case value instanceof Set: return cloneMapOrSet(value, depth, references);
+		case value instanceof Node: return cloneNode(value, depth, references);
+		case isArrayOrPlainObject(value): return cloneObject(value, depth, references);
+		case isTypedArray(value): return cloneTypedArray(value, depth, references);
+		default: return tryStructuredClone(value, depth, references);
+	}
 }
 function tryStructuredClone(value, depth, references) {
-    if (depth >= MAX_DEPTH$1) {
-        return value;
-    }
-    try {
-        const cloned = structuredClone(value);
-        references.set(value, cloned);
-        return cloned;
-    }
-    catch {
-        references.set(value, value);
-        return value;
-    }
-}
-//
+	if (depth >= MAX_DEPTH$1) return value;
+	try {
+		const cloned = structuredClone(value);
+		references.set(value, cloned);
+		return cloned;
+	} catch {
+		references.set(value, value);
+		return value;
+	}
+}
 const MAX_DEPTH$1 = 100;
-
-//
-/**
- * Find the differences between two values
- * @param first First value
- * @param second Second value
- * @param options Comparison options
- * @returns Difference result
- */
 function diff(first, second, options) {
-    const relaxedNullish = typeof options === 'object' && options?.relaxedNullish === true;
-    const result = {
-        original: {
-            from: first,
-            to: second,
-        },
-        type: 'partial',
-        values: {},
-    };
-    const same = (relaxedNullish && first == null && second == null) ||
-        Object.is(first, second);
-    const firstIsArrayOrObject = isArrayOrPlainObject(first);
-    const secondIsArrayOrObject = isArrayOrPlainObject(second);
-    if (same || !(firstIsArrayOrObject || secondIsArrayOrObject)) {
-        result.type = same ? 'none' : 'full';
-        return result;
-    }
-    if (firstIsArrayOrObject !== secondIsArrayOrObject) {
-        result.type = 'full';
-        return result;
-    }
-    const diffs = getDiffs(first, second, relaxedNullish);
-    const { length } = diffs;
-    if (length === 0) {
-        result.type = 'none';
-    }
-    for (let index = 0; index < length; index += 1) {
-        const diff = diffs[index];
-        result.values[diff.key] = { from: diff.from, to: diff.to };
-    }
-    return result;
+	const relaxedNullish = typeof options === "object" && options?.relaxedNullish === true;
+	const result = {
+		original: {
+			from: first,
+			to: second
+		},
+		type: "partial",
+		values: {}
+	};
+	const same = relaxedNullish && first == null && second == null || Object.is(first, second);
+	const firstIsArrayOrObject = isArrayOrPlainObject(first);
+	const secondIsArrayOrObject = isArrayOrPlainObject(second);
+	if (same || !(firstIsArrayOrObject || secondIsArrayOrObject)) {
+		result.type = same ? "none" : "full";
+		return result;
+	}
+	if (firstIsArrayOrObject !== secondIsArrayOrObject) {
+		result.type = "full";
+		return result;
+	}
+	const diffs = getDiffs(first, second, relaxedNullish);
+	const { length } = diffs;
+	if (length === 0) result.type = "none";
+	for (let index = 0; index < length; index += 1) {
+		const diff$1 = diffs[index];
+		result.values[diff$1.key] = {
+			from: diff$1.from,
+			to: diff$1.to
+		};
+	}
+	return result;
 }
 function getChanges(changes, first, second, relaxedNullish, prefix) {
-    const checked = new Set();
-    for (let outerIndex = 0; outerIndex < 2; outerIndex += 1) {
-        const value = (outerIndex === 0 ? first : second) ?? {};
-        const keys = [
-            ...Object.keys(value),
-            ...Object.getOwnPropertySymbols(value),
-        ];
-        const { length } = keys;
-        for (let innerIndex = 0; innerIndex < length; innerIndex += 1) {
-            const key = keys[innerIndex];
-            if (checked.has(key)) {
-                continue;
-            }
-            checked.add(key);
-            setChanges({
-                changes,
-                key,
-                relaxedNullish,
-                prefix,
-                values: { first, second },
-            });
-        }
-    }
-    return changes;
+	const checked = /* @__PURE__ */ new Set();
+	for (let outerIndex = 0; outerIndex < 2; outerIndex += 1) {
+		const value = (outerIndex === 0 ? first : second) ?? {};
+		const keys = [...Object.keys(value), ...Object.getOwnPropertySymbols(value)];
+		const { length } = keys;
+		for (let innerIndex = 0; innerIndex < length; innerIndex += 1) {
+			const key = keys[innerIndex];
+			if (checked.has(key)) continue;
+			checked.add(key);
+			setChanges({
+				changes,
+				key,
+				relaxedNullish,
+				prefix,
+				values: {
+					first,
+					second
+				}
+			});
+		}
+	}
+	return changes;
 }
 function getDiffs(first, second, relaxedNullish, prefix) {
-    const changes = [];
-    if (Array.isArray(first) && Array.isArray(second)) {
-        const maximumLength = Math.max(first.length, second.length);
-        const minimumLength = Math.min(first.length, second.length);
-        for (let index = minimumLength; index < maximumLength; index += 1) {
-            const key = join([prefix, index], '.');
-            changes.push({
-                key,
-                from: index >= first.length ? undefined : first[index],
-                to: index >= first.length ? second[index] : undefined,
-            });
-        }
-    }
-    return getChanges(changes, first, second, relaxedNullish, prefix);
+	const changes = [];
+	if (Array.isArray(first) && Array.isArray(second)) {
+		const maximumLength = Math.max(first.length, second.length);
+		const minimumLength = Math.min(first.length, second.length);
+		for (let index = minimumLength; index < maximumLength; index += 1) {
+			const key = join([prefix, index], ".");
+			changes.push({
+				key,
+				from: index >= first.length ? void 0 : first[index],
+				to: index >= first.length ? second[index] : void 0
+			});
+		}
+	}
+	return getChanges(changes, first, second, relaxedNullish, prefix);
 }
 function setChanges(parameters) {
-    const { changes, key, prefix, relaxedNullish, values } = parameters;
-    const from = values.first?.[key];
-    const to = values.second?.[key];
-    if (equal(from, to, { relaxedNullish })) {
-        return;
-    }
-    const prefixed = join([prefix, key], '.');
-    const change = {
-        from,
-        to,
-        key: prefixed,
-    };
-    const nested = isArrayOrPlainObject(from) || isArrayOrPlainObject(to);
-    const diffs = nested ? getDiffs(from, to, relaxedNullish, prefixed) : [];
-    if (!nested || (nested && diffs.length > 0)) {
-        changes.push(change);
-    }
-    const diffsLength = diffs.length;
-    for (let diffIndex = 0; diffIndex < diffsLength; diffIndex += 1) {
-        changes.push(diffs[diffIndex]);
-    }
-}
-
+	const { changes, key, prefix, relaxedNullish, values } = parameters;
+	const from = values.first?.[key];
+	const to = values.second?.[key];
+	if (equal(from, to, { relaxedNullish })) return;
+	const prefixed = join([prefix, key], ".");
+	const change = {
+		from,
+		to,
+		key: prefixed
+	};
+	const diffs = isArrayOrPlainObject(from) || isArrayOrPlainObject(to) ? getDiffs(from, to, relaxedNullish, prefixed) : [];
+	changes.push(change);
+	const diffsLength = diffs.length;
+	for (let diffIndex = 0; diffIndex < diffsLength; diffIndex += 1) changes.push(diffs[diffIndex]);
+}
 function getOptions(options) {
-    const actual = {
-        replaceableObjects: undefined,
-        skipNullableInArrays: false,
-    };
-    if (typeof options !== 'object' || options == null) {
-        return actual;
-    }
-    actual.replaceableObjects = getReplaceableObjects(options.replaceableObjects);
-    actual.skipNullableInArrays = options.skipNullableInArrays === true;
-    return actual;
+	const actual = {
+		replaceableObjects: void 0,
+		skipNullableInArrays: false
+	};
+	if (typeof options !== "object" || options == null) return actual;
+	actual.replaceableObjects = getReplaceableObjects(options.replaceableObjects);
+	actual.skipNullableInArrays = options.skipNullableInArrays === true;
+	return actual;
 }
 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));
-    }
-}
-/**
- * Merge multiple arrays or objects into a single one
- * @param values Values to merge
- * @param options Merging options
- * @returns Merged 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));
+	if (!Array.isArray(values) || values.length === 0) return {};
+	return mergeValues(values, getOptions(options), true);
 }
 function mergeObjects(values, options, prefix) {
-    const { length } = values;
-    const isArray = values.every(Array.isArray);
-    const result = (isArray ? [] : {});
-    for (let outerIndex = 0; outerIndex < length; outerIndex += 1) {
-        const item = values[outerIndex];
-        const keys = Object.keys(item);
-        const size = keys.length;
-        for (let innerIndex = 0; innerIndex < size; innerIndex += 1) {
-            const key = keys[innerIndex];
-            const full = join([prefix, key], '.');
-            const next = item[key];
-            const previous = result[key];
-            if (isArray && options.skipNullableInArrays && next == null) {
-                continue;
-            }
-            if (!(isArrayOrPlainObject(next) && isArrayOrPlainObject(previous)) ||
-                (options.replaceableObjects?.(full) ?? false)) {
-                result[key] = next;
-            }
-            else {
-                result[key] = mergeValues([previous, next], options, full);
-            }
-        }
-    }
-    return result;
-}
-function mergeValues(values, options, prefix) {
-    const actual = values.filter(isArrayOrPlainObject);
-    return actual.length > 1
-        ? mergeObjects(actual, options, prefix)
-        : (actual[0] ?? {});
-}
-
-/**
- * Create a new object with only the specified keys
- * @param value Original object
- * @param keys Keys to use
- * @returns Partial object with only the specified keys
- */
+	const { length } = values;
+	const isArray = values.every(Array.isArray);
+	const result = isArray ? [] : {};
+	for (let outerIndex = 0; outerIndex < length; outerIndex += 1) {
+		const item = values[outerIndex];
+		const keys = Object.keys(item);
+		const size = keys.length;
+		for (let innerIndex = 0; innerIndex < size; innerIndex += 1) {
+			const key = keys[innerIndex];
+			const full = join([prefix, key], ".");
+			const next = item[key];
+			const previous = result[key];
+			if (isArray && options.skipNullableInArrays && next == null) continue;
+			if (isArrayOrPlainObject(next) && isArrayOrPlainObject(previous) && !(options.replaceableObjects?.(full) ?? false)) result[key] = mergeValues([previous, next], options, false, full);
+			else result[key] = next;
+		}
+	}
+	return result;
+}
+function mergeValues(values, options, validate, prefix) {
+	const actual = validate ? values.filter(isArrayOrPlainObject) : values;
+	return actual.length > 1 ? mergeObjects(actual, options, prefix) : actual[0] ?? {};
+}
 function partial(value, keys) {
-    if (typeof value !== 'object' ||
-        value === null ||
-        Object.keys(value).length === 0 ||
-        !Array.isArray(keys) ||
-        keys.length === 0) {
-        return {};
-    }
-    const { length } = keys;
-    const result = {};
-    for (let index = 0; index < length; index += 1) {
-        const key = keys[index];
-        result[key] = value[key];
-    }
-    return result;
-}
-
-function flatten(value, depth, smushed, prefix) {
-    if (depth >= MAX_DEPTH) {
-        return {};
-    }
-    if (smushed.has(value)) {
-        return smushed.get(value);
-    }
-    const keys = Object.keys(value);
-    const { length } = keys;
-    const flattened = {};
-    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 },
-                ...flatten(val, depth + 1, smushed, join([prefix, key], '.')),
-            });
-        }
-        else {
-            flattened[join([prefix, key], '.')] = val;
-        }
-    }
-    smushed.set(value, flattened);
-    return flattened;
-}
-/**
- * Smush an object into a flat object that uses dot notation keys
- * @param value Object to smush
- * @returns Smushed object with dot notation keys
- */
+	if (typeof value !== "object" || value === null || Object.keys(value).length === 0 || !Array.isArray(keys) || keys.length === 0) return {};
+	const { length } = keys;
+	const result = {};
+	for (let index = 0; index < length; index += 1) {
+		const key = keys[index];
+		result[key] = value[key];
+	}
+	return result;
+}
+function flattenObject(value, depth, smushed, prefix) {
+	if (depth >= MAX_DEPTH) return {};
+	if (smushed.has(value)) return smushed.get(value);
+	const keys = Object.keys(value);
+	const { length } = keys;
+	const flattened = {};
+	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;
+	}
+	smushed.set(value, flattened);
+	return flattened;
+}
 function smush(value) {
-    return typeof value === 'object' && value !== null
-        ? flatten(value, 0, new WeakMap())
-        : {};
+	return typeof value === "object" && value !== null ? flattenObject(value, 0, /* @__PURE__ */ new WeakMap()) : {};
 }
-//
 const MAX_DEPTH = 100;
-
 function getKeys(value) {
-    const keys = Object.keys(value);
-    const { length } = keys;
-    const result = [];
-    for (let index = 0; index < length; index += 1) {
-        const key = keys[index];
-        result.push({
-            order: key.split('.').length,
-            value: key,
-        });
-    }
-    return result.sort((first, second) => first.order - second.order);
-}
-/**
- * Unsmush a smushed object _(turning dot notation keys into nested keys)_
- * @param value Object to unsmush
- * @returns Unsmushed object with nested keys
- */
+	const keys = Object.keys(value);
+	const { length } = keys;
+	const result = [];
+	for (let index = 0; index < length; index += 1) {
+		const key = keys[index];
+		result.push({
+			order: key.split(".").length,
+			value: key
+		});
+	}
+	return result.sort((first, second) => first.order - second.order);
+}
 function unsmush(value) {
-    if (typeof value !== 'object' || value === null) {
-        return {};
-    }
-    const keys = getKeys(value);
-    const { length } = keys;
-    const unsmushed = {};
-    for (let index = 0; index < length; index += 1) {
-        const key = keys[index].value;
-        const val = value[key];
-        let next = val;
-        if (isArrayOrPlainObject(val)) {
-            next = Array.isArray(val) ? [...val] : { ...val };
-        }
-        setValue(unsmushed, key, next);
-    }
-    return unsmushed;
-}
-
-export { SizedMap, SizedSet, average, between, camelCase, capitalize, chunk, clamp, clone, compact, compare, count, createUuid, debounce, diff, emitter, equal, exists, filter, find, flatten$1 as 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, isHslaColor, isKey, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject$1 as isObject, isPlainObject, isPrimitive, isRgbColor, 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 };
+	if (typeof value !== "object" || value === null) return {};
+	const keys = getKeys(value);
+	const { length } = keys;
+	const unsmushed = {};
+	for (let index = 0; index < length; index += 1) {
+		const key = keys[index].value;
+		const val = value[key];
+		let next = val;
+		if (isArrayOrPlainObject(val)) next = Array.isArray(val) ? [...val] : { ...val };
+		setValue(unsmushed, key, next);
+	}
+	return unsmushed;
+}
+export { frame_rate_default as FRAME_RATE_MS, SizedMap, SizedSet, average, between, camelCase, capitalize, chunk, clamp, clone, compact, compare, count, createUuid, debounce, diff, emitter, 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 };