@lowentry/utils 1.13.5 → 1.15.1

package/src/LeUtils.js

@@ -4,7 +4,7 @@ import {ISSET, IS_OBJECT, IS_ARRAY, STRING, INT_LAX, FLOAT_LAX, INT_LAX_ANY, FLO
 
 
 /**
- * @param {LeUtils~TransactionalValue} transactionalValue
+ * @param {LeUtils_TransactionalValue} transactionalValue
  */
 const checkTransactionalValue = (transactionalValue) =>
 {
@@ -17,7 +17,7 @@ const checkTransactionalValue = (transactionalValue) =>
 };
 
 /**
- * @param {LeUtils~TransactionalValue} transactionalValue
+ * @param {LeUtils_TransactionalValue} transactionalValue
  * @param {string} changeId
  * @returns {{index:number, value:*}|null}
  */
@@ -75,7 +75,7 @@ export const LeUtils = {
 			
 			if((document.readyState === 'interactive') || (document.readyState === 'complete'))
 			{
-				return LeUtils.setTimeout(callback, 0);
+				return LeUtils.setTimeout(() => callback(), 0);
 			}
 			else
 			{
@@ -435,17 +435,11 @@ export const LeUtils = {
 			return result;
 		},
 	
-	/**
-	 * @callback LeUtils~__findIndexValueCallback
-	 * @param {*} value
-	 * @param {*} index
-	 * @returns {boolean|undefined}
-	 */
 	/**
 	 * 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 {LeUtils~__findIndexValueCallback} callback
+	 * @param {(value:*, index:*) => boolean|void} callback
 	 * @param {boolean} [optionalSkipHasOwnPropertyCheck]
 	 * @returns {{index:*, value:*}|null}
 	 */
@@ -460,7 +454,7 @@ export const LeUtils = {
 					result = {index, value};
 					return false;
 				}
-			});
+			}, optionalSkipHasOwnPropertyCheck);
 			return result;
 		},
 	
