@lowentry/utils 1.25.3 → 2.0.2

package/src/LeUtils.js

@@ -1,3611 +0,0 @@
-import CloneDeep from 'clone-deep';
-import {ISSET, IS_OBJECT, IS_ARRAY, STRING, INT_LAX, FLOAT_LAX, INT_LAX_ANY, FLOAT_LAX_ANY, ARRAY} from './LeTypes.js';
-
-
-/**
- * @param {LeUtils_TransactionalValue} transactionalValue
- */
-const checkTransactionalValue = (transactionalValue) =>
-{
-	if(!LeUtils.isTransactionalValueValid(transactionalValue))
-	{
-		console.error('The given value is not a valid TransactionalValue:');
-		console.error(transactionalValue);
-		throw new Error('The given value is not a valid TransactionalValue');
-	}
-};
-
-/**
- * @param {LeUtils_TransactionalValue} transactionalValue
- * @param {string} changeId
- * @returns {{index:number, value:*}|null}
- */
-const findTransactionalValueChange = (transactionalValue, changeId) =>
-{
-	for(let i = 0; i < transactionalValue.changes.length; i++)
-	{
-		const change = transactionalValue.changes[i];
-		if(change.id === changeId)
-		{
-			return {index:i, value:change.value};
-		}
-	}
-	return null;
-};
-
-
-export const LeUtils = {
-	/**
-	 * A deep equals implementation.
-	 *
-	 * @param {*} a The value to compare.
-	 * @param {*} b The other value to compare.
-	 * @returns {boolean} Returns true if the values are equivalent.
-	 */
-	equals:
-		(a, b) =>
-		{
-			if(a === b)
-			{
-				return true;
-			}
-			
-			if(a && b && typeof a == 'object' && typeof b == 'object')
-			{
-				if(a.constructor !== b.constructor)
-				{
-					return false;
-				}
-				
-				if(Array.isArray(a))
-				{
-					const length = a.length;
-					if(length != b.length)
-					{
-						return false;
-					}
-					for(let i = length; i-- !== 0;)
-					{
-						if(!LeUtils.equals(a[i], b[i]))
-						{
-							return false;
-						}
-					}
-					return true;
-				}
-				if((a instanceof Map) && (b instanceof Map))
-				{
-					if(a.size !== b.size)
-					{
-						return false;
-					}
-					for(let i of a.entries())
-					{
-						if(!b.has(i[0]))
-						{
-							return false;
-						}
-					}
-					for(let i of a.entries())
-					{
-						if(!LeUtils.equals(i[1], b.get(i[0])))
-						{
-							return false;
-						}
-					}
-					return true;
-				}
-				if((a instanceof Set) && (b instanceof Set))
-				{
-					if(a.size !== b.size)
-					{
-						return false;
-					}
-					for(let i of a.entries())
-					{
-						if(!b.has(i[0]))
-						{
-							return false;
-						}
-					}
-					return true;
-				}
-				if(ArrayBuffer.isView(a) && ArrayBuffer.isView(b))
-				{
-					if(('length' in a) && ('length' in b) && (typeof a.length === 'number') && (typeof b.length === 'number'))
-					{
-						if(a.length != b.length)
-						{
-							return false;
-						}
-						for(let i = a.length; i-- !== 0;)
-						{
-							if(a[i] !== b[i])
-							{
-								return false;
-							}
-						}
-						return true;
-					}
-					if(('byteLength' in a) && ('byteLength' in b) && (typeof a.byteLength === 'number') && (typeof b.byteLength === 'number') && ('getUint8' in a) && ('getUint8' in b) && (typeof a.getUint8 === 'function') && (typeof b.getUint8 === 'function'))
-					{
-						if(a.byteLength !== b.byteLength)
-						{
-							return false;
-						}
-						for(let i = a.byteLength; i-- !== 0;)
-						{
-							if(a.getUint8(i) !== b.getUint8(i))
-							{
-								return false;
-							}
-						}
-						return true;
-					}
-					return false;
-				}
-				
-				if(a.constructor === RegExp)
-				{
-					return a.source === b.source && a.flags === b.flags;
-				}
-				if(a.valueOf !== Object.prototype.valueOf)
-				{
-					return a.valueOf() === b.valueOf();
-				}
-				if(a.toString !== Object.prototype.toString)
-				{
-					return a.toString() === b.toString();
-				}
-				
-				if(a.constructor && (a.constructor !== Object) && (a.constructor !== Array) && (Object.getPrototypeOf(a) !== Object.prototype))
-				{
-					if(typeof a.equals === 'function')
-					{
-						return a.equals(b);
-					}
-					return false;
-				}
-				
-				const keys = Object.keys(a);
-				const length = keys.length;
-				if(length !== Object.keys(b).length)
-				{
-					return false;
-				}
-				for(let i = length; i-- !== 0;)
-				{
-					if(!Object.prototype.hasOwnProperty.call(b, keys[i]))
-					{
-						return false;
-					}
-				}
-				for(let i = length; i-- !== 0;)
-				{
-					const key = keys[i];
-					if((key === '_owner') && a.$$typeof)
-					{
-						// React-specific: avoid traversing _owner, it contains circular references, and is not needed when comparing the actual element
-						continue;
-					}
-					if(!LeUtils.equals(a[key], b[key]))
-					{
-						return false;
-					}
-				}
-				return true;
-			}
-			
-			// true if both are NaN, false otherwise
-			return ((a !== a) && (b !== b));
-		},
-	
-	/**
-	 * Performs a deep equality comparison between two collections (objects, maps, arrays, etc), sorting on the keys before comparing them.
-	 *
-	 * This is useful for comparing objects that have the same properties, but in a different order, and/or in a different collection type (like Maps vs Objects).
-	 *
-	 * @param {*} elementsA The elements to compare.
-	 * @param {*} elementsB The other elements to compare.
-	 * @param {string[]} [ignoreKeys=[]] An array of keys to ignore when comparing the elements. This is useful for ignoring properties that are not relevant for the comparison.
-	 * @return {boolean} Returns true if the given values are equivalent, ignoring the order of properties.
-	 */
-	equalsMapLike:
-		(() =>
-		{
-			const sortKeyValueArrays = (pairA, pairB) => LeUtils.compare(pairA[0], pairB[0]);
-			return (elementsA, elementsB, ignoreKeys = []) =>
-			{
-				elementsA = LeUtils.mapToArray(elementsA, (value, key) => [key, value]).sort(sortKeyValueArrays);
-				elementsB = LeUtils.mapToArray(elementsB, (value, key) => [key, value]).sort(sortKeyValueArrays);
-				ignoreKeys = (typeof ignoreKeys === 'string') ? ARRAY(ignoreKeys) : LeUtils.mapToArray(ignoreKeys);
-				
-				let indexA = 0;
-				let indexB = 0;
-				while((indexA < elementsA.length) && (indexB < elementsB.length))
-				{
-					const [mapKey, mapValue] = elementsA[indexA];
-					const [ownMapKey, ownMapValue] = elementsB[indexB];
-					
-					const ignoreKeysIncludesMapKey = ignoreKeys.includes(mapKey);
-					const ignoreKeysIncludesOwnMapKey = ignoreKeys.includes(ownMapKey);
-					if(ignoreKeysIncludesMapKey)
-					{
-						indexA++;
-						if(ignoreKeysIncludesOwnMapKey)
-						{
-							indexB++;
-						}
-						continue;
-					}
-					else if(ignoreKeysIncludesOwnMapKey)
-					{
-						indexB++;
-						continue;
-					}
-					
-					if(!LeUtils.equals(mapKey, ownMapKey) || !LeUtils.equals(mapValue, ownMapValue))
-					{
-						return false;
-					}
-					indexA++;
-					indexB++;
-				}
-				
-				while((indexA < elementsA.length) && ignoreKeys.includes(elementsA[indexA][0]))
-				{
-					indexA++;
-				}
-				if(indexA < elementsA.length)
-				{
-					return false;
-				}
-				
-				while((indexB < elementsB.length) && ignoreKeys.includes(elementsB[indexB][0]))
-				{
-					indexB++;
-				}
-				return (indexB >= elementsB.length);
-			};
-		})(),
-	
-	/**
-	 * Returns a deep copy of the given value.
-	 *
-	 * @param {*} value
-	 * @returns {*}
-	 */
-	clone:
-		(value) => CloneDeep(value, true),
-	
-	/**
-	 * Executes the given callback when the document is ready.
-	 *
-	 * @param {Function} callback
-	 * @returns {{remove:Function}}
-	 */
-	onDomReady:
-		(callback) =>
-		{
-			if(!globalThis?.document || !globalThis?.document?.addEventListener || !globalThis?.document?.removeEventListener)
-			{
-				// no document, so we can't wait for it to be ready
-				console.warn('LeUtils.onDomReady() was called, but there is no document available. This might happen if the code is executed in a non-browser environment.');
-				return {
-					remove:() =>
-					       {
-					       },
-				};
-			}
-			
-			if((globalThis.document.readyState === 'interactive') || (globalThis.document.readyState === 'complete'))
-			{
-				return LeUtils.setTimeout(() => callback(), 0);
-			}
-			else
-			{
-				let listening = true;
-				const callbackWrapper = () =>
-				{
-					if(listening)
-					{
-						listening = false;
-						globalThis.document.removeEventListener('DOMContentLoaded', callbackWrapper);
-						callback();
-					}
-				};
-				
-				globalThis.document.addEventListener('DOMContentLoaded', callbackWrapper);
-				
-				return {
-					remove:
-						() =>
-						{
-							if(listening)
-							{
-								listening = false;
-								globalThis.document.removeEventListener('DOMContentLoaded', callbackWrapper);
-							}
-						},
-				};
-			}
-		},
-	
-	/**
-	 * Parses the given version string, and returns an object with the major, minor, and patch numbers, as well as some comparison functions.
-	 *
-	 * Expects a version string such as:
-	 * - "1"
-	 * - "1.2"
-	 * - "1.2.3"
-	 * - "1.2.3 anything"
-	 * - "1.2.3-anything"
-	 *
-	 * @param {string|*} versionString
-	 * @returns {{major: (number),  minor: (number),  patch: (number),  toString: (function(): string),  equals: (function(string|*): boolean),  smallerThan: (function(string|*): boolean),  smallerThanOrEquals: (function(string|*): boolean),  largerThan: (function(string|*): boolean),  largerThanOrEquals: (function(string|*): boolean)}}
-	 */
-	parseVersionString:
-		(versionString) =>
-		{
-			if(IS_OBJECT(versionString) && ISSET(versionString?.major) && ISSET(versionString?.minor) && ISSET(versionString?.patch))
-			{
-				return versionString;
-			}
-			
-			versionString = STRING(versionString).trim();
-			const partsVersion = versionString.split(' ')[0].split('-')[0].split('.');
-			const major = INT_LAX(partsVersion[0]);
-			const minor = INT_LAX(partsVersion[1]);
-			const patch = INT_LAX(partsVersion[2]);
-			
-			const THIS = {
-				major:major,
-				minor:minor,
-				patch:patch,
-				
-				toString:
-					() => major + '.' + minor + '.' + patch,
-				
-				equals:
-					(otherVersion) =>
-					{
-						otherVersion = LeUtils.parseVersionString(otherVersion);
-						return (major === otherVersion.major) && (minor === otherVersion.minor) && (patch === otherVersion.patch);
-					},
-				
-				largerThan:
-					(otherVersion) =>
-					{
-						otherVersion = LeUtils.parseVersionString(otherVersion);
-						
-						if(major > otherVersion.major)
-						{
-							return true;
-						}
-						if(major < otherVersion.major)
-						{
-							return false;
-						}
-						
-						if(minor > otherVersion.minor)
-						{
-							return true;
-						}
-						if(minor < otherVersion.minor)
-						{
-							return false;
-						}
-						
-						return (patch > otherVersion.patch);
-					},
-				
-				largerThanOrEquals:
-					(otherVersion) =>
-					{
-						otherVersion = LeUtils.parseVersionString(otherVersion);
-						
-						if(major > otherVersion.major)
-						{
-							return true;
-						}
-						if(major < otherVersion.major)
-						{
-							return false;
-						}
-						
-						if(minor > otherVersion.minor)
-						{
-							return true;
-						}
-						if(minor < otherVersion.minor)
-						{
-							return false;
-						}
-						
-						return (patch >= otherVersion.patch);
-					},
-				
-				smallerThan:
-					(otherVersion) => !THIS.largerThanOrEquals(otherVersion),
-				
-				smallerThanOrEquals:
-					(otherVersion) => !THIS.largerThan(otherVersion),
-			};
-			return THIS;
-		},
-	
-	/**
-	 * Returns true if the array or object contains the given value.
-	 *
-	 * Values are compared by casting both of them to a string.
-	 *
-	 * @param {*[]|Object|Function} array
-	 * @param {*} value
-	 * @returns {boolean}
-	 */
-	contains:
-		(array, value) =>
-		{
-			if(!array)
-			{
-				return false;
-			}
-			let result = false;
-			value = STRING(value);
-			LeUtils.each(array, (val) =>
-			{
-				if(STRING(val) === value)
-				{
-					result = true;
-					return false;
-				}
-			});
-			return result;
-		},
-	
-	/**
-	 * Returns true if the array or object contains the given value.
-	 *
-	 * Values are compared by casting both of them to a string, and then lowercasing them.
-	 *
-	 * @param {*[]|Object|Function} array
-	 * @param {*} value
-	 * @returns {boolean}
-	 */
-	containsCaseInsensitive:
-		(array, value) =>
-		{
-			if(!array)
-			{
-				return false;
-			}
-			let result = false;
-			value = STRING(value).toLowerCase();
-			LeUtils.each(array, (val) =>
-			{
-				if(STRING(val).toLowerCase() === value)
-				{
-					result = true;
-					return false;
-				}
-			});
-			return result;
-		},
-	
-	/**
-	 * Returns true if the array or object contains all the given values.
-	 *
-	 * Values are compared by casting both of them to a string.
-	 *
-	 * @param {*[]|Object|Function} array
-	 * @param {*[]|Object|Function} values
-	 * @returns {boolean}
-	 */
-	containsAll:
-		(array, values) =>
-		{
-			if(!array)
-			{
-				return false;
-			}
-			let result = true;
-			LeUtils.each(values, (value) =>
-			{
-				if(!LeUtils.contains(array, value))
-				{
-					result = false;
-					return false;
-				}
-			});
-			return result;
-		},
-	
-	/**
-	 * Returns true if the array or object contains all the given values.
-	 *
-	 * Values are compared by casting both of them to a string, and then lowercasing them.
-	 *
-	 * @param {*[]|Object|Function} array
-	 * @param {*[]|Object|Function} values
-	 * @returns {boolean}
-	 */
-	containsAllCaseInsensitive:
-		(array, values) =>
-		{
-			if(!array)
-			{
-				return false;
-			}
-			let result = true;
-			LeUtils.each(values, (value) =>
-			{
-				if(!LeUtils.containsCaseInsensitive(array, value))
-				{
-					result = false;
-					return false;
-				}
-			});
-			return result;
-		},
-	
-	/**
-	 * Returns true if the array or object contains any of the given values.
-	 *
-	 * Values are compared by casting both of them to a string.
-	 *
-	 * @param {*[]|Object|Function} array
-	 * @param {*[]|Object|Function} values
-	 * @returns {boolean}
-	 */
-	containsAny:
-		(array, values) =>
-		{
-			if(!array)
-			{
-				return false;
-			}
-			let result = false;
-			LeUtils.each(values, (value) =>
-			{
-				if(LeUtils.contains(array, value))
-				{
-					result = true;
-					return false;
-				}
-			});
-			return result;
-		},
-	
-	/**
-	 * Returns true if the array or object contains any of the given values.
-	 *
-	 * Values are compared by casting both of them to a string, and then lowercasing them.
-	 *
-	 * @param {*[]|Object|Function} array
-	 * @param {*[]|Object|Function} values
-	 * @returns {boolean}
-	 */
-	containsAnyCaseInsensitive:
-		(array, values) =>
-		{
-			if(!array)
-			{
-				return false;
-			}
-			let result = false;
-			LeUtils.each(values, (value) =>
-			{
-				if(LeUtils.containsCaseInsensitive(array, value))
-				{
-					result = true;
-					return false;
-				}
-			});
-			return result;
-		},
-	
-	/**
-	 * Returns true if the array or object contains none of the given values.
-	 *
-	 * Values are compared by casting both of them to a string.
-	 *
-	 * @param {*[]|Object|Function} array
-	 * @param {*[]|Object|Function} values
-	 * @returns {boolean}
-	 */
-	containsNone:
-		(array, values) =>
-		{
-			if(!array)
-			{
-				return true;
-			}
-			let result = true;
-			LeUtils.each(values, (value) =>
-			{
-				if(LeUtils.contains(array, value))
-				{
-					result = false;
-					return false;
-				}
-			});
-			return result;
-		},
-	
-	/**
-	 * Returns true if the array or object contains none of the given values.
-	 *
-	 * Values are compared by casting both of them to a string, and then lowercasing them.
-	 *
-	 * @param {*[]|Object|Function} array
-	 * @param {*[]|Object|Function} values
-	 * @returns {boolean}
-	 */
-	containsNoneCaseInsensitive:
-		(array, values) =>
-		{
-			if(!array)
-			{
-				return true;
-			}
-			let result = true;
-			LeUtils.each(values, (value) =>
-			{
-				if(LeUtils.containsCaseInsensitive(array, value))
-				{
-					result = false;
-					return false;
-				}
-			});
-			return result;
-		},
-	
-	/**
-	 * Finds the first element in the given array or object that returns true from the callback, and returns an object with the index and value.
-	 *
-	 * @param {*[]|Object|Function} elements
-	 * @param {(value:*, index:*) => boolean|void} callback
-	 * @param {boolean} [optionalSkipHasOwnPropertyCheck]
-	 * @returns {{index:*, value:*}|null}
-	 */
-	findIndexValue:
-		(elements, callback, optionalSkipHasOwnPropertyCheck = false) =>
-		{
-			let result = null;
-			LeUtils.each(elements, (value, index) =>
-			{
-				if(callback.call(elements[index], elements[index], index))
-				{
-					result = {index, value};
-					return false;
-				}
-			}, optionalSkipHasOwnPropertyCheck);
-			return result;
-		},
-	
-	/**
-	 * Finds the first element in the given array or object that returns true from the callback, and returns the index.
-	 *
-	 * @param {*[]|Object|Function} elements
-	 * @param {(value:*, index:*) => boolean|void} callback
-	 * @param {boolean} [optionalSkipHasOwnPropertyCheck]
-	 * @returns {*|null}
-	 */
-	findIndex:
-		(elements, callback, optionalSkipHasOwnPropertyCheck = false) => LeUtils.findIndexValue(elements, callback, optionalSkipHasOwnPropertyCheck)?.index ?? null,
-	
-	/**
-	 * Finds the first element in the given array or object that returns true from the callback, and returns the value.
-	 *
-	 * @param {*[]|Object|Function} elements
-	 * @param {(value:*, index:*) => boolean|void} callback
-	 * @param {boolean} [optionalSkipHasOwnPropertyCheck]
-	 * @returns {*|null}
-	 */
-	find:
-		(elements, callback, optionalSkipHasOwnPropertyCheck = false) => LeUtils.findIndexValue(elements, callback, optionalSkipHasOwnPropertyCheck)?.value ?? null,
-	
-	/**
-	 * Returns the value at the given index in the given elements.
-	 *
-	 * @param {*} elements
-	 * @param {*} index
-	 * @param {boolean} [optionalSkipHasOwnPropertyCheck]
-	 * @returns {*}
-	 */
-	getValueAtIndex:
-		(elements, index, optionalSkipHasOwnPropertyCheck = false) =>
-		{
-			if((elements === null) || (typeof elements === 'undefined'))
-			{
-				return undefined;
-			}
-			if(Array.isArray(elements))
-			{
-				return elements[index];
-			}
-			if((typeof elements === 'object') && (elements?.constructor === Object))
-			{
-				if((optionalSkipHasOwnPropertyCheck === true) || Object.prototype.hasOwnProperty.call(elements, index))
-				{
-					return elements[index];
-				}
-				return undefined;
-			}
-			if(elements instanceof Map)
-			{
-				return elements.get(index);
-			}
-			if(elements instanceof Set)
-			{
-				return index;
-			}
-			if(typeof elements !== 'string')
-			{
-				if(ArrayBuffer.isView(elements) && !(elements instanceof DataView))
-				{
-					return elements[index];
-				}
-				if(typeof elements?.[Symbol.iterator] === 'function')
-				{
-					let i = 0;
-					for(const value of elements)
-					{
-						if(i === index)
-						{
-							return value;
-						}
-						i++;
-					}
-					return undefined;
-				}
-				if(typeof elements?.forEach === 'function')
-				{
-					let result = undefined;
-					let shouldContinue = true;
-					elements.forEach((value, i) =>
-					{
-						if(shouldContinue)
-						{
-							if(i === index)
-							{
-								result = value;
-								shouldContinue = false;
-							}
-						}
-					});
-					return result;
-				}
-			}
-			if((typeof elements === 'object') || (typeof elements === 'function'))
-			{
-				if((optionalSkipHasOwnPropertyCheck === true) || Object.prototype.hasOwnProperty.call(elements, index))
-				{
-					return elements[index];
-				}
-				return undefined;
-			}
-			return undefined;
-		},
-	
-	/**
-	 * Checks if the given elements can be iterated over using LeUtils.each().
-	 *
-	 * @param {*} elements
-	 * @returns {boolean}
-	 */
-	supportsEach:
-		(elements) =>
-		{
-			if((elements === null) || (typeof elements === 'undefined') || (typeof elements === 'string'))
-			{
-				return false;
-			}
-			return !!(
-				(Array.isArray(elements))
-				|| ((typeof elements === 'object') && (elements?.constructor === Object))
-				|| (typeof elements?.[Symbol.iterator] === 'function')
-				|| (typeof elements?.forEach === 'function')
-				|| ((typeof elements === 'object') || (typeof elements === 'function'))
-			);
-		},
-	
-	/**
-	 * Returns an iterator that iterates over each element in the given array or object, yielding an array with the value and the index/key.
-	 *
-	 * @param {*} elements
-	 * @param {boolean} [optionalSkipHasOwnPropertyCheck]
-	 * @yields {[key:*, value:*]}
-	 */
-	eachIterator:
-		function* (elements, optionalSkipHasOwnPropertyCheck = false)
-		{
-			if((elements === null) || (typeof elements === 'undefined'))
-			{
-				return;
-			}
-			if(Array.isArray(elements))
-			{
-				for(let i = 0; i < elements.length; i++)
-				{
-					yield [elements[i], i];
-				}
-				return;
-			}
-			if((typeof elements === 'object') && (elements?.constructor === Object))
-			{
-				for(const i in elements)
-				{
-					if((optionalSkipHasOwnPropertyCheck === true) || Object.prototype.hasOwnProperty.call(elements, i))
-					{
-						yield [elements[i], i];
-					}
-				}
-				return;
-			}
-			if(elements instanceof Map)
-			{
-				for(const [i, value] of elements)
-				{
-					yield [value, i];
-				}
-				return;
-			}
-			if(elements instanceof Set)
-			{
-				for(const value of elements)
-				{
-					yield [value, value];
-				}
-				return;
-			}
-			if(typeof elements !== 'string')
-			{
-				if(typeof elements?.[Symbol.iterator] === 'function')
-				{
-					let i = 0;
-					for(const value of elements)
-					{
-						yield [value, i];
-						i++;
-					}
-					return;
-				}
-				if(typeof elements?.forEach === 'function')
-				{
-					const buffer = [];
-					elements.forEach((value, i) =>
-					{
-						buffer.push([value, i]);
-					});
-					for(const entry of buffer)
-					{
-						yield entry;
-					}
-					return;
-				}
-			}
-			if((typeof elements === 'object') || (typeof elements === 'function'))
-			{
-				for(const i in elements)
-				{
-					if((optionalSkipHasOwnPropertyCheck === true) || Object.prototype.hasOwnProperty.call(elements, i))
-					{
-						yield [elements[i], i];
-					}
-				}
-				return;
-			}
-			console.warn('Executed LeUtils.eachIterator() on an invalid type: [' + (typeof elements) + ']', elements);
-		},
-	
-	/**
-	 * Loops through each element in the given array or object, and calls the callback for each element.
-	 *
-	 * @param {*} elements
-	 * @param {(value:*, index?:*) => boolean|void} callback
-	 * @param {boolean} [optionalSkipHasOwnPropertyCheck]
-	 * @returns {*}
-	 */
-	each:
-		(elements, callback, optionalSkipHasOwnPropertyCheck = false) =>
-		{
-			for(const [value, key] of LeUtils.eachIterator(elements, optionalSkipHasOwnPropertyCheck))
-			{
-				if(callback.call(value, value, key) === false)
-				{
-					break;
-				}
-			}
-			return elements;
-		},
-	
-	/**
-	 * Like LeUtils.each(), except that it expects an async callback.
-	 *
-	 * @param {*} elements
-	 * @param {(value:*, index?:*) => Promise<boolean|undefined>} asyncCallback
-	 * @param {number} [optionalParallelCount]
-	 * @param {boolean} [optionalSkipHasOwnPropertyCheck]
-	 * @returns {Promise<*>}
-	 */
-	eachAsync:
-		(() =>
-		{
-			/**
-			 * Instead of waiting for every promise individually, this function will queue up multiple promises at once, then wait for any of them to finish, before adding more, until it has looped through all elements.
-			 * Then, at the end, it will wait for the remaining promises to finish.
-			 */
-			const eachAsyncParallel = async (elements, asyncCallback, optionalParallelCount, optionalSkipHasOwnPropertyCheck) =>
-			{
-				const runningPromises = new Set();
-				let doBreak = false;
-				await LeUtils.eachAsync(elements, async (value, index) =>// loop through each element
-				{
-					if(doBreak)
-					{
-						return false;
-					}
-					
-					// if no spot is available, wait for one to finish
-					while(runningPromises.size >= optionalParallelCount)
-					{
-						await Promise.race(runningPromises);
-						if(doBreak)
-						{
-							return false;
-						}
-					}
-					
-					// process this element, by creating a promise, and adding it to the queue
-					const promise = (async () =>
-					{
-						if((await asyncCallback.call(value, value, index)) === false)
-						{
-							doBreak = true;
-						}
-					})();
-					runningPromises.add(promise);
-					promise.finally(() =>
-					{
-						runningPromises.delete(promise);
-					});
-				}, 1, optionalSkipHasOwnPropertyCheck);
-				await Promise.all(runningPromises);
-				return elements;
-			};
-			
-			return async (elements, asyncCallback, parallelCount = 1, optionalSkipHasOwnPropertyCheck = false) =>
-			{
-				if((elements !== null) && (typeof elements !== 'undefined'))
-				{
-					parallelCount = INT_LAX(parallelCount);
-					if(parallelCount > 1)
-					{
-						return await eachAsyncParallel(elements, asyncCallback, parallelCount, optionalSkipHasOwnPropertyCheck);
-					}
-					
-					for(const [value, key] of LeUtils.eachIterator(elements, optionalSkipHasOwnPropertyCheck))
-					{
-						if((await asyncCallback.call(value, value, key)) === false)
-						{
-							break;
-						}
-					}
-				}
-				return elements;
-			};
-		})(),
-	
-	/**
-	 * Returns an empty simplified collection (array, object, or Map), based on the given elements.
-	 *
-	 * Usage:
-	 *
-	 * ```js
-	 * const [success, collection, add] = LeUtils.getEmptySimplifiedCollection(elements);
-	 * ```
-	 *
-	 * @param {*} elements
-	 * @returns {[boolean, *[]|Object|Map, (value:*,index:*)=>void]}
-	 */
-	getEmptySimplifiedCollection:
-		(elements) =>
-		{
-			if((elements === null) || (typeof elements === 'undefined'))
-			{
-				return [false, [], (value, index) =>
-				{
-				}];
-			}
-			
-			let collection = null;
-			let add = null;
-			if(Array.isArray(elements))
-			{
-				collection = [];
-				add = (value, index) =>
-				{
-					collection.push(value);
-				};
-			}
-			else if((typeof elements === 'object') && (elements?.constructor === Object))
-			{
-				collection = {};
-				add = (value, index) =>
-				{
-					collection[index] = value;
-				};
-			}
-			else if(elements instanceof Map)
-			{
-				collection = new Map();
-				add = (value, index) =>
-				{
-					collection.set(index, value);
-				};
-			}
-			else if((typeof elements !== 'string') && ((typeof elements?.[Symbol.iterator] === 'function') || (typeof elements?.forEach === 'function')))
-			{
-				collection = [];
-				add = (value, index) =>
-				{
-					collection.push(value);
-				};
-			}
-			else if((typeof elements === 'object') || (typeof elements === 'function'))
-			{
-				collection = {};
-				add = (value, index) =>
-				{
-					collection[index] = value;
-				};
-			}
-			else
-			{
-				console.warn('Executed LeUtils.getEmptySimplifiedCollection() on an invalid type: [' + (typeof elements) + ']', elements);
-				return [false, [], (value, index) =>
-				{
-				}];
-			}
-			return [true, collection, add];
-		},
-	
-	/**
-	 * Loops through the given elements, and returns a new collection, with only the elements that returned true (or a value equals to true) from the callback.
-	 * If no callback is given, it will return all elements that are of a true value (for example, values that are: not null, not undefined, not false, not 0, not an empty string, not an empty array, not an empty object).
-	 *
-	 * @param {*} elements
-	 * @param {(value:*, index:*) => boolean|undefined} [callback]
-	 * @param {boolean} [optionalSkipHasOwnPropertyCheck]
-	 * @returns {*}
-	 */
-	filter:
-		(elements, callback, optionalSkipHasOwnPropertyCheck = false) =>
-		{
-			const [success, collection, add] = LeUtils.getEmptySimplifiedCollection(elements);
-			if(!success)
-			{
-				return elements;
-			}
-			
-			LeUtils.each(elements, (value, index) =>
-			{
-				if(!callback)
-				{
-					if(value)
-					{
-						add(value, index);
-					}
-				}
-				else if(callback.call(value, value, index))
-				{
-					add(value, index);
-				}
-			}, optionalSkipHasOwnPropertyCheck);
-			return collection;
-		},
-	
-	/**
-	 * Loops through the given elements, and returns a new collection, with the elements that were returned from the callback.
-	 *
-	 * @param {*} elements
-	 * @param {(value:*, index:*) => *} [callback]
-	 * @param {boolean} [optionalSkipHasOwnPropertyCheck]
-	 * @returns {*}
-	 */
-	map:
-		(elements, callback, optionalSkipHasOwnPropertyCheck = false) =>
-		{
-			const [success, collection, add] = LeUtils.getEmptySimplifiedCollection(elements);
-			if(!success)
-			{
-				return elements;
-			}
-			
-			LeUtils.each(elements, (value, index) =>
-			{
-				if(!callback)
-				{
-					add(value, index);
-				}
-				else
-				{
-					add(callback.call(value, value, index), index);
-				}
-			}, optionalSkipHasOwnPropertyCheck);
-			return collection;
-		},
-	
-	/**
-	 * Loops through the given elements, and returns a new array, with the elements that were returned from the callback. Always returns an array.
-	 *
-	 * @param {*} elements
-	 * @param {(value:*, index:*) => *} [callback]
-	 * @param {boolean} [optionalSkipHasOwnPropertyCheck]
-	 * @returns {*[]}
-	 */
-	mapToArray:
-		(elements, callback, optionalSkipHasOwnPropertyCheck = false) =>
-		{
-			let result = [];
-			LeUtils.each(elements, (value, index) =>
-			{
-				if(!callback)
-				{
-					result.push(value);
-				}
-				else
-				{
-					result.push(callback.call(value, value, index));
-				}
-			}, optionalSkipHasOwnPropertyCheck);
-			return result;
-		},
-	
-	/**
-	 * Loops through the given elements, and returns a new array, with the elements that were returned from the callback. The elements will be sorted by the result from the given comparator. Always returns an array.
-	 *
-	 * @param {*} elements
-	 * @param {(valueA:*, valueB:*) => number} comparator
-	 * @param {(value:*, index:*) => *} [callback]
-	 * @param {boolean} [optionalSkipHasOwnPropertyCheck]
-	 * @returns {*[]}
-	 */
-	mapToArraySorted:
-		(elements, comparator, callback, optionalSkipHasOwnPropertyCheck = false) =>
-		{
-			const keys = LeUtils.sortKeys(elements, comparator, optionalSkipHasOwnPropertyCheck);
-			let result = [];
-			for(const key of keys)
-			{
-				const value = LeUtils.getValueAtIndex(elements, key, optionalSkipHasOwnPropertyCheck);
-				if(!callback)
-				{
-					result.push(value);
-				}
-				else
-				{
-					result.push(callback.call(value, value, key));
-				}
-			}
-			return result;
-		},
-	
-	/**
-	 * Loops through the given elements, and returns a new array, with the keys from the given elements, sorted by the result from the given comparator. Always returns an array.
-	 *
-	 * @param {*} elements
-	 * @param {(valueA:*, valueB:*) => number} comparator
-	 * @param {boolean} [optionalSkipHasOwnPropertyCheck]
-	 * @returns {*[]}
-	 */
-	sortKeys:
-		(elements, comparator, optionalSkipHasOwnPropertyCheck = false) =>
-		{
-			let keys = [];
-			LeUtils.each(elements, (value, index) =>
-			{
-				keys.push(index);
-			}, optionalSkipHasOwnPropertyCheck);
-			
-			keys.sort((a, b) => comparator(LeUtils.getValueAtIndex(elements, a, optionalSkipHasOwnPropertyCheck), LeUtils.getValueAtIndex(elements, b, optionalSkipHasOwnPropertyCheck)));
-			return keys;
-		},
-	
-	/**
-	 * Turns the given value(s) into a 1 dimensional array.
-	 *
-	 * Does the same thing as Array.flat(Infinity).
-	 *
-	 * @param {*} array
-	 * @returns {*[]}
-	 */
-	flattenArray:
-		(() =>
-		{
-			const flattenArrayRecursive = (result, array) =>
-			{
-				if(!Array.isArray(array))
-				{
-					result.push(array);
-					return;
-				}
-				array.forEach((entry) =>
-				{
-					flattenArrayRecursive(result, entry);
-				});
-			};
-			
-			return (array) =>
-			{
-				if(!Array.isArray(array))
-				{
-					return [array];
-				}
-				let result = [];
-				array.forEach((entry) =>
-				{
-					flattenArrayRecursive(result, entry);
-				});
-				return result;
-			};
-		})(),
-	
-	/**
-	 * Turns the given value(s) into a 1 dimensional array.
-	 *
-	 * Compared to LeUtils.flattenArray(), this function also supports objects, Maps, Sets, and other iterable objects.
-	 *
-	 * @param {*} elements
-	 * @param {boolean} [optionalSkipHasOwnPropertyCheck]
-	 * @returns {*[]}
-	 */
-	flattenToArray:
-		(() =>
-		{
-			const flattenToArrayRecursive = (result, elements, optionalSkipHasOwnPropertyCheck) =>
-			{
-				if(!LeUtils.supportsEach(elements))
-				{
-					result.push(elements);
-					return;
-				}
-				LeUtils.each(elements, entry =>
-				{
-					flattenToArrayRecursive(result, entry, optionalSkipHasOwnPropertyCheck);
-				}, optionalSkipHasOwnPropertyCheck);
-			};
-			
-			return (elements, optionalSkipHasOwnPropertyCheck = false) =>
-			{
-				if(!LeUtils.supportsEach(elements))
-				{
-					return [elements];
-				}
-				let result = [];
-				LeUtils.each(elements, entry =>
-				{
-					flattenToArrayRecursive(result, entry, optionalSkipHasOwnPropertyCheck);
-				}, optionalSkipHasOwnPropertyCheck);
-				return result;
-			};
-		})(),
-	
-	/**
-	 * Compares two values. Primarily used for sorting.
-	 *
-	 * @param {*} a
-	 * @param {*} b
-	 * @returns {number}
-	 */
-	compare:
-		(a, b) => (a < b) ? -1 : ((a > b) ? 1 : 0),
-	
-	/**
-	 * Compares two numbers. Primarily used for sorting.
-	 *
-	 * @param {number} a
-	 * @param {number} b
-	 * @returns {number}
-	 */
-	compareNumbers:
-		(a, b) => a - b,
-	
-	/**
-	 * Compares two numeric strings. Primarily used for sorting.
-	 *
-	 * @param {string|number} a
-	 * @param {string|number} b
-	 * @returns {number}
-	 */
-	compareNumericStrings:
-		(a, b) =>
-		{
-			const aParts = STRING(a).split('.');
-			const bParts = STRING(b).split('.');
-			for(let i = 0; i < Math.min(aParts.length, bParts.length); i++)
-			{
-				a = aParts[i].trim();
-				b = bParts[i].trim();
-				if(a.length !== b.length)
-				{
-					return (a.length < b.length) ? -1 : 1;
-				}
-				if(a !== b)
-				{
-					return (a < b) ? -1 : 1;
-				}
-			}
-			if(aParts.length !== bParts.length)
-			{
-				return (aParts.length < bParts.length) ? -1 : 1;
-			}
-			return 0;
-		},
-	
-	/**
-	 * Compares two strings in a natural way, meaning that it will compare numbers in the strings as actual numbers.
-	 *
-	 * This will correctly sort numeric parts so that "file5.txt" comes before "file10.txt", as well as that "file/5/test.txt" comes before "file/10/test.txt".
-	 *
-	 * @param {string} a
-	 * @param {string} b
-	 * @returns {number}
-	 */
-	compareNaturalStrings:
-		(a, b) =>
-		{
-			const re = /(\d+|\D+)/g; // split into runs of digits or non-digits
-			const aTokens = a.match(re) ?? [];
-			const bTokens = b.match(re) ?? [];
-			
-			const len = Math.min(aTokens.length, bTokens.length);
-			for(let i = 0; i < len; i++)
-			{
-				const x = aTokens[i];
-				const y = bTokens[i];
-				if(x === y)
-				{
-					continue;
-				}
-				
-				// if both are numbers, compare as numbers
-				const nx = parseInt(x, 10);
-				const ny = parseInt(y, 10);
-				if(!isNaN(nx) && !isNaN(ny))
-				{
-					return nx - ny;
-				}
-				
-				// otherwise compare lexically
-				return x < y ? -1 : 1;
-			}
-			
-			return aTokens.length - bTokens.length;
-		},
-	
-	/**
-	 * Compares two strings generated by LeUtils.timestamp(). Primarily used for sorting.
-	 *
-	 * @param {string} a
-	 * @param {string} b
-	 * @returns {number}
-	 */
-	compareTimestampStrings:
-		(a, b) =>
-		{
-			a = LeUtils.base64ToHex(STRING(a).replaceAll('-', '+').replaceAll('_', '/'));
-			b = LeUtils.base64ToHex(STRING(b).replaceAll('-', '+').replaceAll('_', '/'));
-			return LeUtils.compare(a, b);
-		},
-	
-	/**
-	 * Returns true if the given object is empty, false otherwise.
-	 *
-	 * @param {Object} obj
-	 * @param [optionalSkipHasOwnPropertyCheck]
-	 * @returns {boolean}
-	 */
-	isEmptyObject:
-		(obj, optionalSkipHasOwnPropertyCheck = false) =>
-		{
-			for(let field in obj)
-			{
-				if((optionalSkipHasOwnPropertyCheck === true) || Object.prototype.hasOwnProperty.call(obj, field))
-				{
-					return false;
-				}
-			}
-			return true;
-		},
-	
-	/**
-	 * Returns the number of fields in the given object.
-	 *
-	 * @param {Object} obj
-	 * @param [optionalSkipHasOwnPropertyCheck]
-	 * @returns {number}
-	 */
-	getObjectFieldsCount:
-		(obj, optionalSkipHasOwnPropertyCheck = false) =>
-		{
-			let count = 0;
-			for(let field in obj)
-			{
-				if((optionalSkipHasOwnPropertyCheck === true) || Object.prototype.hasOwnProperty.call(obj, field))
-				{
-					count++;
-				}
-			}
-			return count;
-		},
-	
-	/**
-	 * Returns true if the given function is a generator function (like: "function* (){}"), returns false otherwise.
-	 *
-	 * @param {Function} func
-	 * @returns {boolean}
-	 */
-	isGeneratorFunction:
-		(() =>
-		{
-			const GeneratorFunction = function* ()
-			{
-			}.constructor;
-			
-			const AsyncGeneratorFunction = async function* ()
-			{
-			}.constructor;
-			
-			const RegularFunction = function()
-			{
-			}.constructor;
-			
-			const PossibleGeneratorFunctionNames = Array.from(new Set(['GeneratorFunction', 'AsyncFunction', 'AsyncGeneratorFunction', GeneratorFunction.name, AsyncGeneratorFunction.name])).filter((element) =>
-			{
-				return (element && (element !== RegularFunction.name));
-			});
-			
-			return (func) =>
-			{
-				if(!func)
-				{
-					return false;
-				}
-				const constructor = func.constructor;
-				if(!constructor)
-				{
-					return false;
-				}
-				// noinspection JSUnresolvedVariable
-				return ((constructor.name && PossibleGeneratorFunctionNames.includes(constructor.name)) || (constructor.displayName && PossibleGeneratorFunctionNames.includes(constructor.displayName)));
-			};
-		})(),
-	
-	/**
-	 * Executes the callback after the given number of milliseconds. Passes the elapsed time in seconds to the callback.
-	 *
-	 * To cancel the timeout, call remove() on the result of this function (example: "const timeoutHandler = LeUtils.setTimeout((deltaTime)=>{}, 1000); timeoutHandler.remove();")
-	 *
-	 * @param {(deltaTime:number) => *} callback
-	 * @param {number} ms
-	 * @returns {{remove:Function}}
-	 */
-	setTimeout:
-		(callback, ms) =>
-		{
-			if(!globalThis?.setTimeout || !globalThis?.clearTimeout)
-			{
-				console.warn('LeUtils.setTimeout() called in an environment without globalThis.setTimeout, returning a no-op handler.');
-				return {
-					remove:() =>
-					       {
-					       },
-				};
-			}
-			
-			ms = FLOAT_LAX(ms);
-			
-			let lastTime = globalThis?.performance?.now?.() ?? 0;
-			/** @type {number|null} */
-			let handler = globalThis.setTimeout(() =>
-			{
-				const currentTime = globalThis?.performance?.now?.() ?? 0;
-				try
-				{
-					callback((currentTime - lastTime) / 1000);
-				}
-				catch(e)
-				{
-					console.error(e);
-				}
-				lastTime = currentTime;
-			}, ms);
-			
-			return {
-				remove:
-					() =>
-					{
-						if(handler !== null)
-						{
-							globalThis.clearTimeout(handler);
-							handler = null;
-						}
-					},
-			};
-		},
-	
-	/**
-	 * Executes the callback every given number of milliseconds. Passes the time difference in seconds between the last frame and now to it.
-	 *
-	 * To remove the interval, call remove() on the result of this function (example: "const intervalHandler = LeUtils.setInterval((deltaTime)=>{}, 1000); intervalHandler.remove();")
-	 *
-	 * @param {(deltaTime:number) => *} callback
-	 * @param {number} [intervalMs]
-	 * @param {boolean} [fireImmediately]
-	 * @returns {{remove:Function}}
-	 */
-	setInterval:
-		(callback, intervalMs = 1000, fireImmediately = false) =>
-		{
-			intervalMs = FLOAT_LAX_ANY(intervalMs, 1000);
-			
-			if(fireImmediately)
-			{
-				try
-				{
-					callback(0);
-				}
-				catch(e)
-				{
-					console.error(e);
-				}
-			}
-			
-			if(!globalThis?.setInterval || !globalThis?.clearInterval)
-			{
-				console.warn('LeUtils.setInterval() called in an environment without globalThis.setInterval, returning a no-op handler.');
-				return {
-					remove:() =>
-					       {
-					       },
-				};
-			}
-			
-			let lastTime = globalThis?.performance?.now?.() ?? 0;
-			/** @type {number|null} */
-			let handler = globalThis.setInterval(() =>
-			{
-				const currentTime = globalThis?.performance?.now?.() ?? 0;
-				try
-				{
-					callback((currentTime - lastTime) / 1000);
-				}
-				catch(e)
-				{
-					console.error(e);
-				}
-				lastTime = currentTime;
-			}, intervalMs);
-			
-			return {
-				remove:
-					() =>
-					{
-						if(handler !== null)
-						{
-							globalThis.clearInterval(handler);
-							handler = null;
-						}
-					},
-			};
-		},
-	
-	/**
-	 * Executes the callback after the given number of frames. Passes the elapsed time in seconds to the callback.
-	 *
-	 * To cancel the timeout, call remove() on the result of this function (example: "const timeoutHandler = LeUtils.setAnimationFrameTimeout((deltaTime){}, 5); timeoutHandler.remove();")
-	 *
-	 * @param {(deltaTime:number) => *} callback
-	 * @param {number} [frames]
-	 * @returns {{remove:Function}}
-	 */
-	setAnimationFrameTimeout:
-		(callback, frames = 1) =>
-		{
-			if(!globalThis?.requestAnimationFrame || !globalThis?.cancelAnimationFrame)
-			{
-				console.warn('LeUtils.setAnimationFrameTimeout() called in an environment without globalThis.requestAnimationFrame, returning a no-op handler.');
-				return {
-					remove:() =>
-					       {
-					       },
-				};
-			}
-			
-			frames = INT_LAX_ANY(frames, 1);
-			
-			let run = true;
-			let requestAnimationFrameId = null;
-			let lastTime = globalThis?.performance?.now?.() ?? 0;
-			const tick = () =>
-			{
-				if(run)
-				{
-					if(frames <= 0)
-					{
-						run = false;
-						requestAnimationFrameId = null;
-						const currentTime = globalThis?.performance?.now?.() ?? 0;
-						try
-						{
-							callback((currentTime - lastTime) / 1000);
-						}
-						catch(e)
-						{
-							console.error(e);
-						}
-						lastTime = currentTime;
-						return;
-					}
-					frames--;
-					requestAnimationFrameId = globalThis.requestAnimationFrame(tick);
-				}
-			};
-			tick();
-			
-			return {
-				remove:
-					() =>
-					{
-						run = false;
-						if(requestAnimationFrameId !== null)
-						{
-							globalThis.cancelAnimationFrame(requestAnimationFrameId);
-							requestAnimationFrameId = null;
-						}
-					},
-			};
-		},
-	
-	/**
-	 * Executes the callback every given number of frames. Passes the time difference in seconds between the last frame and now to it.
-	 *
-	 * To remove the interval, call remove() on the result of this function (example: "const intervalHandler = LeUtils.setAnimationFrameInterval((deltaTime)=>{}, 5); intervalHandler.remove();")
-	 *
-	 * @param {(deltaTime:number) => *} callback
-	 * @param {number} [intervalFrames]
-	 * @param {boolean} [fireImmediately]
-	 * @returns {{remove:Function}}
-	 */
-	setAnimationFrameInterval:
-		(callback, intervalFrames = 1, fireImmediately = false) =>
-		{
-			intervalFrames = INT_LAX_ANY(intervalFrames, 1);
-			
-			if(fireImmediately)
-			{
-				try
-				{
-					callback(0);
-				}
-				catch(e)
-				{
-					console.error(e);
-				}
-			}
-			
-			if(!globalThis?.requestAnimationFrame || !globalThis?.cancelAnimationFrame)
-			{
-				console.warn('LeUtils.setAnimationFrameInterval() called in an environment without globalThis.requestAnimationFrame, returning a no-op handler.');
-				return {
-					remove:() =>
-					       {
-					       },
-				};
-			}
-			
-			let run = true;
-			let requestAnimationFrameId = null;
-			let lastTimestamp = 0;
-			let totalTime = 0;
-			let frames = intervalFrames;
-			const tick = (timestamp) =>
-			{
-				if(run)
-				{
-					if(lastTimestamp === 0)
-					{
-						lastTimestamp = timestamp;
-					}
-					totalTime += (timestamp - lastTimestamp);
-					lastTimestamp = timestamp;
-					
-					frames--;
-					if(frames <= 0)
-					{
-						try
-						{
-							callback(totalTime / 1000);
-						}
-						catch(e)
-						{
-							console.error(e);
-						}
-						totalTime = 0;
-						frames = intervalFrames;
-					}
-					
-					if(run)
-					{
-						requestAnimationFrameId = globalThis.requestAnimationFrame(tick);
-					}
-				}
-			};
-			globalThis.requestAnimationFrame(tick);
-			
-			return {
-				remove:
-					() =>
-					{
-						run = false;
-						if(requestAnimationFrameId !== null)
-						{
-							globalThis.cancelAnimationFrame(requestAnimationFrameId);
-							requestAnimationFrameId = null;
-						}
-					},
-			};
-		},
-	
-	/**
-	 * Returns a promise, which will be resolved after the given number of milliseconds.
-	 *
-	 * @param {number} ms
-	 * @returns {Promise<number>}
-	 */
-	promiseTimeout:
-		(ms) =>
-		{
-			ms = FLOAT_LAX(ms);
-			if(ms <= 0)
-			{
-				return new Promise(resolve => resolve(0));
-			}
-			return new Promise(resolve => LeUtils.setTimeout(resolve, ms));
-		},
-	
-	/**
-	 * Returns a promise, which will be resolved after the given number of frames.
-	 *
-	 * @param {number} frames
-	 * @returns {Promise<number>}
-	 */
-	promiseAnimationFrameTimeout:
-		(frames) =>
-		{
-			frames = INT_LAX(frames);
-			if(frames <= 0)
-			{
-				return new Promise(resolve => resolve(0));
-			}
-			return new Promise(resolve => LeUtils.setAnimationFrameTimeout(resolve, frames));
-		},
-	
-	/**
-	 * Allows you to do a fetch, with built-in retry and abort functionality.
-	 *
-	 * @param {string} url
-	 * @param {{retries?:number|null, delay?:number|((attempt:number)=>number)|null}|Object|null} [options]
-	 * @returns {{then:Function, catch:Function, finally:Function, remove:Function, isRemoved:Function}}
-	 */
-	fetch:
-		(url, options) =>
-		{
-			let currentRetries = 0;
-			const retries = INT_LAX(options?.retries);
-			
-			let controllerAborted = false;
-			let controller = null;
-			if(globalThis?.AbortController)
-			{
-				controller = new AbortController();
-			}
-			
-			let promise = (async () =>
-			{
-				const attemptFetch = async () =>
-				{
-					if(controllerAborted || controller?.signal?.aborted)
-					{
-						throw new Error('Aborted');
-					}
-					
-					try
-					{
-						const response = await fetch(url, {
-							signal:controller?.signal,
-							...(options ?? {}),
-							retries:undefined,
-							delay:  undefined,
-						});
-						if(!response.ok)
-						{
-							throw new Error('Network request failed: ' + response.status + ' ' + response.statusText);
-						}
-						return response;
-					}
-					catch(error)
-					{
-						if(controllerAborted || controller?.signal?.aborted)
-						{
-							throw new Error('Aborted');
-						}
-						if(currentRetries >= retries)
-						{
-							throw error;
-						}
-						currentRetries++;
-						await LeUtils.promiseTimeout((typeof options?.delay === 'function') ? INT_LAX_ANY(options?.delay(currentRetries), 500) : (INT_LAX_ANY(options?.delay, 500)));
-						return await attemptFetch();
-					}
-				};
-				return await attemptFetch();
-			})();
-			
-			let result = {};
-			result.then = (...args) =>
-			{
-				promise = promise.then(...args);
-				return result;
-			};
-			result.catch = (...args) =>
-			{
-				promise = promise.catch(...args);
-				return result;
-			};
-			result.finally = (...args) =>
-			{
-				promise = promise.finally(...args);
-				return result;
-			};
-			result.remove = (...args) =>
-			{
-				controllerAborted = true;
-				if(controller)
-				{
-					controller.abort(...args);
-				}
-				return result;
-			};
-			result.isRemoved = () => (controllerAborted || !!controller?.signal?.aborted);
-			return result;
-		},
-	
-	/**
-	 * Allows you to do a fetch, with built-in retry functionality. Caches on the requested URL, so that the same URL will not be fetched multiple times.
-	 *
-	 * @param {string} url
-	 * @param {{retries?:number|null, delay?:number|((attempt:number)=>number)|null, [verify]:((data:*,response:*)=>void)|null}|null} [options]
-	 * @param {((response:*)=>*)|null} [responseFunction] A function that will be called with the response object, and should return the data to be cached.
-	 * @returns {Promise<*>}
-	 */
-	cachedFetch:
-		(() =>
-		{
-			const cache = new Map();
-			return async (url, options, responseFunction) =>
-			{
-				if(cache.has(url))
-				{
-					const result = cache.get(url);
-					if(result.data)
-					{
-						return result.data;
-					}
-					if(result.promise)
-					{
-						return await result.promise;
-					}
-					if(result.error)
-					{
-						throw result.error;
-					}
-					console.warn('Failed to use the cachedFetch cache, for URL: ', url, ', it is in an unexpected state: ', result);
-					return null;
-				}
-				
-				const promise = LeUtils.fetch(url, options)
-					.then(async response =>
-					{
-						const data = responseFunction ? (await responseFunction(response)) : response;
-						if(typeof options?.verify === 'function')
-						{
-							await options.verify(data, response);
-						}
-						return data;
-					})
-					.then(data =>
-					{
-						cache.set(url, {data});
-						return data;
-					})
-					.catch(error =>
-					{
-						cache.set(url, {error});
-						console.error('Failed to fetch: ', error);
-						throw error;
-					});
-				if(!cache.has(url))
-				{
-					cache.set(url, {promise});
-				}
-				return await promise;
-			};
-		})(),
-	
-	/**
-	 * Returns true if the user is on a smartphone device (mobile).
-	 * Will return false if the user is on a tablet or on a desktop.
-	 *
-	 * In short:
-	 * - Mobile: True
-	 * - Tablet: False
-	 * - Desktop: False
-	 *
-	 * @returns {boolean}
-	 */
-	platformIsMobile:
-		() =>
-		{
-			// noinspection JSDeprecatedSymbols, JSUnresolvedReference
-			/** navigator.userAgentData.mobile doesn't return the correct value on some platforms, so this is a work-around, code from:  http://detectmobilebrowsers.com **/
-			const a = STRING(globalThis?.navigator?.userAgent || globalThis?.navigator?.vendor || globalThis?.opera || '');
-			const b = a.substring(0, 4);
-			return !!(
-				/(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series([46])0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino/i
-					.test(a) ||
-				/1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br([ev])w|bumb|bw-([nu])|c55\/|capi|ccwa|cdm-|cell|chtm|cldc|cmd-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc-s|devi|dica|dmob|do([cp])o|ds(12|-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly([-_])|g1 u|g560|gene|gf-5|g-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd-([mpt])|hei-|hi(pt|ta)|hp( i|ip)|hs-c|ht(c([- _agpst])|tp)|hu(aw|tc)|i-(20|go|ma)|i230|iac([ \-/])|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja([tv])a|jbro|jemu|jigs|kddi|keji|kgt([ /])|klon|kpt |kwc-|kyo([ck])|le(no|xi)|lg( g|\/([klu])|50|54|-[a-w])|libw|lynx|m1-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t([- ov])|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30([02])|n50([025])|n7(0([01])|10)|ne(([cm])-|on|tf|wf|wg|wt)|nok([6i])|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan([adt])|pdxg|pg(13|-([1-8]|c))|phil|pire|pl(ay|uc)|pn-2|po(ck|rt|se)|prox|psio|pt-g|qa-a|qc(07|12|21|32|60|-[2-7]|i-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h-|oo|p-)|sdk\/|se(c([-01])|47|mc|nd|ri)|sgh-|shar|sie([-m])|sk-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h-|v-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl-|tdg-|tel([im])|tim-|t-mo|to(pl|sh)|ts(70|m-|m3|m5)|tx-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c([- ])|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas-|your|zeto|zte-/i
-					.test(b)
-			);
-		},
-	
-	/**
-	 * Returns true if the user has a cursor (mouse, touchpad, etc).
-	 * In this context, a cursor is defined as an input device that can hover over elements without necessarily interacting with them.
-	 *
-	 * @returns {boolean}
-	 */
-	platformHasCursor:
-		() =>
-		{
-			return !LeUtils.platformIsMobile() && !globalThis?.matchMedia?.('(any-hover: none)')?.matches;
-		},
-	
-	/**
-	 * Returns the given string, with the first character capitalized.
-	 *
-	 * @param {String} string
-	 * @returns {string}
-	 */
-	capitalize:
-		(string) =>
-		{
-			string = STRING(string).trim();
-			if(string.length <= 0)
-			{
-				return string;
-			}
-			return string.charAt(0).toUpperCase() + string.slice(1);
-		},
-	
-	/**
-	 * Returns true if the given string ends with any of the given characters or words.
-	 *
-	 * @param {string} string
-	 * @param {string|string[]} endingCharsStringOrArray
-	 * @returns {boolean}
-	 */
-	endsWithAny:
-		(string, endingCharsStringOrArray) =>
-		{
-			string = STRING(string);
-			let endingCharsArray;
-			if(Array.isArray(endingCharsStringOrArray))
-			{
-				endingCharsArray = endingCharsStringOrArray;
-			}
-			else
-			{
-				endingCharsArray = STRING(endingCharsStringOrArray).split('');
-			}
-			let result = false;
-			LeUtils.each(endingCharsArray, (chars) =>
-			{
-				if(string.endsWith(STRING(chars)))
-				{
-					result = true;
-					return false;
-				}
-			});
-			return result;
-		},
-	
-	/**
-	 * Returns true if the given string starts with any of the given characters or words.
-	 *
-	 * @param {string} string
-	 * @param {string|string[]} startingCharsStringOrArray
-	 * @returns {boolean}
-	 */
-	startsWithAny:
-		(string, startingCharsStringOrArray) =>
-		{
-			string = STRING(string);
-			let startingCharsArray;
-			if(Array.isArray(startingCharsStringOrArray))
-			{
-				startingCharsArray = startingCharsStringOrArray;
-			}
-			else
-			{
-				startingCharsArray = STRING(startingCharsStringOrArray).split('');
-			}
-			let result = false;
-			LeUtils.each(startingCharsArray, (chars) =>
-			{
-				if(string.startsWith(STRING(chars)))
-				{
-					result = true;
-					return false;
-				}
-			});
-			return result;
-		},
-	
-	/**
-	 * Trims the end of the given string, by removing the given characters from it.
-	 *
-	 * @param {string} string
-	 * @param {string|string[]} trimCharsStringOrArray
-	 */
-	trimEnd:
-		(string, trimCharsStringOrArray) =>
-		{
-			string = STRING(string);
-			let endingCharsArray;
-			if(Array.isArray(trimCharsStringOrArray))
-			{
-				endingCharsArray = trimCharsStringOrArray;
-			}
-			else
-			{
-				endingCharsArray = STRING(trimCharsStringOrArray).split('');
-			}
-			const trimChars = (chars) =>
-			{
-				chars = STRING(chars);
-				if(string.endsWith(chars))
-				{
-					string = string.substring(0, string.length - chars.length);
-					run = true;
-				}
-			};
-			let run = true;
-			while(run)
-			{
-				run = false;
-				LeUtils.each(endingCharsArray, trimChars);
-			}
-			return string;
-		},
-	
-	/**
-	 * Trims the start of the given string, by removing the given characters from it.
-	 *
-	 * @param {string} string
-	 * @param {string|string[]} trimCharsStringOrArray
-	 */
-	trimStart:
-		(string, trimCharsStringOrArray) =>
-		{
-			string = STRING(string);
-			let startingCharsArray;
-			if(Array.isArray(trimCharsStringOrArray))
-			{
-				startingCharsArray = trimCharsStringOrArray;
-			}
-			else
-			{
-				startingCharsArray = STRING(trimCharsStringOrArray).split('');
-			}
-			const trimChars = (chars) =>
-			{
-				chars = STRING(chars);
-				if(string.startsWith(chars))
-				{
-					string = string.substring(chars.length);
-					run = true;
-				}
-			};
-			let run = true;
-			while(run)
-			{
-				run = false;
-				LeUtils.each(startingCharsArray, trimChars);
-			}
-			return string;
-		},
-	
-	/**
-	 * Trims the start and end of the given string, by removing the given characters from it.
-	 *
-	 * @param {string} string
-	 * @param {string|string[]} trimCharsStringOrArray
-	 */
-	trim:
-		(string, trimCharsStringOrArray) => LeUtils.trimEnd(LeUtils.trimStart(string, trimCharsStringOrArray), trimCharsStringOrArray),
-	
-	/**
-	 * Returns the given string, trims the start and end, and makes sure it ends with a valid sentence ending character (such as !?;.).
-	 *
-	 * @param {string} sentence
-	 * @returns {string}
-	 */
-	purgeSentence:
-		(sentence) =>
-		{
-			sentence = LeUtils.trimEnd(STRING(sentence).trim(), '.: \r\n\t');
-			sentence += (LeUtils.endsWithAny(sentence, '!?;') ? '' : '.');
-			return sentence;
-		},
-	
-	/**
-	 * Attempts to obtain and return an error message from the given error, regardless of what is passed to this function.
-	 *
-	 * @param {*} error
-	 * @returns {string}
-	 */
-	purgeErrorMessage:
-		(error) =>
-		{
-			if(error?.message)
-			{
-				error = error.message;
-			}
-			if(typeof error === 'string')
-			{
-				const errorParts = error.split('threw an error:');
-				error = errorParts[errorParts.length - 1];
-			}
-			else
-			{
-				try
-				{
-					error = JSON.stringify(error);
-				}
-				catch(e)
-				{
-					error = 'An unknown error occurred';
-				}
-			}
-			return error.trim();
-		},
-	
-	/**
-	 * Generates all permutations of the given names.
-	 *
-	 * For example, if you pass "foo" and "bar", it will return:
-	 * - foobar
-	 * - fooBar
-	 * - FooBar
-	 * - foo-bar
-	 * - foo_bar
-	 *
-	 * @param {string[]} names
-	 * @returns {string[]}
-	 */
-	generateNamePermutations:
-		(...names) =>
-		{
-			names = LeUtils.flattenToArray(names)
-				.map(name => STRING(name).trim().toLowerCase())
-				.filter(name => (name.length > 0));
-			let results = [];
-			if(names.length > 0)
-			{
-				results.push(names.join('')); //foobar
-				results.push(names.map(LeUtils.capitalize).join('')); //FooBar
-			}
-			if(names.length > 1)
-			{
-				results.push([names[0]].concat(names.slice(1).map(LeUtils.capitalize)).join('')); //fooBar
-				results.push(names.join('-')); //foo-bar
-				results.push(names.join('_')); //foo_bar
-			}
-			return results;
-		},
-	
-	/**
-	 * Increases the given numeric string by 1, this allows you to increase a numeric string without a limit.
-	 *
-	 * @param {string} string
-	 * @returns {string}
-	 */
-	increaseNumericStringByOne:
-		(string) =>
-		{
-			if(typeof string !== 'string')
-			{
-				string = '' + string;
-				for(let i = string.length - 1; i >= 0; i--)
-				{
-					const c = string.charAt(i);
-					if((c < '0') || (c > '9'))
-					{
-						return '1';
-					}
-				}
-			}
-			if(string === '')
-			{
-				return '1';
-			}
-			for(let i = string.length - 1; i >= 0; i--)
-			{
-				let c = string.charAt(i);
-				if((c < '0') || (c > '9'))
-				{
-					return '1';
-				}
-				if(c < '9')
-				{
-					c = String.fromCharCode(c.charCodeAt(0) + 1);
-					string = string.substring(0, i) + c + string.substring(i + 1);// string[i] = (char + 1);
-					break;
-				}
-				string = string.substring(0, i) + '0' + string.substring(i + 1);// string[i] = '0';
-			}
-			if(string.charAt(0) === '0')
-			{
-				string = '1' + string;
-			}
-			return string;
-		},
-	
-	/**
-	 * Generates a base64 string (with +/ replaced by -_) that is guaranteed to be unique.
-	 *
-	 * @returns {string}
-	 */
-	uniqueId:
-		(() =>
-		{
-			let previousUniqueIdsTime = null;
-			let previousUniqueIds = new Map();
-			
-			const numberToBytes = (number) =>
-			{
-				const size = (number === 0) ? 0 : Math.ceil((Math.floor(Math.log2(number)) + 1) / 8);
-				const bytes = new Uint8ClampedArray(size);
-				let x = number;
-				for(let i = (size - 1); i >= 0; i--)
-				{
-					const rightByte = x & 0xff;
-					bytes[i] = rightByte;
-					x = Math.floor(x / 0x100);
-				}
-				return bytes;
-			};
-			
-			const generateUniqueId = () =>
-			{
-				let now;
-				try
-				{
-					// noinspection JSDeprecatedSymbols
-					now = (globalThis?.performance?.timeOrigin || globalThis?.performance?.timing?.navigationStart || 0) + (globalThis?.performance?.now?.() ?? 0);
-				}
-				catch(e)
-				{
-				}
-				now = now || (Date.now ? Date.now() : (new Date()).getTime());
-				now = Math.round(now);
-				const nowBytes = numberToBytes(now);
-				
-				let uuid = null;
-				try
-				{
-					uuid = crypto?.randomUUID();
-				}
-				catch(e)
-				{
-				}
-				
-				if(uuid)
-				{
-					uuid = LeUtils.base64ToBytes(LeUtils.hexToBase64(uuid));
-				}
-				else
-				{
-					const bytesChunkA = numberToBytes((Math.random() + ' ').substring(2, 12).padEnd(10, '0'));
-					const bytesChunkB = numberToBytes((Math.random() + ' ').substring(2, 12).padEnd(10, '0'));
-					const bytesChunkC = numberToBytes((Math.random() + ' ').substring(2, 12).padEnd(10, '0'));
-					const bytesChunkD = numberToBytes((Math.random() + ' ').substring(2, 12).padEnd(10, '0'));
-					uuid = new Uint8Array(bytesChunkA.length + bytesChunkB.length + bytesChunkC.length + bytesChunkD.length);
-					uuid.set(bytesChunkA, 0);
-					uuid.set(bytesChunkB, bytesChunkA.length);
-					uuid.set(bytesChunkC, bytesChunkA.length + bytesChunkB.length);
-					uuid.set(bytesChunkD, bytesChunkA.length + bytesChunkB.length + bytesChunkC.length);
-				}
-				
-				const bytes = new Uint8Array(nowBytes.length + uuid.length);
-				bytes.set(nowBytes, 0);
-				bytes.set(uuid, nowBytes.length);
-				uuid = LeUtils.bytesToBase64(bytes).replaceAll('=', '').replaceAll('+', '-').replaceAll('/', '_');
-				
-				return {
-					time:now,
-					id:  uuid,
-				};
-			};
-			
-			return () =>
-			{
-				while(true)
-				{
-					const result = generateUniqueId();
-					if(previousUniqueIdsTime !== result.time)
-					{
-						previousUniqueIdsTime = result.time;
-						previousUniqueIds.clear();
-						previousUniqueIds.set(result.id, true);
-						return result.id;
-					}
-					else if(previousUniqueIds.get(result.id) !== true)
-					{
-						previousUniqueIds.set(result.id, true);
-						return result.id;
-					}
-				}
-			};
-		})(),
-	
-	/**
-	 * Generates a base64 string (with +/ replaced by -_) of the current time (in milliseconds since 1970).
-	 *
-	 * @param {number} [now] Optional time to use instead of the current time. If not set, the current time will be used.
-	 * @returns {string}
-	 */
-	timestamp:
-		(() =>
-		{
-			const numberToBytes = (number) =>
-			{
-				const size = (number === 0) ? 0 : Math.ceil((Math.floor(Math.log2(number)) + 1) / 8);
-				const bytes = new Uint8ClampedArray(size);
-				let x = number;
-				for(let i = (size - 1); i >= 0; i--)
-				{
-					const rightByte = x & 0xff;
-					bytes[i] = rightByte;
-					x = Math.floor(x / 0x100);
-				}
-				return bytes;
-			};
-			
-			return (/** @type {number|null|undefined} */ now = null) =>
-			{
-				if(ISSET(now))
-				{
-					now = FLOAT_LAX(now);
-				}
-				else
-				{
-					try
-					{
-						// noinspection JSDeprecatedSymbols
-						now = (performance?.timeOrigin || performance?.timing?.navigationStart || 0) + (performance?.now?.() ?? 0);
-					}
-					catch(e)
-					{
-					}
-					now = now || (Date.now ? Date.now() : (new Date()).getTime());
-				}
-				now = Math.round(now);
-				const nowBytes = numberToBytes(now);
-				
-				return LeUtils.bytesToBase64(nowBytes).replaceAll('=', '').replaceAll('+', '-').replaceAll('/', '_');
-			};
-		})(),
-	
-	/**
-	 * Returns a data URL of a 1x1 transparent pixel.
-	 *
-	 * @returns {string}
-	 */
-	getEmptyImageSrc:
-		() =>
-		{
-			// noinspection SpellCheckingInspection
-			return 'data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==';
-		},
-	
-	/**
-	 * Calculates and returns the percentage of the part and total ((part / total) * 100).
-	 *
-	 * @param {number|string} part
-	 * @param {number|string} total
-	 * @returns {number}
-	 */
-	getPercentage:
-		(part, total) =>
-		{
-			part = FLOAT_LAX(part);
-			total = FLOAT_LAX(total);
-			if(total === 0)
-			{
-				return 100;
-			}
-			return Math.max(0, Math.min(100, ((part / total) * 100)));
-		},
-	
-	/**
-	 * Returns the pixels of the given Image object.
-	 *
-	 * @param {HTMLImageElement} image
-	 * @returns {Uint8ClampedArray}
-	 */
-	getImagePixels:
-		(image) =>
-		{
-			if(!globalThis?.document?.createElement || !globalThis?.document?.body?.appendChild)
-			{
-				console.warn('LeUtils.getImagePixels: Document is not available, returning empty pixels.');
-				return new Uint8ClampedArray();
-			}
-			const canvas = globalThis.document.createElement('canvas');
-			globalThis.document.body.appendChild(canvas);
-			try
-			{
-				const ctx = canvas.getContext('2d');
-				const width = Math.floor(image.width);
-				const height = Math.floor(image.height);
-				if(!ctx || (width <= 0) || (height <= 0))
-				{
-					return new Uint8ClampedArray();
-				}
-				canvas.width = width;
-				canvas.height = height;
-				ctx.drawImage(image, 0, 0, canvas.width, canvas.height);
-				return ctx.getImageData(0, 0, canvas.width, canvas.height).data;
-			}
-			finally
-			{
-				canvas?.parentNode?.removeChild(canvas);
-			}
-		},
-	
-	/**
-	 * Returns the data URL (mimetype "image/png") of a colored version of the given Image object.
-	 *
-	 * @param {HTMLImageElement} image
-	 * @param {string} color
-	 * @returns {string}
-	 */
-	getColoredImage:
-		(image, color) =>
-		{
-			if(!globalThis?.document?.createElement || !globalThis?.document?.body?.appendChild)
-			{
-				console.warn('LeUtils.getColoredImage: Document is not available, returning empty image src.');
-				return LeUtils.getEmptyImageSrc();
-			}
-			const canvas = globalThis.document.createElement('canvas');
-			globalThis.document.body.appendChild(canvas);
-			try
-			{
-				const ctx = canvas.getContext('2d');
-				const width = Math.floor(image.width);
-				const height = Math.floor(image.height);
-				if(!ctx || (width <= 0) || (height <= 0))
-				{
-					return LeUtils.getEmptyImageSrc();
-				}
-				canvas.width = width;
-				canvas.height = height;
-				ctx.drawImage(image, 0, 0, canvas.width, canvas.height);
-				ctx.globalCompositeOperation = 'source-in';
-				ctx.fillStyle = color;
-				ctx.fillRect(0, 0, canvas.width, canvas.height);
-				return canvas.toDataURL('image/png');
-			}
-			finally
-			{
-				canvas?.parentNode?.removeChild(canvas);
-			}
-		},
-	
-	/**
-	 * Returns the hex color of the given RGB(A).
-	 *
-	 * @param {number[]} rgb
-	 * @returns {string}
-	 */
-	rgbToHex:
-		(rgb) =>
-		{
-			return '#' + rgb.map((x) =>
-			{
-				const hex = x.toString(16);
-				return ((hex.length === 1) ? '0' + hex : hex);
-			}).join('');
-		},
-	
-	/**
-	 * Returns the RGB(A) of the given hex color.
-	 *
-	 * @param {string} hexstring
-	 * @returns {number[]}
-	 */
-	hexToRgb:
-		(hexstring) =>
-		{
-			const initialHexstring = hexstring;
-			hexstring = hexstring.replace(/[^0-9A-F]/gi, '');
-			const hasAlpha = ((hexstring.length === 4) || (hexstring.length === 8));
-			while(hexstring.length < 6)
-			{
-				hexstring = hexstring.replace(/(.)/g, '$1$1');
-			}
-			const result = hexstring.match(/\w{2}/g)?.map((a) => parseInt(a, 16));
-			if(!result || (result.length < 3))
-			{
-				throw new Error('Invalid hex color: "' + hexstring + '"  (was given "' + initialHexstring + '")');
-			}
-			return [
-				result[0],
-				result[1],
-				result[2],
-				...(hasAlpha ? [result[3]] : []),
-			];
-		},
-	
-	/**
-	 * Returns the HSL(A) of the given RGB(A).
-	 *
-	 * @param {number[]} rgb
-	 * @returns {number[]}
-	 */
-	rgbToHsl:
-		(rgb) =>
-		{
-			const r = rgb[0] / 255;
-			const g = rgb[1] / 255;
-			const b = rgb[2] / 255;
-			const max = Math.max(r, g, b);
-			const min = Math.min(r, g, b);
-			let h = 0;
-			let s = 0;
-			let l = (max + min) / 2;
-			if(max !== min)
-			{
-				const d = max - min;
-				s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
-				switch(max)
-				{
-					case r:
-						h = (g - b) / d + (g < b ? 6 : 0);
-						break;
-					case g:
-						h = (b - r) / d + 2;
-						break;
-					case b:
-						h = (r - g) / d + 4;
-						break;
-				}
-				h /= 6;
-			}
-			return [h, s, l, ...((rgb.length >= 4) ? [rgb[3] / 255] : [])];
-		},
-	
-	/**
-	 * Returns the RGB(A) of the given HSL(A).
-	 *
-	 * @param {number[]} hsl
-	 * @returns {number[]}
-	 */
-	hslToRgb:
-		(() =>
-		{
-			const hue2rgb = (p, q, t) =>
-			{
-				if(t < 0)
-				{
-					t += 1;
-				}
-				if(t > 1)
-				{
-					t -= 1;
-				}
-				if(t < 1 / 6)
-				{
-					return p + (q - p) * 6 * t;
-				}
-				if(t < 1 / 2)
-				{
-					return q;
-				}
-				if(t < 2 / 3)
-				{
-					return p + (q - p) * (2 / 3 - t) * 6;
-				}
-				return p;
-			};
-			return (hsl) =>
-			{
-				const h = hsl[0];
-				const s = hsl[1];
-				const l = hsl[2];
-				let r = 1;
-				let g = 1;
-				let b = 1;
-				if(s !== 0)
-				{
-					const q = (l < 0.5) ? (l * (1 + s)) : (l + s - (l * s));
-					const p = (2 * l) - q;
-					r = hue2rgb(p, q, h + (1 / 3));
-					g = hue2rgb(p, q, h);
-					b = hue2rgb(p, q, h - (1 / 3));
-				}
-				return [r * 255, g * 255, b * 255, ...((hsl.length >= 4) ? [hsl[3] * 255] : [])].map((c) => Math.max(0, Math.min(255, Math.round(c))));
-			};
-		})(),
-	
-	/**
-	 * Returns the LAB(A) of the given RGB(A).
-	 *
-	 * @param {number[]} rgb
-	 * @returns {number[]}
-	 */
-	rgbToLab:
-		(rgb) =>
-		{
-			let r = rgb[0] / 255;
-			let g = rgb[1] / 255;
-			let b = rgb[2] / 255;
-			r = (r > 0.04045) ? Math.pow((r + 0.055) / 1.055, 2.4) : (r / 12.92);
-			g = (g > 0.04045) ? Math.pow((g + 0.055) / 1.055, 2.4) : (g / 12.92);
-			b = (b > 0.04045) ? Math.pow((b + 0.055) / 1.055, 2.4) : (b / 12.92);
-			let x = ((r * 0.4124) + (g * 0.3576) + (b * 0.1805)) / 0.95047;
-			let y = ((r * 0.2126) + (g * 0.7152) + (b * 0.0722));
-			let z = ((r * 0.0193) + (g * 0.1192) + (b * 0.9505)) / 1.08883;
-			x = (x > 0.008856) ? Math.pow(x, 1 / 3) : (7.787 * x) + (16 / 116);
-			y = (y > 0.008856) ? Math.pow(y, 1 / 3) : (7.787 * y) + (16 / 116);
-			z = (z > 0.008856) ? Math.pow(z, 1 / 3) : (7.787 * z) + (16 / 116);
-			return [(116 * y) - 16, 500 * (x - y), 200 * (y - z), ...((rgb.length >= 4) ? [rgb[3] / 255] : [])];
-		},
-	
-	/**
-	 * Returns the difference (calculated with DeltaE) of the LAB values of the given RGB values.
-	 *
-	 * Returns a number:
-	 *
-	 * ```js
-	 *   < 1      is not perceptible by human eyes
-	 *     1-2    is perceptible through close observation
-	 *     2-10   is perceptible at a glance
-	 *     11-49  is more similar than opposite
-	 *     100    is exactly the opposite color
-	 * ```
-	 *
-	 * @param {number[]} rgbA
-	 * @param {number[]} rgbB
-	 * @returns {number}
-	 */
-	getDifferenceBetweenRgb:
-		(rgbA, rgbB) =>
-		{
-			const labA = LeUtils.rgbToLab(rgbA);
-			const labB = LeUtils.rgbToLab(rgbB);
-			return LeUtils.getDifferenceBetweenLab(labA, labB);
-		},
-	
-	/**
-	 * Returns the difference (calculated with DeltaE) of the given LAB values. Ignores the Alpha channel.
-	 *
-	 * Returns a number:
-	 *
-	 * ```js
-	 *   < 1      is not perceptible by human eyes
-	 *     1-2    is perceptible through close observation
-	 *     2-10   is perceptible at a glance
-	 *     11-49  is more similar than opposite
-	 *     100    is exactly the opposite color
-	 * ```
-	 *
-	 * @param {number[]} labA
-	 * @param {number[]} labB
-	 * @returns {number}
-	 */
-	getDifferenceBetweenLab:
-		(labA, labB) =>
-		{
-			const deltaL = labA[0] - labB[0];
-			const deltaA = labA[1] - labB[1];
-			const deltaB = labA[2] - labB[2];
-			const c1 = Math.sqrt(labA[1] * labA[1] + labA[2] * labA[2]);
-			const c2 = Math.sqrt(labB[1] * labB[1] + labB[2] * labB[2]);
-			const deltaC = c1 - c2;
-			let deltaH = deltaA * deltaA + deltaB * deltaB - deltaC * deltaC;
-			deltaH = deltaH < 0 ? 0 : Math.sqrt(deltaH);
-			const sc = 1.0 + 0.045 * c1;
-			const sh = 1.0 + 0.015 * c1;
-			const deltaLKlsl = deltaL / (1.0);
-			const deltaCkcsc = deltaC / (sc);
-			const deltaHkhsh = deltaH / (sh);
-			const i = deltaLKlsl * deltaLKlsl + deltaCkcsc * deltaCkcsc + deltaHkhsh * deltaHkhsh;
-			return (i < 0) ? 0 : Math.sqrt(i);
-		},
-	
-	/**
-	 * Returns the RGB(A) of the given RGB(A) values, based on the given percentage (0-100).
-	 * This allows you to define a gradient of colors to fade in between, rather than just having a start and an end color.
-	 *
-	 * Usage:
-	 *
-	 * ```js
-	 * LeUtils.getRgbOfGradient({
-	 *   0:  [255, 0,   0],
-	 *   33: [255, 255, 0],
-	 *   66: [0,   255, 0],
-	 *   100:[0,   255, 255],
-	 * }, 45.1234);
-	 * ```
-	 *
-	 * @param {{percentage?:number[]}} gradient
-	 * @param {number} percentage
-	 * @returns {number[]}
-	 */
-	getRgbOfGradient:
-		(gradient, percentage) =>
-		{
-			percentage = Math.max(0, Math.min(100, FLOAT_LAX(percentage)));
-			
-			let closest = null;
-			LeUtils.each(gradient, (color, percent) =>
-			{
-				percent = INT_LAX(percent);
-				if(closest === null)
-				{
-					closest = [percent, Math.abs(percentage - percent)];
-				}
-				else
-				{
-					const difference = Math.abs(percentage - percent);
-					if(difference < closest[1])
-					{
-						closest = [percent, difference];
-					}
-				}
-			});
-			if(closest === null)
-			{
-				return [0, 0, 0];
-			}
-			closest = closest[0];
-			
-			const HIGHER = 99999;
-			const LOWER = -99999;
-			let higher = HIGHER;
-			let lower = LOWER;
-			LeUtils.each(gradient, (color, percent) =>
-			{
-				percent = INT_LAX(percent);
-				if(percent < closest)
-				{
-					if(percent > lower)
-					{
-						lower = percent;
-					}
-				}
-				if(percent > closest)
-				{
-					if(percent < higher)
-					{
-						higher = percent;
-					}
-				}
-			});
-			
-			if(((higher === HIGHER) && (lower === LOWER)) || (higher === lower))
-			{
-				return gradient[closest];
-			}
-			else if((higher !== HIGHER) && (lower !== LOWER))
-			{
-				const higherDifference = Math.abs(higher - percentage);
-				const lowerDifference = Math.abs(percentage - lower);
-				if(higherDifference > lowerDifference)
-				{
-					higher = closest;
-				}
-				else
-				{
-					lower = closest;
-				}
-			}
-			else if(lower === LOWER)
-			{
-				lower = closest;
-			}
-			else
-			{
-				higher = closest;
-			}
-			
-			if(lower > higher)
-			{
-				const tmp = higher;
-				higher = lower;
-				lower = tmp;
-			}
-			
-			const total = (higher - lower);
-			const part = (percentage - lower);
-			return LeUtils.getRgbBetween(gradient[lower], gradient[higher], ((part / total) * 100));
-		},
-	
-	/**
-	 * Returns the RGB(A) between the two given RGB(A) values, based on the given percentage (0-100).
-	 *
-	 * @param {number[]} startRgb
-	 * @param {number[]} endRgb
-	 * @param {number} percentage
-	 * @returns {number[]}
-	 */
-	getRgbBetween:
-		(startRgb, endRgb, percentage) =>
-		{
-			percentage = FLOAT_LAX(percentage);
-			const partEnd = Math.max(0, Math.min(1, (percentage / 100.0)));
-			const partStart = (1 - partEnd);
-			const length = Math.min(startRgb.length, endRgb.length);
-			let result = [];
-			for(let i = 0; i < length; i++)
-			{
-				result.push(Math.max(0, Math.min(255, Math.round((startRgb[i] * partStart) + (endRgb[i] * partEnd)))));
-			}
-			return result;
-		},
-	
-	/**
-	 * An implementation of the btoa function, which should work in all environments.
-	 *
-	 * @param {string} string
-	 * @returns {string}
-	 */
-	btoa:
-		(string) =>
-		{
-			if(typeof globalThis?.btoa === 'function')
-			{
-				return globalThis.btoa(string);
-			}
-			if(typeof globalThis?.Buffer?.from === 'function')
-			{
-				return globalThis.Buffer.from(string).toString('base64');
-			}
-			throw new Error('LeUtils.btoa: No btoa implementation found in this environment.');
-		},
-	
-	/**
-	 * An implementation of the atob function, which should work in all environments.
-	 *
-	 * @param {string} base64string
-	 * @returns {string}
-	 */
-	atob:
-		(base64string) =>
-		{
-			if(typeof globalThis?.atob === 'function')
-			{
-				return globalThis.atob(base64string);
-			}
-			if(typeof globalThis?.Buffer?.from === 'function')
-			{
-				return globalThis.Buffer.from(base64string, 'base64').toString();
-			}
-			throw new Error('LeUtils.atob: No atob implementation found in this environment.');
-		},
-	
-	/**
-	 * Encodes a UTF-8 string into a base64 string.
-	 *
-	 * @param {string} string
-	 * @returns {string}
-	 */
-	utf8ToBase64:
-		(string) =>
-		{
-			return LeUtils.btoa(encodeURIComponent(string).replace(/%([0-9A-F]{2})/g, (match, p1) => String.fromCharCode(parseInt(p1, 16))));
-		},
-	
-	/**
-	 * Decodes a base64 string back into a UTF-8 string.
-	 *
-	 * @param {string} base64string
-	 * @returns {string}
-	 */
-	base64ToUtf8:
-		(base64string) =>
-		{
-			return decodeURIComponent(LeUtils.atob(base64string.trim()).split('').map((c) => '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2)).join(''));
-		},
-	
-	/**
-	 * Converts a base64 string into a hex string.
-	 *
-	 * @param {string} base64string
-	 * @returns {string}
-	 */
-	base64ToHex:
-		(base64string) =>
-		{
-			return LeUtils.atob(base64string.trim()).split('').map((c) => ('0' + c.charCodeAt(0).toString(16)).slice(-2)).join('');
-		},
-	
-	/**
-	 * Converts a hex string into a base64 string.
-	 *
-	 * @param {string} hexstring
-	 * @returns {string}
-	 */
-	hexToBase64:
-		(hexstring) =>
-		{
-			const hexResult = hexstring.replace(/[^0-9A-F]/gi, '').match(/\w{2}/g)?.map((a) => String.fromCharCode(parseInt(a, 16)))?.join('');
-			if(!hexResult)
-			{
-				throw new Error('Invalid hex string: "' + hexstring + '"');
-			}
-			return LeUtils.btoa(hexResult);
-		},
-	
-	/**
-	 * Converts a base64 string into bytes (Uint8Array).
-	 *
-	 * @param {string} base64string
-	 * @returns {Uint8Array}
-	 */
-	base64ToBytes:
-		(base64string) =>
-		{
-			const binary = LeUtils.atob(base64string.trim());
-			const len = binary.length;
-			let data = new Uint8Array(len);
-			for(let i = 0; i < len; i++)
-			{
-				data[i] = binary.charCodeAt(i);
-			}
-			return data;
-		},
-	
-	/**
-	 * Converts bytes into a base64 string.
-	 *
-	 * @param {ArrayLike<number>|ArrayBuffer} arraybuffer
-	 * @returns {string}
-	 */
-	bytesToBase64:
-		(arraybuffer) =>
-		{
-			const bytes = new Uint8Array(arraybuffer);
-			const len = bytes.byteLength;
-			let binary = '';
-			for(let i = 0; i < len; i++)
-			{
-				binary += String.fromCharCode(bytes[i]);
-			}
-			return LeUtils.btoa(binary);
-		},
-	
-	/**
-	 * Downloads the given base64 string as a file.
-	 *
-	 * @param {string} base64string
-	 * @param {string} [fileName]
-	 * @param {string} [mimeType]
-	 */
-	downloadFile:
-		(base64string, fileName, mimeType) =>
-		{
-			if(!globalThis?.document?.createElement)
-			{
-				console.warn('LeUtils.downloadFile: Document is not available, cannot download file.');
-				return;
-			}
-			const link = globalThis.document.createElement('a');
-			link.setAttribute('download', (typeof fileName === 'string') ? fileName : 'file');
-			link.href = 'data:' + mimeType + ';base64,' + base64string;
-			link.setAttribute('target', '_blank');
-			link.click();
-		},
-	
-	/**
-	 * Loads the value from the browser, returns undefined if the value doesn't exist.
-	 *
-	 * @param {string} id
-	 * @returns {*}
-	 */
-	localStorageGet:
-		(id) =>
-		{
-			if(!globalThis?.localStorage?.getItem)
-			{
-				console.warn('LeUtils.localStorageGet: LocalStorage is not available, returning undefined.');
-				return;
-			}
-			let result = globalThis.localStorage.getItem('LeUtils_' + id);
-			if(typeof result !== 'string')
-			{
-				return;
-			}
-			try
-			{
-				return JSON.parse(result)?.['-'];
-			}
-			catch(e)
-			{
-			}
-		},
-	
-	/**
-	 * Saves the given data in the browser.
-	 *
-	 * @param {string} id
-	 * @param {*} data
-	 */
-	localStorageSet:
-		(id, data) =>
-		{
-			if(!globalThis?.localStorage?.setItem)
-			{
-				console.warn('LeUtils.localStorageSet: LocalStorage is not available, cannot save data.');
-				return;
-			}
-			if(typeof data === 'undefined')
-			{
-				globalThis.localStorage.removeItem('LeUtils_' + id);
-				return;
-			}
-			globalThis.localStorage.setItem('LeUtils_' + id, JSON.stringify({'-':data}));
-		},
-	
-	/**
-	 * Removes the data from the browser.
-	 *
-	 * @param {string} id
-	 */
-	localStorageRemove:
-		(id) =>
-		{
-			if(!globalThis?.localStorage?.removeItem)
-			{
-				console.warn('LeUtils.localStorageRemove: LocalStorage is not available, cannot remove data.');
-				return;
-			}
-			globalThis.localStorage.removeItem('LeUtils_' + id);
-		},
-	
-	/**
-	 * Returns whether the current hostname (globalThis.location.hostname) is private (such as localhost, 192.168.1.1, etc).
-	 * This can be used to determine if the app is running in a development environment or not.
-	 *
-	 * Only "localhost" and IPv4 addresses are supported. IPv6 addresses will always return false.
-	 *
-	 * @returns {boolean}
-	 */
-	isCurrentHostPrivate:
-		(() =>
-		{
-			let lastHostname = null;
-			let lastResult = false;
-			
-			return () =>
-			{
-				if(!globalThis?.location?.hostname)
-				{
-					console.warn('LeUtils.isCurrentHostPrivate: No location.hostname found, returning false.');
-					return false;
-				}
-				const hostname = globalThis.location.hostname;
-				if(lastHostname === hostname)
-				{
-					return lastResult;
-				}
-				lastHostname = hostname;
-				lastResult = LeUtils.isGivenHostPrivate(lastHostname);
-				return lastResult;
-			};
-		})(),
-	
-	/**
-	 * Returns true if the given hostname is private (such as localhost, 192.168.1.1, etc).
-	 *
-	 * Only "localhost" and IPv4 addresses are supported. IPv6 addresses will always return false.
-	 *
-	 * @param {string} host
-	 * @returns {boolean}
-	 */
-	isGivenHostPrivate:
-		(host) =>
-		{
-			host = STRING(host).trim();
-			if(!host)
-			{
-				return false;
-			}
-			try
-			{
-				host = (new URL(host)).hostname;
-			}
-			catch(e)
-			{
-				host = host.split(':')[0];
-			}
-			host = STRING(host).trim().toLowerCase();
-			
-			if((host === 'localhost') || (host === '127.0.0.1'))
-			{
-				return true;
-			}
-			if(!/^(\d{1,3}\.){3}\d{1,3}$/.test(host))
-			{
-				return false;
-			}
-			const parts = host.split('.');
-			return (parts[0] === '10') || // 10.0.0.0 - 10.255.255.255
-				((parts[0] === '172') && ((parseInt(parts[1], 10) >= 16) && (parseInt(parts[1], 10) <= 31))) || // 172.16.0.0 - 172.31.255.255
-				((parts[0] === '192') && (parts[1] === '168')); // 192.168.0.0 - 192.168.255.255
-		},
-	
-	/**
-	 * @typedef {Object} LeUtils_TransactionalValue
-	 * @property {*} value
-	 * @property {{id:string, value:*}[]} changes
-	 */
-	/**
-	 * Creates and returns a new TransactionalValue object.
-	 * With a TransactionalValue, you can keep track of changes to a value, and commit or cancel them.
-	 *
-	 * Multiple uncommitted changes can be made at the same time, the last change will be the one that overwrites older changes.
-	 * If that change is cancelled, the previous change will be the one that overwrites older changes.
-	 * This allows you to make multiple unconfirmed changes, and confirm or cancel each of them individually at any time.
-	 *
-	 * @param {*} [value]
-	 * @returns {LeUtils_TransactionalValue}
-	 */
-	createTransactionalValue:
-		(value) =>
-		{
-			if(typeof value === 'undefined')
-			{
-				value = null;
-			}
-			return {value:value, changes:[]};
-		},
-	
-	/**
-	 * Returns true if the given value is a valid TransactionalValue, returns false if it isn't.
-	 *
-	 * @param {LeUtils_TransactionalValue} transactionalValue
-	 * @returns {boolean}
-	 */
-	isTransactionalValueValid:
-		(transactionalValue) =>
-		{
-			return ((typeof transactionalValue === 'object') && ('value' in transactionalValue) && ('changes' in transactionalValue) && Array.isArray(transactionalValue.changes));
-		},
-	
-	/**
-	 * Returns true if the given value is a TransactionalValue, false otherwise.
-	 *
-	 * @param {LeUtils_TransactionalValue} transactionalValue
-	 * @returns {string}
-	 */
-	transactionalValueToString:
-		(transactionalValue) =>
-		{
-			if(!LeUtils.isTransactionalValueValid(transactionalValue))
-			{
-				return transactionalValue + '';
-			}
-			if(transactionalValue.changes.length <= 0)
-			{
-				return '' + transactionalValue.value;
-			}
-			let valuesString = '' + transactionalValue.value;
-			for(let i = 0; i < transactionalValue.changes.length; i++)
-			{
-				valuesString += ' -> ' + transactionalValue.changes[i].value;
-			}
-			return transactionalValue.changes[transactionalValue.changes.length - 1].value + ' (' + valuesString + ')';
-		},
-	
-	/**
-	 * Sets the committed value of the given TransactionalValue to the given value. Clears out the previously uncommitted changes.
-	 *
-	 * @param {LeUtils_TransactionalValue} transactionalValue
-	 * @param {*} value
-	 */
-	transactionSetAndCommit:
-		(transactionalValue, value) =>
-		{
-			checkTransactionalValue(transactionalValue);
-			if(typeof value === 'undefined')
-			{
-				value = null;
-			}
-			transactionalValue.value = value;
-			transactionalValue.changes = [];
-		},
-	
-	/**
-	 * Sets the value of the given TransactionalValue to the given value, without yet committing it, meaning it can be committed or cancelled later.
-	 * It returns the ID of the change, which can be used to commit or cancel the change later.
-	 *
-	 * @param {LeUtils_TransactionalValue} transactionalValue
-	 * @param {*} value
-	 * @returns {string}
-	 */
-	transactionSetWithoutCommitting:
-		(transactionalValue, value) =>
-		{
-			checkTransactionalValue(transactionalValue);
-			if(typeof value === 'undefined')
-			{
-				value = null;
-			}
-			const id = LeUtils.uniqueId();
-			transactionalValue.changes.push({id:id, value:value});
-			return id;
-		},
-	
-	/**
-	 * Commits the change with the given ID, making it the new committed value.
-	 * Returns true if the change was found and committed, returns false if it was already overwritten by a newer committed change.
-	 *
-	 * @param {LeUtils_TransactionalValue} transactionalValue
-	 * @param {string} changeId
-	 * @returns {boolean}
-	 */
-	transactionCommitChange:
-		(transactionalValue, changeId) =>
-		{
-			checkTransactionalValue(transactionalValue);
-			const change = findTransactionalValueChange(transactionalValue, changeId);
-			if(change === null)
-			{
-				return false;
-			}
-			transactionalValue.value = change.value;
-			transactionalValue.changes.splice(0, change.index + 1);
-			return true;
-		},
-	
-	/**
-	 * Cancels the change with the given ID, removing it from the uncommitted changes.
-	 * Returns true if the change was found and removed, returns false if it was already overwritten by a newer committed change.
-	 *
-	 * @param {LeUtils_TransactionalValue} transactionalValue
-	 * @param {string} changeId
-	 * @returns {boolean}
-	 */
-	transactionCancelChange:
-		(transactionalValue, changeId) =>
-		{
-			checkTransactionalValue(transactionalValue);
-			const change = findTransactionalValueChange(transactionalValue, changeId);
-			if(change === null)
-			{
-				return false;
-			}
-			transactionalValue.changes.splice(change.index, 1);
-			return true;
-		},
-	
-	/**
-	 * Returns true if the change was found, meaning it can still make a difference to the final committed value of this TransactionalValue.
-	 * Returns false if it was already overwritten by a newer committed change, meaning that this change can no longer make a difference to the final committed value of this TransactionalValue.
-	 *
-	 * @param {LeUtils_TransactionalValue} transactionalValue
-	 * @param {string} changeId
-	 * @returns {boolean}
-	 */
-	transactionIsChangeRelevant:
-		(transactionalValue, changeId) =>
-		{
-			checkTransactionalValue(transactionalValue);
-			return (findTransactionalValueChange(transactionalValue, changeId) !== null);
-		},
-	
-	/**
-	 * Returns the committed value of the given TransactionalValue.
-	 *
-	 * @param {LeUtils_TransactionalValue} transactionalValue
-	 * @returns {*}
-	 */
-	transactionGetCommittedValue:
-		(transactionalValue) =>
-		{
-			checkTransactionalValue(transactionalValue);
-			return transactionalValue.value;
-		},
-	
-	/**
-	 * Returns the value (including any uncommitted changes made to it) of the given TransactionalValue.
-	 *
-	 * @param {LeUtils_TransactionalValue} transactionalValue
-	 * @returns {*}
-	 */
-	transactionGetValue:
-		(transactionalValue) =>
-		{
-			checkTransactionalValue(transactionalValue);
-			if(transactionalValue.changes.length <= 0)
-			{
-				return transactionalValue.value;
-			}
-			return transactionalValue.changes[transactionalValue.changes.length - 1].value;
-		},
-	
-	/**
-	 * Creates a worker thread. Workers have to be stored at /workers/{workerName}.worker.js for this to work.
-	 *
-	 * Example of a worker file:
-	 *
-	 * ```js
-	 * onmessage = (message) =>
-	 * {
-	 *     postMessage({
-	 *         ...message.data,
-	 *         results: ['...some expensive calculation involving message.data...'],
-	 *     });
-	 * };
-	 * ```
-	 *
-	 * Usage:
-	 *
-	 * ```js
-	 * const {results} = await (async () =>
-	 * {
-	 *     try
-	 *     {
-	 *         return await LeUtils.sendWorkerMessage('my-worker', {someData:[1, 2, 3, 4, 5]});
-	 *     }
-	 *     catch(error)
-	 *     {
-	 *         console.error('MyWorker: ', error);
-	 *         return {results:[]};
-	 *     }
-	 * })();
-	 * ```
-	 *
-	 * or, if you want more control over the number of threads you have (the above example will only create 1 thread per worker):
-	 *
-	 * ```js
-	 * const myWorker1 = LeUtils.createWorkerThread('my-worker'); // creates a thread, you can create multiple worker threads of the same worker, to run multiple instances in parallel
-	 * const myWorker2 = LeUtils.createWorkerThread('my-worker'); // same worker, another thread
-	 * const {results} = await (async () =>
-	 * {
-	 *     try
-	 *     {
-	 *         return await myWorker1.sendMessage({someData:[1, 2, 3, 4, 5]});
-	 *     }
-	 *     catch(error)
-	 *     {
-	 *         console.error('MyWorker: ', error);
-	 *         return {results:[]};
-	 *     }
-	 * })();
-	 * ```
-	 *
-	 * @param {string} name
-	 * @returns {{worker:Worker|null, sendMessage:(data:Object,options:{timeout:number|undefined}|undefined)=>Promise<Object>}}
-	 */
-	createWorkerThread:
-		(name) =>
-		{
-			if(!globalThis?.Worker)
-			{
-				console.warn('LeUtils.createWorkerThread: Workers are not supported in this environment, returning a dummy worker.');
-				return {
-					worker:     null,
-					sendMessage:(data, options) => new Promise((resolve, reject) =>
-					{
-						reject('Workers are not supported in this environment');
-					}),
-				};
-			}
-			
-			const worker = new globalThis.Worker('/workers/' + name + '.worker.js');
-			let listeners = new Map();
-			
-			const addListener = (id, callback) =>
-			{
-				listeners.set(id, callback);
-			};
-			
-			const removeListener = (id) =>
-			{
-				listeners.delete(id);
-			};
-			
-			const sendMessage = (data, options) =>
-			{
-				return new Promise((resolve, reject) =>
-				{
-					const id = LeUtils.uniqueId();
-					addListener(id, resolve);
-					setTimeout(() =>
-					{
-						removeListener(id);
-						reject('timeout');
-					}, options?.timeout ?? 10000);
-					
-					worker.postMessage({
-						id,
-						...data,
-					});
-				});
-			};
-			
-			worker.onerror = (error) =>
-			{
-				console.error('Worker ' + name + ':', error);
-			};
-			worker.onmessage = (message) =>
-			{
-				const data = message.data;
-				if(data?.id)
-				{
-					const callback = listeners.get(data.id);
-					if(callback)
-					{
-						removeListener(data.id);
-						callback(data);
-					}
-				}
-			};
-			
-			return {worker, sendMessage};
-		},
-	
-	/**
-	 * Sends a message to the given worker. Creates a worker thread for this worker if it doesn't exist yet.
-	 *
-	 * See {@link LeUtils#createWorkerThread} for more info on how to use workers.
-	 *
-	 * @param {string} workerName
-	 * @param {Object} data
-	 * @param {{timeout:number|undefined}} [options]
-	 * @returns {Promise<Object>}
-	 */
-	sendWorkerMessage:
-		(() =>
-		{
-			const workers = new Map();
-			return (workerName, data, options) =>
-			{
-				if(!workers.has(workerName))
-				{
-					workers.set(workerName, LeUtils.createWorkerThread(workerName));
-				}
-				return workers.get(workerName).sendMessage(data, options);
-			};
-		})(),
-	
-	/**
-	 * Purges the given email address, returning an empty string if it's invalid.
-	 *
-	 * @param {string} email
-	 * @returns {string}
-	 */
-	purgeEmail:
-		(email) =>
-		{
-			email = STRING(email).trim().toLowerCase().replace(/\s/g, '');
-			if(!email.includes('@') || !email.includes('.'))
-			{
-				return '';
-			}
-			return email;
-		},
-	
-	/**
-	 * Returns true if the focus is effectively clear, meaning that the user is not typing in an input field.
-	 *
-	 * @returns {boolean}
-	 */
-	isFocusClear:(() =>
-	{
-		const inputTypes = ['text', 'search', 'email', 'number', 'password', 'tel', 'time', 'url', 'week', 'month', 'date', 'datetime-local'];
-		return () => !((globalThis?.document?.activeElement?.tagName?.toLowerCase() === 'input') && inputTypes.includes(globalThis?.document?.activeElement?.getAttribute('type')?.toLowerCase() ?? ''));
-	})(),
-	
-	/**
-	 * Returns the user's locale. Returns 'en-US' if it can't be determined.
-	 *
-	 * @returns {string}
-	 */
-	getUserLocale:(() =>
-	{
-		let userLocale = null;
-		return () =>
-		{
-			if(userLocale === null)
-			{
-				userLocale = (() =>
-				{
-					let locales = globalThis?.navigator?.languages ?? [];
-					if(!IS_ARRAY(locales) || (locales.length <= 0))
-					{
-						return 'en-US';
-					}
-					locales = locales.filter(locale => ((typeof locale === 'string') && locale.includes('-') && (locale.toLowerCase() !== 'en-us')));
-					if(locales.length <= 0)
-					{
-						return 'en-US';
-					}
-					const localesNoEnglish = locales.filter(locale => !locale.toLowerCase().startsWith('en-'));
-					if(localesNoEnglish.length <= 0)
-					{
-						return locales[0];
-					}
-					return localesNoEnglish[0];
-				})();
-			}
-			return userLocale;
-		};
-	})(),
-	
-	/**
-	 * Returns the user's locale date format. Always returns YYYY MM DD, with the character in between depending on the user's locale. Returns 'YYYY/MM/DD' if the user's locale can't be determined.
-	 *
-	 * @returns {string}
-	 */
-	getUserLocaleDateFormat:(() =>
-	{
-		let userLocaleDateFormat = null;
-		return () =>
-		{
-			if(userLocaleDateFormat === null)
-			{
-				userLocaleDateFormat = (() =>
-				{
-					let char = '/';
-					if(globalThis?.Intl?.DateTimeFormat)
-					{
-						const formattedDate = new globalThis.Intl.DateTimeFormat(LeUtils.getUserLocale()).format();
-						if(formattedDate.includes('-'))
-						{
-							char = '-';
-						}
-						else if(formattedDate.includes('. '))
-						{
-							char = '.';
-						}
-						else if(formattedDate.includes('.'))
-						{
-							char = '.';
-						}
-					}
-					return 'YYYY' + char + 'MM' + char + 'DD';
-				})();
-			}
-			return userLocaleDateFormat;
-		};
-	})(),
-};