@@ -468,7 +462,7 @@ export const LeUtils = {
 	 * 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 {LeUtils~__findIndexValueCallback} callback
+	 * @param {(value:*, index:*) => boolean|void} callback
 	 * @param {boolean} [optionalSkipHasOwnPropertyCheck]
 	 * @returns {*|null}
 	 */
@@ -479,7 +473,7 @@ export const LeUtils = {
 	 * 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 {LeUtils~__findIndexValueCallback} callback
+	 * @param {(value:*, index:*) => boolean|void} callback
 	 * @param {boolean} [optionalSkipHasOwnPropertyCheck]
 	 * @returns {*|null}
 	 */
@@ -487,50 +481,222 @@ export const LeUtils = {
 		(elements, callback, optionalSkipHasOwnPropertyCheck = false) => LeUtils.findIndexValue(elements, callback, optionalSkipHasOwnPropertyCheck)?.value ?? null,
 	
 	/**
-	 * @callback LeUtils~__eachCallback
-	 * @param {*} value
+	 * Returns the value at the given index in the given elements.
+	 *
+	 * @param {*} elements
 	 * @param {*} index
-	 * @returns {boolean|undefined}
+	 * @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(ArrayBuffer.isView(elements) && !(elements instanceof DataView))
+			{
+				return elements[index];
+			}
+			if(typeof elements === 'string')
+			{
+				return elements.charAt(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;
+		},
+	
 	/**
-	 * Loops through each element in the given array or object, and calls the callback for each element.
+	 * Checks if the given elements can be iterated over using LeUtils.each().
 	 *
-	 * @param {*[]|object|Function} elements
-	 * @param {LeUtils~__eachCallback} callback
+	 * @param {*} elements
+	 * @returns {boolean}
+	 */
+	supportsEach:
+		(elements) =>
+		{
+			if((elements === null) || (typeof elements === 'undefined'))
+			{
+				return false;
+			}
+			return !!(
+				(Array.isArray(elements))
+				|| ((typeof elements === 'object') && (elements?.constructor === Object))
+				|| (typeof elements === 'string')
+				|| (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]
-	 * @returns {*[]|object|Function}
+	 * @returns {Generator<*, void, *>}
 	 */
-	each:
-		(elements, callback, optionalSkipHasOwnPropertyCheck = false) =>
+	eachIterator:
+		function* (elements, optionalSkipHasOwnPropertyCheck = false)
 		{
-			if((elements !== null) && (typeof elements !== 'undefined'))
+			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))
 			{
-				if(Array.isArray(elements))
+				for(const i in elements)
 				{
-					for(let index = 0; index < elements.length; index++)
+					if((optionalSkipHasOwnPropertyCheck === true) || Object.prototype.hasOwnProperty.call(elements, i))
 					{
-						if(callback.call(elements[index], elements[index], index) === false)
-						{
-							break;
-						}
+						yield [elements[i], i];
 					}
 				}
-				else if((typeof elements === 'object') || (typeof elements === 'function'))
+				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')
+			{
+				for(let i = 0; i < elements.length; i++)
+				{
+					yield [elements.charAt(i), i];
+				}
+				return;
+			}
+			if(typeof elements?.[Symbol.iterator] === 'function')
+			{
+				let i = 0;
+				for(const value of elements)
 				{
-					for(let index in 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))
 					{
-						if((optionalSkipHasOwnPropertyCheck === true) || Object.prototype.hasOwnProperty.call(elements, index))
-						{
-							if(callback.call(elements[index], elements[index], index) === false)
-							{
-								break;
-							}
-						}
+						yield [elements[i], i];
 					}
 				}
-				else
+				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)
 				{
-					console.warn('Executed LeUtils.each() on an invalid type: [' + (typeof elements) + ']', elements);
+					break;
 				}
 			}
 			return elements;
@@ -539,54 +705,55 @@ export const LeUtils = {
 	/**
 	 * Like LeUtils.each(), except that it expects an async callback.
 	 *
-	 * @param {*[]|object|function} elements
-	 * @param {LeUtils~__eachCallback} asyncCallback
+	 * @param {*} elements
+	 * @param {(value:*, index?:*) => Promise<boolean|undefined>} asyncCallback
 	 * @param {number} [optionalParallelCount]
 	 * @param {boolean} [optionalSkipHasOwnPropertyCheck]
-	 * @returns {*[]|object|function}
+	 * @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) =>
 			{
-				let promises = [];
+				const runningPromises = new Set();
 				let doBreak = false;
-				await LeUtils.eachAsync(elements, async (element, index) =>
+				await LeUtils.eachAsync(elements, async (value, index) =>// loop through each element
 				{
-					while(promises.length > optionalParallelCount)
+					if(doBreak)
 					{
-						let newPromises = [];
-						LeUtils.each(promises, (promise) =>
-						{
-							if(!promise.__lowentry_utils__promise_is_done__)
-							{
-								newPromises.push(promise);
-							}
-						});
-						promises = newPromises;
-						if(promises.length > optionalParallelCount)
-						{
-							await Promise.any(promises);
-						}
+						return false;
 					}
 					
-					if(doBreak)
+					// if no spot is available, wait for one to finish
+					while(runningPromises.size >= optionalParallelCount)
 					{
-						return false;
+						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(element, element, index)) === false)
+						if((await asyncCallback.call(value, value, index)) === false)
 						{
 							doBreak = true;
 						}
-						promise.__lowentry_utils__promise_is_done__ = true;
 					})();
-					promises.push(promise);
-				}, optionalSkipHasOwnPropertyCheck);
-				await Promise.all(promises);
+					runningPromises.add(promise);
+					promise.finally(() =>
+					{
+						runningPromises.delete(promise);
+					});
+				}, 1, optionalSkipHasOwnPropertyCheck);
+				await Promise.all(runningPromises);
 				return elements;
 			};
 			
@@ -600,166 +767,163 @@ export const LeUtils = {
 						return await eachAsyncParallel(elements, asyncCallback, parallelCount, optionalSkipHasOwnPropertyCheck);
 					}
 					
-					if(Array.isArray(elements))
-					{
-						for(let index = 0; index < elements.length; index++)
-						{
-							if((await asyncCallback.call(elements[index], elements[index], index)) === false)
-							{
-								break;
-							}
-						}
-					}
-					else if((typeof elements === 'object') || (typeof elements === 'function'))
+					for(const [value, key] of LeUtils.eachIterator(elements, optionalSkipHasOwnPropertyCheck))
 					{
-						for(let index in elements)
+						if((await asyncCallback.call(value, value, key)) === false)
 						{
-							if((optionalSkipHasOwnPropertyCheck === true) || Object.prototype.hasOwnProperty.call(elements, index))
-							{
-								if((await asyncCallback.call(elements[index], elements[index], index)) === false)
-								{
-									break;
-								}
-							}
+							break;
 						}
 					}
-					else
-					{
-						console.warn('Executed LeUtils.eachAsync() on an invalid type: [' + (typeof elements) + ']', elements);
-					}
 				}
 				return elements;
 			};
 		})(),
 	
 	/**
-	 * @callback LeUtils~__filterCallback
-	 * @param {*} value
-	 * @param {*} index
-	 * @returns {boolean|undefined}
+	 * 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 array or object, with only the elements that returned true (or a value equals to true) from the callback.
+	 * 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 {*[]|object|Function} elements
-	 * @param {LeUtils~__filterCallback} [callback]
+	 * @param {*} elements
+	 * @param {(value:*, index:*) => boolean|undefined} [callback]
 	 * @param {boolean} [optionalSkipHasOwnPropertyCheck]
-	 * @returns {*[]|object|Function}
+	 * @returns {*}
 	 */
 	filter:
 		(elements, callback, optionalSkipHasOwnPropertyCheck = false) =>
 		{
-			if((elements !== null) && (typeof elements !== 'undefined'))
+			const [success, collection, add] = LeUtils.getEmptySimplifiedCollection(elements);
+			if(!success)
 			{
-				if(Array.isArray(elements))
-				{
-					let result = [];
-					for(let index = 0; index < elements.length; index++)
-					{
-						if((!callback && elements[index]) || (callback && callback.call(elements[index], elements[index], index)))
-						{
-							result.push(elements[index]);
-						}
-					}
-					return result;
-				}
-				else if((typeof elements === 'object') || (typeof elements === 'function'))
+				return elements;
+			}
+			
+			LeUtils.each(elements, (value, index) =>
+			{
+				if(!callback)
 				{
-					let result = {};
-					for(let index in elements)
+					if(value)
 					{
-						if((optionalSkipHasOwnPropertyCheck === true) || Object.prototype.hasOwnProperty.call(elements, index))
-						{
-							if((!callback && elements[index]) || (callback && callback.call(elements[index], elements[index], index)))
-							{
-								result[index] = elements[index];
-							}
-						}
+						add(value, index);
 					}
-					return result;
 				}
-				else
+				else if(callback.call(value, value, index))
 				{
-					console.warn('Executed LeUtils.filter() on an invalid type: [' + (typeof elements) + ']', elements);
+					add(value, index);
 				}
-			}
-			return elements;
+			}, optionalSkipHasOwnPropertyCheck);
+			return collection;
 		},
 	
 	/**
-	 * @callback LeUtils~__mapCallback
-	 * @param {*} value
-	 * @param {*} index
-	 * @returns {*}
-	 */
-	/**
-	 * Loops through the given elements, and returns a new array or object, with the elements that were returned from the callback.
+	 * Loops through the given elements, and returns a new collection, with the elements that were returned from the callback.
 	 *
-	 * @param {*[]|object|Function} elements
-	 * @param {LeUtils~__mapCallback} [callback]
+	 * @param {*} elements
+	 * @param {(value:*, index:*) => *} [callback]
 	 * @param {boolean} [optionalSkipHasOwnPropertyCheck]
-	 * @returns {*[]|object|Function}
+	 * @returns {*}
 	 */
 	map:
 		(elements, callback, optionalSkipHasOwnPropertyCheck = false) =>
 		{
-			if((elements !== null) && (typeof elements !== 'undefined'))
+			const [success, collection, add] = LeUtils.getEmptySimplifiedCollection(elements);
+			if(!success)
 			{
-				if(Array.isArray(elements))
-				{
-					let result = [];
-					for(let index = 0; index < elements.length; index++)
-					{
-						if(!callback)
-						{
-							result[index] = elements[index];
-						}
-						else
-						{
-							result[index] = callback.call(elements[index], elements[index], index);
-						}
-					}
-					return result;
-				}
-				else if((typeof elements === 'object') || (typeof elements === 'function'))
+				return elements;
+			}
+			
+			LeUtils.each(elements, (value, index) =>
+			{
+				if(!callback)
 				{
-					let result = {};
-					for(let index in elements)
-					{
-						if((optionalSkipHasOwnPropertyCheck === true) || Object.prototype.hasOwnProperty.call(elements, index))
-						{
-							if(!callback)
-							{
-								result[index] = elements[index];
-							}
-							else
-							{
-								result[index] = callback.call(elements[index], elements[index], index);
-							}
-						}
-					}
-					return result;
+					add(value, index);
 				}
 				else
 				{
-					console.warn('Executed LeUtils.map() on an invalid type: [' + (typeof elements) + ']', elements);
+					add(callback.call(value, value, index), index);
 				}
-			}
-			return elements;
+			}, optionalSkipHasOwnPropertyCheck);
+			return collection;
 		},
 	
-	/**
-	 * @callback LeUtils~__mapToArrayCallback
-	 * @param {*} value
-	 * @param {*} index
-	 * @returns {*}
-	 */
 	/**
 	 * Loops through the given elements, and returns a new array, with the elements that were returned from the callback. Always returns an array.
 	 *
-	 * @param {*[]|object|Function} elements
-	 * @param {LeUtils~__mapToArrayCallback} [callback]
+	 * @param {*} elements
+	 * @param {(value:*, index:*) => *} [callback]
 	 * @param {boolean} [optionalSkipHasOwnPropertyCheck]
 	 * @returns {*[]}
 	 */
@@ -767,59 +931,26 @@ export const LeUtils = {
 		(elements, callback, optionalSkipHasOwnPropertyCheck = false) =>
 		{
 			let result = [];
-			if((elements !== null) && (typeof elements !== 'undefined'))
+			LeUtils.each(elements, (value, index) =>
 			{
-				if(Array.isArray(elements))
-				{
-					for(let index = 0; index < elements.length; index++)
-					{
-						if(!callback)
-						{
-							result.push(elements[index]);
-						}
-						else
-						{
-							result.push(callback.call(elements[index], elements[index], index));
-						}
-					}
-				}
-				else if((typeof elements === 'object') || (typeof elements === 'function'))
+				if(!callback)
 				{
-					for(let index in elements)
-					{
-						if((optionalSkipHasOwnPropertyCheck === true) || Object.prototype.hasOwnProperty.call(elements, index))
-						{
-							if(!callback)
-							{
-								result.push(elements[index]);
-							}
-							else
-							{
-								result.push(callback.call(elements[index], elements[index], index));
-							}
-						}
-					}
+					result.push(value);
 				}
 				else
 				{
-					console.warn('Executed LeUtils.mapToArray() on an invalid type: [' + (typeof elements) + ']', elements);
+					result.push(callback.call(value, value, index));
 				}
-			}
+			}, optionalSkipHasOwnPropertyCheck);
 			return result;
 		},
 	
-	/**
-	 * @callback LeUtils~__mapToArraySortedCallback
-	 * @param {*} value
-	 * @param {*} index
-	 * @returns {*}
-	 */
 	/**
 	 * 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 {*[]|object|Function} elements
-	 * @param {LeUtils~__sortKeysComparatorCallback} comparator
-	 * @param {LeUtils~__mapToArraySortedCallback} [callback]
+	 * @param {*} elements
+	 * @param {(valueA:*, valueB:*) => number} comparator
+	 * @param {(value:*, index:*) => *} [callback]
 	 * @param {boolean} [optionalSkipHasOwnPropertyCheck]
 	 * @returns {*[]}
 	 */
@@ -828,31 +959,26 @@ export const LeUtils = {
 		{
 			const keys = LeUtils.sortKeys(elements, comparator, optionalSkipHasOwnPropertyCheck);
 			let result = [];
-			for(let i = 0; i < keys.length; i++)
+			for(const key of keys)
 			{
+				const value = LeUtils.getValueAtIndex(elements, key, optionalSkipHasOwnPropertyCheck);
 				if(!callback)
 				{
-					result.push(elements[keys[i]]);
+					result.push(value);
 				}
 				else
 				{
-					result.push(callback.call(elements[keys[i]], elements[keys[i]], keys[i]));
+					result.push(callback.call(value, value, key));
 				}
 			}
 			return result;
 		},
 	
-	/**
-	 * @callback LeUtils~__sortKeysComparatorCallback
-	 * @param {*} elementA
-	 * @param {*} elementB
-	 * @returns {number}
-	 */
 	/**
 	 * 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 {*[]|object|Function} elements
-	 * @param {LeUtils~__sortKeysComparatorCallback} comparator
+	 * @param {*} elements
+	 * @param {(valueA:*, valueB:*) => number} comparator
 	 * @param {boolean} [optionalSkipHasOwnPropertyCheck]
 	 * @returns {*[]}
 	 */
@@ -860,31 +986,12 @@ export const LeUtils = {
 		(elements, comparator, optionalSkipHasOwnPropertyCheck = false) =>
 		{
 			let keys = [];
-			if((elements !== null) && (typeof elements !== 'undefined'))
+			LeUtils.each(elements, (value, index) =>
 			{
-				if(Array.isArray(elements))
-				{
-					for(let index = 0; index < elements.length; index++)
-					{
-						keys.push(index);
-					}
-				}
-				else if((typeof elements === 'object') || (typeof elements === 'function'))
-				{
-					for(let index in elements)
-					{
-						if((optionalSkipHasOwnPropertyCheck === true) || Object.prototype.hasOwnProperty.call(elements, index))
-						{
-							keys.push(index);
-						}
-					}
-				}
-				else
-				{
-					console.warn('Executed LeUtils.sortKeys() on an invalid type: [' + (typeof elements) + ']', elements);
-				}
-			}
-			keys.sort((a, b) => comparator(elements[a], elements[b]));
+				keys.push(index);
+			}, optionalSkipHasOwnPropertyCheck);
+			
+			keys.sort((a, b) => comparator(LeUtils.getValueAtIndex(elements, a, optionalSkipHasOwnPropertyCheck), LeUtils.getValueAtIndex(elements, b, optionalSkipHasOwnPropertyCheck)));
 			return keys;
 		},
 	
@@ -927,6 +1034,46 @@ export const LeUtils = {
 			};
 		})(),
 	
+	/**
+	 * 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.
 	 *
@@ -957,13 +1104,26 @@ export const LeUtils = {
 	compareNumericStrings:
 		(a, b) =>
 		{
-			a = STRING(a).trim();
-			b = STRING(b).trim();
-			if(a.length === b.length)
+			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 (a < b) ? -1 : ((a > b) ? 1 : 0);
+				return (aParts.length < bParts.length) ? -1 : 1;
 			}
-			return (a.length < b.length) ? -1 : 1;
+			return 0;
 		},
 	
 	/**
@@ -1043,9 +1203,9 @@ export const LeUtils = {
 			{
 			}.constructor;
 			
-			const PossibleGeneratorFunctionNames = Array.from(new Set(['GeneratorFunction', 'AsyncFunction', 'AsyncGeneratorFunction', GeneratorFunction.name, GeneratorFunction.displayName, AsyncGeneratorFunction.name, AsyncGeneratorFunction.displayName])).filter((element) =>
+			const PossibleGeneratorFunctionNames = Array.from(new Set(['GeneratorFunction', 'AsyncFunction', 'AsyncGeneratorFunction', GeneratorFunction.name, AsyncGeneratorFunction.name])).filter((element) =>
 			{
-				return (element && (element !== RegularFunction.name) && (element !== RegularFunction.displayName));
+				return (element && (element !== RegularFunction.name));
 			});
 			
 			return (func) =>
@@ -1059,20 +1219,17 @@ export const LeUtils = {
 				{
 					return false;
 				}
+				// noinspection JSUnresolvedVariable
 				return ((constructor.name && PossibleGeneratorFunctionNames.includes(constructor.name)) || (constructor.displayName && PossibleGeneratorFunctionNames.includes(constructor.displayName)));
 			};
 		})(),
 	
-	/**
-	 * @callback LeUtils~__setTimeoutCallback
-	 * @param {number} deltaTime
-	 */
 	/**
 	 * 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 {LeUtils~__setTimeoutCallback} callback ([number] deltaTime)
+	 * @param {(deltaTime:number) => *} callback
 	 * @param {number} ms
 	 * @returns {{remove:Function}}
 	 */
@@ -1091,6 +1248,7 @@ export const LeUtils = {
 			ms = FLOAT_LAX(ms);
 			
 			let lastTime = performance.now();
+			/** @type {number|null} */
 			let handler = window.setTimeout(() =>
 			{
 				const currentTime = performance.now();
@@ -1118,16 +1276,12 @@ export const LeUtils = {
 			};
 		},
 	
-	/**
-	 * @callback LeUtils~__setIntervalCallback
-	 * @param {number} deltaTime
-	 */
 	/**
 	 * 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 {LeUtils~__setIntervalCallback} callback ([number] deltaTime)
+	 * @param {(deltaTime:number) => *} callback
 	 * @param {number} [intervalMs]
 	 * @param {boolean} [fireImmediately]
 	 * @returns {{remove:Function}}
@@ -1159,6 +1313,7 @@ export const LeUtils = {
 			}
 			
 			let lastTime = performance.now();
+			/** @type {number|null} */
 			let handler = window.setInterval(() =>
 			{
 				const currentTime = performance.now();
@@ -1186,16 +1341,12 @@ export const LeUtils = {
 			};
 		},
 	
-	/**
-	 * @callback LeUtils~__setAnimationFrameTimeoutCallback
-	 * @param {number} deltaTime
-	 */
 	/**
 	 * 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 {LeUtils~__setAnimationFrameTimeoutCallback} callback ([number] deltaTime)
+	 * @param {(deltaTime:number) => *} callback
 	 * @param {number} [frames]
 	 * @returns {{remove:Function}}
 	 */
@@ -1256,16 +1407,12 @@ export const LeUtils = {
 			};
 		},
 	
-	/**
-	 * @callback LeUtils~__setAnimationFrameIntervalCallback
-	 * @param {number} deltaTime
-	 */
 	/**
 	 * 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 {LeUtils~__setAnimationFrameIntervalCallback} callback ([number] deltaTime)
+	 * @param {(deltaTime:number) => *} callback
 	 * @param {number} [intervalFrames]
 	 * @param {boolean} [fireImmediately]
 	 * @returns {{remove:Function}}
@@ -1346,7 +1493,7 @@ export const LeUtils = {
 	 * Returns a promise, which will be resolved after the given number of milliseconds.
 	 *
 	 * @param {number} ms
-	 * @returns {Promise}
+	 * @returns {Promise<number>}
 	 */
 	promiseTimeout:
 		(ms) =>
@@ -1354,7 +1501,7 @@ export const LeUtils = {
 			ms = FLOAT_LAX(ms);
 			if(ms <= 0)
 			{
-				return new Promise(resolve => resolve(undefined));
+				return new Promise(resolve => resolve(0));
 			}
 			return new Promise(resolve => LeUtils.setTimeout(resolve, ms));
 		},
@@ -1363,7 +1510,7 @@ export const LeUtils = {
 	 * Returns a promise, which will be resolved after the given number of frames.
 	 *
 	 * @param {number} frames
-	 * @returns {Promise}
+	 * @returns {Promise<number>}
 	 */
 	promiseAnimationFrameTimeout:
 		(frames) =>
@@ -1371,7 +1518,7 @@ export const LeUtils = {
 			frames = INT_LAX(frames);
 			if(frames <= 0)
 			{
-				return new Promise(resolve => resolve(undefined));
+				return new Promise(resolve => resolve(0));
 			}
 			return new Promise(resolve => LeUtils.setAnimationFrameTimeout(resolve, frames));
 		},
@@ -1380,7 +1527,7 @@ export const LeUtils = {
 	 * Allows you to do a fetch, with built-in retry and abort functionality.
 	 *
 	 * @param {string} url
-	 * @param {Object} [options]
+	 * @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:
@@ -1466,6 +1613,68 @@ export const LeUtils = {
 			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.
@@ -1732,7 +1941,7 @@ export const LeUtils = {
 	 * - foo-bar
 	 * - foo_bar
 	 *
-	 * @param {string} names
+	 * @param {string[]} names
 	 * @returns {string[]}
 	 */
 	generateNamePermutations:
@@ -1790,7 +1999,7 @@ export const LeUtils = {
 				}
 				if(c < '9')
 				{
-					c++;
+					c = String.fromCharCode(c.charCodeAt(0) + 1);
 					string = string.substring(0, i) + c + string.substring(i + 1);// string[i] = (char + 1);
 					break;
 				}
@@ -1812,7 +2021,7 @@ export const LeUtils = {
 		(() =>
 		{
 			let previousUniqueIdsTime = null;
-			let previousUniqueIds = {};
+			let previousUniqueIds = new Map();
 			
 			const numberToBytes = (number) =>
 			{
@@ -1896,12 +2105,13 @@ export const LeUtils = {
 					if(previousUniqueIdsTime !== result.time)
 					{
 						previousUniqueIdsTime = result.time;
-						previousUniqueIds = {[result.id]:true};
+						previousUniqueIds.clear();
+						previousUniqueIds.set(result.id, true);
 						return result.id;
 					}
-					else if(previousUniqueIds[result.id] !== true)
+					else if(previousUniqueIds.get(result.id) !== true)
 					{
-						previousUniqueIds[result.id] = true;
+						previousUniqueIds.set(result.id, true);
 						return result.id;
 					}
 				}
@@ -1931,7 +2141,7 @@ export const LeUtils = {
 				return bytes;
 			};
 			
-			return (now = null) =>
+			return (/** @type {number|null|undefined} */ now = null) =>
 			{
 				if(ISSET(now))
 				{
@@ -1988,7 +2198,7 @@ export const LeUtils = {
 		{
 			part = FLOAT_LAX(part);
 			total = FLOAT_LAX(total);
-			if(total <= 0)
+			if(total === 0)
 			{
 				return 100;
 			}
@@ -2015,22 +2225,18 @@ export const LeUtils = {
 				const ctx = canvas.getContext('2d');
 				const width = Math.floor(image.width);
 				const height = Math.floor(image.height);
-				if((width <= 0) || (height <= 0))
-				{
-					canvas.width = 1;
-					canvas.height = 1;
-				}
-				else
+				if(!ctx || (width <= 0) || (height <= 0))
 				{
-					canvas.width = width;
-					canvas.height = height;
-					ctx.drawImage(image, 0, 0, canvas.width, canvas.height);
+					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);
+				canvas?.parentNode?.removeChild(canvas);
 			}
 		},
 	
@@ -2055,17 +2261,13 @@ export const LeUtils = {
 				const ctx = canvas.getContext('2d');
 				const width = Math.floor(image.width);
 				const height = Math.floor(image.height);
-				if((width <= 0) || (height <= 0))
+				if(!ctx || (width <= 0) || (height <= 0))
 				{
-					canvas.width = 1;
-					canvas.height = 1;
-				}
-				else
-				{
-					canvas.width = width;
-					canvas.height = height;
-					ctx.drawImage(image, 0, 0, canvas.width, canvas.height);
+					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);
@@ -2073,7 +2275,7 @@ export const LeUtils = {
 			}
 			finally
 			{
-				canvas.parentNode.removeChild(canvas);
+				canvas?.parentNode?.removeChild(canvas);
 			}
 		},
 	
@@ -2102,13 +2304,18 @@ export const LeUtils = {
 	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));
+			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],
@@ -2131,12 +2338,10 @@ export const LeUtils = {
 			const b = rgb[2] / 255;
 			const max = Math.max(r, g, b);
 			const min = Math.min(r, g, b);
-			let h, s, l = (max + min) / 2;
-			if(max === min)
-			{
-				h = s = 0;
-			}
-			else
+			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);
@@ -2195,12 +2400,10 @@ export const LeUtils = {
 				const h = hsl[0];
 				const s = hsl[1];
 				const l = hsl[2];
-				let r, g, b;
-				if(s === 0)
-				{
-					r = g = b = l;
-				}
-				else
+				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;
@@ -2241,13 +2444,13 @@ export const LeUtils = {
 	 *
 	 * Returns a number:
 	 *
-	 * <pre>
-	 *   < 1.0    is not perceptible by human eyes
+	 * ```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
-	 * </pre>
+	 * ```
 	 *
 	 * @param {number[]} rgbA
 	 * @param {number[]} rgbB
@@ -2266,13 +2469,13 @@ export const LeUtils = {
 	 *
 	 * Returns a number:
 	 *
-	 * <pre>
-	 *   < 1.0    is not perceptible by human eyes
+	 * ```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
-	 * </pre>
+	 * ```
 	 *
 	 * @param {number[]} labA
 	 * @param {number[]} labB
@@ -2304,16 +2507,16 @@ export const LeUtils = {
 	 *
 	 * Usage:
 	 *
-	 * <pre>
+	 * ```js
 	 * LeUtils.getRgbOfGradient({
 	 *   0:  [255, 0,   0],
 	 *   33: [255, 255, 0],
 	 *   66: [0,   255, 0],
 	 *   100:[0,   255, 255],
 	 * }, 45.1234);
-	 * </pre>
+	 * ```
 	 *
-	 * @param {{[percentage]: number[]}} gradient
+	 * @param {{percentage?:number[]}} gradient
 	 * @param {number} percentage
 	 * @returns {number[]}
 	 */
@@ -2341,12 +2544,14 @@ export const LeUtils = {
 			});
 			if(closest === null)
 			{
-				return null;
+				return [0, 0, 0];
 			}
 			closest = closest[0];
 			
-			let higher = 99999;
-			let lower = -99999;
+			const HIGHER = 99999;
+			const LOWER = -99999;
+			let higher = HIGHER;
+			let lower = LOWER;
 			LeUtils.each(gradient, (color, percent) =>
 			{
 				percent = INT_LAX(percent);
@@ -2365,20 +2570,12 @@ export const LeUtils = {
 					}
 				}
 			});
-			if(higher === 99999)
-			{
-				higher = null;
-			}
-			if(lower === -99999)
-			{
-				lower = null;
-			}
 			
-			if(((higher === null) && (lower === null)) || (higher === lower))
+			if(((higher === HIGHER) && (lower === LOWER)) || (higher === lower))
 			{
 				return gradient[closest];
 			}
-			else if((higher !== null) && (lower !== null))
+			else if((higher !== HIGHER) && (lower !== LOWER))
 			{
 				const higherDifference = Math.abs(higher - percentage);
 				const lowerDifference = Math.abs(percentage - lower);
@@ -2391,7 +2588,7 @@ export const LeUtils = {
 					lower = closest;
 				}
 			}
-			else if(lower === null)
+			else if(lower === LOWER)
 			{
 				lower = closest;
 			}
@@ -2512,7 +2709,12 @@ export const LeUtils = {
 	hexToBase64:
 		(hexstring) =>
 		{
-			return LeUtils.btoa(hexstring.replace(/[^0-9A-F]/gi, '').match(/\w{2}/g).map((a) => String.fromCharCode(parseInt(a, 16))).join(''));
+			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);
 		},
 	
 	/**
@@ -2537,7 +2739,7 @@ export const LeUtils = {
 	/**
 	 * Converts bytes into a base64 string.
 	 *
-	 * @param {ArrayLike<number>|ArrayBufferLike} arraybuffer
+	 * @param {ArrayLike<number>|ArrayBuffer} arraybuffer
 	 * @returns {string}
 	 */
 	bytesToBase64:
@@ -2594,11 +2796,7 @@ export const LeUtils = {
 			}
 			try
 			{
-				result = JSON.parse(result);
-				if(typeof result['-'] !== 'undefined')
-				{
-					return result['-'];
-				}
+				return JSON.parse(result)?.['-'];
 			}
 			catch(e)
 			{
@@ -2707,8 +2905,8 @@ export const LeUtils = {
 	 * This way, you can have values that aren't the same be treated as if they are. This can be used to deal with issues such as floating point errors for example.
 	 *
 	 * @param {*[]} elements
-	 * @param {Function} comparator
-	 * @returns {{getElements: (function(): *[]),  getComparator: (function(): Function),  size: (function(): number),  isEmpty: (function(): boolean),  contains: (function(*): boolean),  first: (function(): *|undefined),  last: (function(): *|undefined),  pollFirst: (function(): *|undefined),  pollLast: (function(): *|undefined),  add: function(*),  addAll: function(*[]|object),  getEqualValue: (function(*): (*)),  getEqualValueOrAdd: (function(*): (*))}}
+	 * @param {(valueA:*, valueB:*) => number} comparator
+	 * @returns {{getElements:(()=>*[]), getComparator:(()=>((valueA:*,valueB:*)=>number)), size:(()=>number), isEmpty:(()=>boolean), contains:((value:*)=>boolean), first:(()=>*|undefined), last:(()=>*|undefined), pollFirst:(()=>*|undefined), pollLast:(()=>*|undefined), add:((value:*)=>void), addAll:((values:*)=>void), getEqualValue:((value:*)=>*), getEqualValueOrAdd:((value:*)=>*)}}
 	 */
 	createTreeSet:
 		(elements, comparator) =>
@@ -2760,7 +2958,7 @@ export const LeUtils = {
 				/**
 				 * Returns the comparator of the set.
 				 *
-				 * @returns {Function}
+				 * @returns {(valueA:*, valueB:*) => number}
 				 */
 				getComparator:
 					() => comparator,
@@ -2841,7 +3039,7 @@ export const LeUtils = {
 				/**
 				 * Adds all the given values to the set. Will only do so if no equal value already exists.
 				 *
-				 * @param {*[]|object} values
+				 * @param {*} values
 				 */
 				addAll:
 					(values) =>
@@ -2888,7 +3086,7 @@ export const LeUtils = {
 		},
 	
 	/**
-	 * @typedef {Object} LeUtils~TransactionalValue
+	 * @typedef {Object} LeUtils_TransactionalValue
 	 * @property {*} value
 	 * @property {{id:string, value:*}[]} changes
 	 */
@@ -2901,7 +3099,7 @@ export const LeUtils = {
 	 * This allows you to make multiple unconfirmed changes, and confirm or cancel each of them individually at any time.
 	 *
 	 * @param {*} [value]
-	 * @returns {LeUtils~TransactionalValue}
+	 * @returns {LeUtils_TransactionalValue}
 	 */
 	createTransactionalValue:
 		(value) =>
@@ -2916,7 +3114,7 @@ export const LeUtils = {
 	/**
 	 * Returns true if the given value is a valid TransactionalValue, returns false if it isn't.
 	 *
-	 * @param {LeUtils~TransactionalValue} transactionalValue
+	 * @param {LeUtils_TransactionalValue} transactionalValue
 	 * @returns {boolean}
 	 */
 	isTransactionalValueValid:
@@ -2928,7 +3126,7 @@ export const LeUtils = {
 	/**
 	 * Returns true if the given value is a TransactionalValue, false otherwise.
 	 *
-	 * @param {LeUtils~TransactionalValue} transactionalValue
+	 * @param {LeUtils_TransactionalValue} transactionalValue
 	 * @returns {string}
 	 */
 	transactionalValueToString:
@@ -2953,7 +3151,7 @@ export const LeUtils = {
 	/**
 	 * Sets the committed value of the given TransactionalValue to the given value. Clears out the previously uncommitted changes.
 	 *
-	 * @param {LeUtils~TransactionalValue} transactionalValue
+	 * @param {LeUtils_TransactionalValue} transactionalValue
 	 * @param {*} value
 	 */
 	transactionSetAndCommit:
@@ -2972,7 +3170,7 @@ export const LeUtils = {
 	 * 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 {LeUtils_TransactionalValue} transactionalValue
 	 * @param {*} value
 	 * @returns {string}
 	 */
@@ -2993,7 +3191,7 @@ export const LeUtils = {
 	 * 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 {LeUtils_TransactionalValue} transactionalValue
 	 * @param {string} changeId
 	 * @returns {boolean}
 	 */
@@ -3015,7 +3213,7 @@ export const LeUtils = {
 	 * 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 {LeUtils_TransactionalValue} transactionalValue
 	 * @param {string} changeId
 	 * @returns {boolean}
 	 */
@@ -3036,7 +3234,7 @@ export const LeUtils = {
 	 * 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 {LeUtils_TransactionalValue} transactionalValue
 	 * @param {string} changeId
 	 * @returns {boolean}
 	 */
@@ -3050,7 +3248,7 @@ export const LeUtils = {
 	/**
 	 * Returns the committed value of the given TransactionalValue.
 	 *
-	 * @param {LeUtils~TransactionalValue} transactionalValue
+	 * @param {LeUtils_TransactionalValue} transactionalValue
 	 * @returns {*}
 	 */
 	transactionGetCommittedValue:
@@ -3063,7 +3261,7 @@ export const LeUtils = {
 	/**
 	 * Returns the value (including any uncommitted changes made to it) of the given TransactionalValue.
 	 *
-	 * @param {LeUtils~TransactionalValue} transactionalValue
+	 * @param {LeUtils_TransactionalValue} transactionalValue
 	 * @returns {*}
 	 */
 	transactionGetValue:
@@ -3129,7 +3327,7 @@ export const LeUtils = {
 	 * ```
 	 *
 	 * @param {string} name
-	 * @returns {{worker: Worker,  sendMessage: function(Object, {timeout: number|undefined}|undefined): Promise<Object>}}
+	 * @returns {{worker:Worker|null, sendMessage:(data:Object,options:{timeout:number|undefined}|undefined)=>Promise<Object>}}
 	 */
 	createWorkerThread:
 		(name) =>
@@ -3138,7 +3336,7 @@ export const LeUtils = {
 			{
 				return {
 					worker:     null,
-					sendMessage:new Promise((resolve, reject) =>
+					sendMessage:(data, options) => new Promise((resolve, reject) =>
 					{
 						reject('Workers are not supported in this environment');
 					}),
@@ -3146,16 +3344,16 @@ export const LeUtils = {
 			}
 			
 			const worker = new Worker('/workers/' + name + '.worker.js');
-			let listeners = {};
+			let listeners = new Map();
 			
 			const addListener = (id, callback) =>
 			{
-				listeners[id] = callback;
+				listeners.set(id, callback);
 			};
 			
 			const removeListener = (id) =>
 			{
-				delete listeners[id];
+				listeners.delete(id);
 			};
 			
 			const sendMessage = (data, options) =>
@@ -3186,7 +3384,7 @@ export const LeUtils = {
 				const data = message.data;
 				if(data?.id)
 				{
-					const callback = listeners[data.id];
+					const callback = listeners.get(data.id);
 					if(callback)
 					{
 						removeListener(data.id);
@@ -3205,20 +3403,20 @@ export const LeUtils = {
 	 *
 	 * @param {string} workerName
 	 * @param {Object} data
-	 * @param {{timeout: number|undefined}} [options]
+	 * @param {{timeout:number|undefined}} [options]
 	 * @returns {Promise<Object>}
 	 */
 	sendWorkerMessage:
 		(() =>
 		{
-			const workers = {};
+			const workers = new Map();
 			return (workerName, data, options) =>
 			{
-				if(!workers[workerName])
+				if(!workers.has(workerName))
 				{
-					workers[workerName] = LeUtils.createWorkerThread(workerName);
+					workers.set(workerName, LeUtils.createWorkerThread(workerName));
 				}
-				return workers[workerName].sendMessage(data, options);
+				return workers.get(workerName).sendMessage(data, options);
 			};
 		})(),
 	
@@ -3251,7 +3449,7 @@ export const LeUtils = {
 			return () => true;
 		}
 		const inputTypes = ['text', 'search', 'email', 'number', 'password', 'tel', 'time', 'url', 'week', 'month', 'date', 'datetime-local'];
-		return () => !((document?.activeElement?.tagName?.toLowerCase() === 'input') && inputTypes.includes(document?.activeElement?.type?.toLowerCase()));
+		return () => !((document?.activeElement?.tagName?.toLowerCase() === 'input') && inputTypes.includes(document?.activeElement?.getAttribute('type')?.toLowerCase() ?? ''));
 	})(),
 	
 	/**