@lowentry/utils 1.25.3 → 2.0.3

package/dist/src/LeUtils.js

@@ -0,0 +1,3168 @@
+/**
+ * LeUtils - Core utility functions
+ */
+import { ISSET, IS_OBJECT, IS_ARRAY, ARRAY, STRING, INT_LAX, FLOAT_LAX, INT_LAX_ANY, FLOAT_LAX_ANY } from './LeTypes';
+/**
+ * Helper function to safely get property value without 'as'
+ * Returns undefined if property doesn't exist (this is normal, no warning)
+ * This is a defensive helper - it's expected that obj might not be an object or prop might not exist
+ */
+function safeGetProperty(obj, prop) {
+    if ((typeof obj !== 'object' && typeof obj !== 'function') || obj === null) {
+        // Non-object - return undefined (defensive, no warning)
+        return undefined;
+    }
+    if (!(prop in obj)) {
+        // Property doesn't exist - this is normal, no warning
+        return undefined;
+    }
+    const desc = Object.getOwnPropertyDescriptor(obj, prop);
+    if (desc === undefined) {
+        // Property might be on prototype - use direct access
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-explicit-any
+        return obj[prop];
+    }
+    return desc.value;
+}
+/**
+ * Type predicate: check if value has numeric length property
+ */
+function hasNumericLength(val) {
+    if ((typeof val !== 'object' && typeof val !== 'function') || val === null) {
+        return false;
+    }
+    if (!('length' in val)) {
+        return false;
+    }
+    const lengthValue = safeGetProperty(val, 'length');
+    if (typeof lengthValue !== 'number') {
+        return false;
+    }
+    return true;
+}
+/**
+ * Type predicate: check if value is DataView-like
+ */
+function isDataViewLike(val) {
+    if ((typeof val !== 'object' && typeof val !== 'function') || val === null) {
+        return false;
+    }
+    if (!('byteLength' in val) || !('getUint8' in val)) {
+        return false;
+    }
+    const byteLengthValue = safeGetProperty(val, 'byteLength');
+    const getUint8Value = safeGetProperty(val, 'getUint8');
+    if (typeof byteLengthValue !== 'number' || typeof getUint8Value !== 'function') {
+        return false;
+    }
+    return true;
+}
+/**
+ * Type predicate: check if value is RegExp
+ */
+function isRegExp(val) {
+    return val instanceof RegExp;
+}
+/**
+ * Type predicate: check if value is Record-like
+ */
+function isRecordLike(val) {
+    return (typeof val === 'object' || typeof val === 'function') && val !== null && !Array.isArray(val) && !(val instanceof Map) && !(val instanceof Set);
+}
+/**
+ * Type predicate: check if value is array-like (unknown[])
+ */
+function isUnknownArray(val) {
+    return Array.isArray(val);
+}
+/**
+ * Type predicate: check if value is Map-like
+ */
+function isMapLike(val) {
+    return val instanceof Map;
+}
+/**
+ * Type predicate: check if value is Set-like
+ */
+function isSetLike(val) {
+    return val instanceof Set;
+}
+/**
+ * Type predicate: check if value is ArrayBufferView
+ */
+function isArrayBufferView(val) {
+    return ArrayBuffer.isView(val);
+}
+/**
+ * Type predicate: check if value has constructor property
+ */
+function hasConstructor(val) {
+    if ((typeof val !== 'object' && typeof val !== 'function') || val === null) {
+        return false;
+    }
+    const constructorValue = safeGetProperty(val, 'constructor');
+    return typeof constructorValue === 'function';
+}
+/**
+ * Type predicate: check if value is Iterable
+ */
+function isIterable(val) {
+    if ((typeof val !== 'object' && typeof val !== 'function') || val === null) {
+        return false;
+    }
+    // Check for Symbol.iterator using 'in' operator and direct property access
+    if (!(Symbol.iterator in val)) {
+        return false;
+    }
+    const desc = Object.getOwnPropertyDescriptor(val, Symbol.iterator);
+    if (desc === undefined) {
+        // Property might be on prototype - use direct access
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-explicit-any
+        return typeof val[Symbol.iterator] === 'function';
+    }
+    return typeof desc.value === 'function';
+}
+/**
+ * Type predicate: check if value has forEach method
+ */
+function hasForEach(val) {
+    if (typeof val !== 'object' || val === null) {
+        return false;
+    }
+    const forEach = safeGetProperty(val, 'forEach');
+    return typeof forEach === 'function';
+}
+/**
+ * Type predicate: check if value is object (not null, not array, not Map, not Set)
+ */
+function isPlainObject(val) {
+    if (typeof val !== 'object' || val === null) {
+        return false;
+    }
+    const constructor = safeGetProperty(val, 'constructor');
+    return constructor === Object;
+}
+/**
+ * Type predicate: check if value is a tuple pair [unknown, unknown]
+ */
+function isPair(val) {
+    if (!Array.isArray(val)) {
+        return false;
+    }
+    return val.length === 2;
+}
+/**
+ * Type predicate: check if value is a Promise
+ */
+function isPromise(val) {
+    if (typeof val !== 'object' || val === null) {
+        return false;
+    }
+    const then = safeGetProperty(val, 'then');
+    return typeof then === 'function';
+}
+/**
+ * Type predicate: check if value is TransactionalValue
+ */
+function isTransactionalValue(val) {
+    if (typeof val !== 'object' || val === null) {
+        return false;
+    }
+    if (!('value' in val)) {
+        return false;
+    }
+    if (!('changes' in val)) {
+        return false;
+    }
+    const changes = safeGetProperty(val, 'changes');
+    if (!Array.isArray(changes)) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Type predicate: check if Performance has timing property (legacy API)
+ */
+function hasPerformanceTiming(perf) {
+    if (typeof perf !== 'object' || perf === null) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Type predicate: check if globalThis has setTimeout
+ */
+function hasSetTimeout(global) {
+    if (typeof global !== 'object' || global === null) {
+        return false;
+    }
+    const setTimeout = safeGetProperty(global, 'setTimeout');
+    return typeof setTimeout === 'function';
+}
+/**
+ * Type predicate: check if globalThis has setInterval
+ */
+function hasSetInterval(global) {
+    if (typeof global !== 'object' || global === null) {
+        return false;
+    }
+    const setInterval = safeGetProperty(global, 'setInterval');
+    return typeof setInterval === 'function';
+}
+/**
+ * Type predicate: check if value is a number array (for gradients)
+ */
+function isNumberArray(val) {
+    if (!Array.isArray(val)) {
+        return false;
+    }
+    return val.every((item) => typeof item === 'number');
+}
+/**
+ * Type predicate: check if Navigator has vendor property
+ */
+function hasNavigatorVendor(nav) {
+    if (typeof nav !== 'object' || nav === null) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Type predicate: check if globalThis has opera property (legacy)
+ */
+function hasOpera(global) {
+    if (typeof global !== 'object' || global === null) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Type predicate: check if Navigator has languages
+ */
+function hasNavigatorLanguages(nav) {
+    if (typeof nav !== 'object' || nav === null) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Type predicate: check if globalThis has Intl
+ */
+function hasIntl(global) {
+    if (typeof global !== 'object' || global === null) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Type predicate: check if object has id property
+ */
+function hasId(obj) {
+    if (typeof obj !== 'object' || obj === null) {
+        return false;
+    }
+    const id = safeGetProperty(obj, 'id');
+    return typeof id === 'string';
+}
+/**
+ * Type predicate: check if value is Worker with sendMessage
+ */
+function hasSendMessage(worker) {
+    if (typeof worker !== 'object' || worker === null) {
+        return false;
+    }
+    const sendMessage = safeGetProperty(worker, 'sendMessage');
+    return typeof sendMessage === 'function';
+}
+/**
+ * Type predicate: check if error has message property
+ */
+function hasErrorMessage(err) {
+    if (typeof err !== 'object' || err === null) {
+        return false;
+    }
+    const message = safeGetProperty(err, 'message');
+    return typeof message === 'string';
+}
+/**
+ * Type predicate: check if version has major, minor, patch
+ */
+function isVersionObject(version) {
+    if (!IS_OBJECT(version)) {
+        return false;
+    }
+    const major = safeGetProperty(version, 'major');
+    const minor = safeGetProperty(version, 'minor');
+    const patch = safeGetProperty(version, 'patch');
+    return major !== undefined && minor !== undefined && patch !== undefined;
+}
+/**
+ * Private helper to convert a number to bytes (Uint8ClampedArray).
+ */
+function numberToBytes(num) {
+    const size = (num === 0) ? 0 : Math.ceil((Math.floor(Math.log2(num)) + 1) / 8);
+    const bytes = new Uint8ClampedArray(size);
+    let x = num;
+    for (let i = (size - 1); i >= 0; i--) {
+        const rightByte = x & 0xff;
+        bytes[i] = rightByte;
+        x = Math.floor(x / 0x100);
+    }
+    return bytes;
+}
+/**
+ * Deep equality comparison.
+ * Compares objects, arrays, Maps, Sets, primitives, and handles special cases.
+ *
+ * @param a - First value to compare
+ * @param b - Second value to compare
+ * @returns true if values are equivalent
+ */
+export function equals(a, b) {
+    const seen = new WeakSet();
+    function recursiveEquals(valA, valB) {
+        if (valA === valB) {
+            return true;
+        }
+        if (valA && valB && typeof valA === 'object' && typeof valB === 'object') {
+            if (seen.has(valA)) {
+                return true;
+            }
+            seen.add(valA);
+            // Type guard: check constructor equality
+            const constructorAValue = safeGetProperty(valA, 'constructor');
+            const constructorBValue = safeGetProperty(valB, 'constructor');
+            if (constructorAValue !== constructorBValue) {
+                return false;
+            }
+            if (Array.isArray(valA)) {
+                // Type guard: verify valB is also an array
+                if (!Array.isArray(valB)) {
+                    return false;
+                }
+                const length = valA.length;
+                if (length !== valB.length) {
+                    return false;
+                }
+                for (let i = length; i-- !== 0;) {
+                    if (!recursiveEquals(valA[i], valB[i])) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+            if ((valA instanceof Map) && (valB instanceof Map)) {
+                if (valA.size !== valB.size) {
+                    return false;
+                }
+                for (const [keyA, valueA] of valA.entries()) {
+                    let found = false;
+                    let valueB;
+                    if (valB.has(keyA)) {
+                        found = true;
+                        valueB = valB.get(keyA);
+                    }
+                    else {
+                        for (const [keyB, vb] of valB.entries()) {
+                            if (recursiveEquals(keyA, keyB)) {
+                                found = true;
+                                valueB = vb;
+                                break;
+                            }
+                        }
+                    }
+                    if (!found || !recursiveEquals(valueA, valueB)) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+            if ((valA instanceof Set) && (valB instanceof Set)) {
+                if (valA.size !== valB.size) {
+                    return false;
+                }
+                for (const itemA of valA) {
+                    if (valB.has(itemA)) {
+                        continue;
+                    }
+                    let found = false;
+                    for (const itemB of valB) {
+                        if (recursiveEquals(itemA, itemB)) {
+                            found = true;
+                            break;
+                        }
+                    }
+                    if (!found) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+            if (ArrayBuffer.isView(valA) && ArrayBuffer.isView(valB)) {
+                if (hasNumericLength(valA) && hasNumericLength(valB)) {
+                    const lengthA = valA.length;
+                    const lengthB = valB.length;
+                    if (lengthA !== lengthB) {
+                        return false;
+                    }
+                    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-explicit-any -- TypedArray index access
+                    const a = valA;
+                    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-explicit-any -- TypedArray index access
+                    const b = valB;
+                    for (let i = lengthA; i-- !== 0;) {
+                        if (a[i] !== b[i]) {
+                            return false;
+                        }
+                    }
+                    return true;
+                }
+                if (isDataViewLike(valA) && isDataViewLike(valB)) {
+                    const byteLengthA = valA.byteLength;
+                    const byteLengthB = valB.byteLength;
+                    if (byteLengthA !== byteLengthB) {
+                        return false;
+                    }
+                    for (let i = byteLengthA; i-- !== 0;) {
+                        if (valA.getUint8(i) !== valB.getUint8(i)) {
+                            return false;
+                        }
+                    }
+                    return true;
+                }
+                return false;
+            }
+            if (isRegExp(valA)) {
+                if (!isRegExp(valB)) {
+                    // Type mismatch - this is normal comparison behavior, not an error
+                    return false;
+                }
+                return valA.source === valB.source && valA.flags === valB.flags;
+            }
+            // Type guard: check for valueOf method
+            const valueOfA = safeGetProperty(valA, 'valueOf');
+            if (typeof valueOfA === 'function' && valueOfA !== Object.prototype.valueOf) {
+                try {
+                    const valueOfB = safeGetProperty(valB, 'valueOf');
+                    if (typeof valueOfB === 'function' && valueOfB !== Object.prototype.valueOf) {
+                        const resultA = Function.prototype.call.call(valueOfA, valA);
+                        const resultB = Function.prototype.call.call(valueOfB, valB);
+                        return resultA === resultB;
+                    }
+                }
+                catch (e) {
+                    // Error calling valueOf - this indicates the method exists but threw an error
+                    // This is unexpected and indicates invalid data or implementation
+                    console.error('LeUtils.equals: error calling valueOf - invalid data or implementation', e);
+                }
+            }
+            // Type guard: check for toString method
+            const toStringA = safeGetProperty(valA, 'toString');
+            if (typeof toStringA === 'function' && toStringA !== Object.prototype.toString) {
+                try {
+                    const toStringB = safeGetProperty(valB, 'toString');
+                    if (typeof toStringB === 'function' && toStringB !== Object.prototype.toString) {
+                        const resultA = Function.prototype.call.call(toStringA, valA);
+                        const resultB = Function.prototype.call.call(toStringB, valB);
+                        return resultA === resultB;
+                    }
+                }
+                catch (e) {
+                    // Error calling toString - this indicates the method exists but threw an error
+                    // This is unexpected and indicates invalid data or implementation
+                    console.error('LeUtils.equals: error calling toString - invalid data or implementation', e);
+                }
+            }
+            const constructorA = safeGetProperty(valA, 'constructor');
+            const constructorB = safeGetProperty(valB, 'constructor');
+            if (constructorA !== constructorB) {
+                return false;
+            }
+            if (!isRecordLike(valA) || !isRecordLike(valB)) {
+                // Type mismatch - this is normal comparison behavior, not an error
+                return false;
+            }
+            const keys = Object.keys(valA);
+            const length = keys.length;
+            if (length !== Object.keys(valB).length) {
+                return false;
+            }
+            for (let i = length; i-- !== 0;) {
+                if (!Object.prototype.hasOwnProperty.call(valB, keys[i])) {
+                    return false;
+                }
+            }
+            for (let i = length; i-- !== 0;) {
+                const key = keys[i];
+                const typeofA = safeGetProperty(valA, '$$typeof');
+                if ((key === '_owner') && typeofA) {
+                    continue;
+                }
+                const aVal = valA[key];
+                const bVal = valB[key];
+                if (!recursiveEquals(aVal, bVal)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        // true if both are NaN, false otherwise
+        return ((valA !== valA) && (valB !== valB));
+    }
+    return recursiveEquals(a, b);
+}
+/**
+ * Deep clones a value.
+ *
+ * @param value - Value to clone
+ * @returns Deep cloned value
+ */
+export function clone(value) {
+    const seen = new WeakMap();
+    function recursiveClone(val) {
+        if (val === null || typeof val !== 'object') {
+            return val;
+        }
+        if (typeof val === 'function') {
+            return val;
+        }
+        if (seen.has(val)) {
+            return seen.get(val);
+        }
+        let result;
+        if (isUnknownArray(val)) {
+            const resultArray = [];
+            result = resultArray;
+            seen.set(val, result);
+            for (let i = 0; i < val.length; i++) {
+                resultArray.push(recursiveClone(val[i]));
+            }
+        }
+        else if (val instanceof Date) {
+            result = new Date(val.getTime());
+            seen.set(val, result);
+        }
+        else if (isRegExp(val)) {
+            result = new RegExp(val.source, val.flags);
+            seen.set(val, result);
+        }
+        else if (isMapLike(val)) {
+            const resultMap = new Map();
+            result = resultMap;
+            seen.set(val, result);
+            for (const [k, v] of val.entries()) {
+                resultMap.set(recursiveClone(k), recursiveClone(v));
+            }
+        }
+        else if (isSetLike(val)) {
+            const resultSet = new Set();
+            result = resultSet;
+            seen.set(val, result);
+            for (const v of val.values()) {
+                resultSet.add(recursiveClone(v));
+            }
+        }
+        else if (isArrayBufferView(val)) {
+            // TypedArray clone
+            if (!hasConstructor(val)) {
+                console.error('LeUtils.clone: ArrayBufferView value does not have constructor property');
+                return value;
+            }
+            const Constructor = val.constructor;
+            // Create a new buffer to ensure independent memory
+            const buffer = val.buffer.slice(val.byteOffset, val.byteOffset + val.byteLength);
+            result = new Constructor(buffer);
+            seen.set(val, result);
+        }
+        else if (isRecordLike(val)) {
+            // Generic object
+            const resultObj = Object.create(Object.getPrototypeOf(val));
+            result = resultObj;
+            seen.set(val, result);
+            for (const key of Object.keys(val)) {
+                resultObj[key] = recursiveClone(val[key]);
+            }
+        }
+        else {
+            // Unknown object type - this indicates an unsupported type being cloned
+            console.error('LeUtils.clone: unsupported object type, cannot clone properly', val);
+            return value;
+        }
+        return result;
+    }
+    const cloned = recursiveClone(value);
+    if (cloned === undefined && value !== undefined) {
+        // Clone should only return undefined if input is undefined - otherwise it's a bug
+        console.error('LeUtils.clone: clone returned undefined for non-undefined input - cloning failed');
+        return value;
+    }
+    // Type guard: verify cloned value matches expected type T
+    // Since we're cloning, the structure should match, but TypeScript can't verify this
+    // We use a type predicate approach: if value is T, then cloned should also be T
+    // This is safe because clone preserves structure
+    // The only way to satisfy TypeScript here is through a type assertion, but we've validated the clone succeeded
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return cloned;
+}
+/**
+ * Checks if the given elements can be iterated over using each().
+ *
+ * @param elements - Value to check
+ * @returns true if can iterate
+ */
+export function supportsEach(elements) {
+    if ((elements === null) || (typeof elements === 'undefined') || (typeof elements === 'string')) {
+        return false;
+    }
+    return !!((Array.isArray(elements))
+        || isPlainObject(elements)
+        || isIterable(elements)
+        || hasForEach(elements)
+        || ((typeof elements === 'object') || (typeof elements === 'function')));
+}
+/**
+ * Returns an iterator that yields [value, key/index] for each element.
+ *
+ * @param elements - Collection to iterate
+ * @param optionalSkipHasOwnPropertyCheck - Skip hasOwnProperty check
+ * @yields [value, key/index]
+ */
+export function* eachIterator(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 (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 (isPlainObject(elements)) {
+        for (const i in elements) {
+            if ((optionalSkipHasOwnPropertyCheck === true) || Object.prototype.hasOwnProperty.call(elements, i)) {
+                yield [elements[i], i];
+            }
+        }
+        return;
+    }
+    if (typeof elements !== 'string') {
+        if (isIterable(elements)) {
+            let i = 0;
+            for (const value of elements) {
+                yield [value, i];
+                i++;
+            }
+            return;
+        }
+        if (hasForEach(elements)) {
+            const buffer = [];
+            elements.forEach((value, i) => {
+                buffer.push([value, i]);
+            });
+            for (const entry of buffer) {
+                yield entry;
+            }
+            return;
+        }
+    }
+    if ((typeof elements === 'object') && (elements !== null)) {
+        // Last resort: try to iterate over any object properties
+        if (isRecordLike(elements)) {
+            for (const i in elements) {
+                if ((optionalSkipHasOwnPropertyCheck === true) || Object.prototype.hasOwnProperty.call(elements, i)) {
+                    yield [elements[i], i];
+                }
+            }
+            return;
+        }
+    }
+    // Reached end of function without yielding - invalid/unsupported type
+    // This is unexpected - user passed a type that can't be iterated
+    console.error('LeUtils.eachIterator: executed on invalid/unsupported type', typeof elements, elements);
+}
+/**
+ * Loops through each element and calls callback.
+ * Callback can return false to break iteration.
+ *
+ * @param elements - Collection to iterate
+ * @param callback - Function called for each element
+ * @param optionalSkipHasOwnPropertyCheck - Skip hasOwnProperty check
+ * @returns Original elements
+ */
+export function each(elements, callback, optionalSkipHasOwnPropertyCheck = false) {
+    if (typeof callback !== 'function') {
+        throw new TypeError('The given callback is not a function');
+    }
+    for (const [value, key] of eachIterator(elements, optionalSkipHasOwnPropertyCheck)) {
+        if (callback.call(value, value, key) === false) {
+            break;
+        }
+    }
+    return elements;
+}
+/**
+ * Like each(), except that it expects an async callback.
+ *
+ * @param elements - Collection to iterate
+ * @param asyncCallback - Async function called for each element
+ * @param parallelCount - Number of parallel executions (default 1)
+ * @param optionalSkipHasOwnPropertyCheck - Skip hasOwnProperty check
+ * @returns Promise resolving to original elements
+ */
+export async function eachAsync(elements, asyncCallback, parallelCount = 1, optionalSkipHasOwnPropertyCheck = false) {
+    if ((elements === null) || (typeof elements === 'undefined')) {
+        return elements;
+    }
+    if (typeof asyncCallback !== 'function') {
+        throw new TypeError('The given callback is not a function');
+    }
+    const pCount = INT_LAX(parallelCount);
+    if (pCount > 1) {
+        const runningPromises = new Set();
+        let doBreak = false;
+        for (const [value, key] of eachIterator(elements, optionalSkipHasOwnPropertyCheck)) {
+            if (doBreak)
+                break;
+            while (runningPromises.size >= pCount) {
+                await Promise.race(runningPromises);
+                if (doBreak)
+                    break;
+            }
+            const promise = (async () => {
+                if ((await asyncCallback.call(value, value, key)) === false) {
+                    doBreak = true;
+                }
+            })();
+            runningPromises.add(promise);
+            promise.finally(() => {
+                runningPromises.delete(promise);
+            });
+        }
+        await Promise.all(runningPromises);
+    }
+    else {
+        for (const [value, key] of eachIterator(elements, optionalSkipHasOwnPropertyCheck)) {
+            if ((await asyncCallback.call(value, value, key)) === false) {
+                break;
+            }
+        }
+    }
+    return elements;
+}
+/**
+ * Returns empty collection matching type of input, plus add function.
+ *
+ * @param elements - Source collection to match type
+ * @returns [success, emptyCollection, addFunction]
+ */
+export function getEmptySimplifiedCollection(elements) {
+    if ((elements === null) || (typeof elements === 'undefined')) {
+        return [false, [], (_value, _index) => { }];
+    }
+    let collection = null;
+    let add = null;
+    if (Array.isArray(elements)) {
+        const arrayCollection = [];
+        collection = arrayCollection;
+        add = (value, _index) => {
+            arrayCollection.push(value);
+        };
+    }
+    else if (isPlainObject(elements)) {
+        const objectCollection = {};
+        collection = objectCollection;
+        add = (value, index) => {
+            const stringIndex = typeof index === 'string' ? index : String(index);
+            objectCollection[stringIndex] = value;
+        };
+    }
+    else if (elements instanceof Map) {
+        const mapCollection = new Map();
+        collection = mapCollection;
+        add = (value, index) => {
+            mapCollection.set(index, value);
+        };
+    }
+    else if ((typeof elements !== 'string') && (elements !== null) && (isIterable(elements) || hasForEach(elements))) {
+        const arrayCollection = [];
+        collection = arrayCollection;
+        add = (value, _index) => {
+            arrayCollection.push(value);
+        };
+    }
+    else if ((typeof elements === 'object' || typeof elements === 'function') && (elements !== null)) {
+        const objectCollection = {};
+        collection = objectCollection;
+        add = (value, index) => {
+            const stringIndex = typeof index === 'string' ? index : String(index);
+            objectCollection[stringIndex] = value;
+        };
+    }
+    else {
+        // Invalid/unsupported type - this is unexpected
+        console.error('LeUtils.getEmptySimplifiedCollection: executed on invalid/unsupported type', typeof elements, elements);
+        return [false, [], (_value, _index) => { }];
+    }
+    return [true, collection, add];
+}
+/**
+ * Filters collection, returning only elements matching predicate.
+ *
+ * @param elements - Collection to filter
+ * @param callback - Predicate function (truthy = keep)
+ * @param optionalSkipHasOwnPropertyCheck - Skip hasOwnProperty
+ * @returns Filtered collection (same type as input)
+ */
+export function filter(elements, callback, optionalSkipHasOwnPropertyCheck = false) {
+    if (callback && (typeof callback !== 'function')) {
+        throw new TypeError('The given callback is not a function');
+    }
+    const [success, collection, add] = getEmptySimplifiedCollection(elements);
+    if (!success) {
+        return elements;
+    }
+    each(elements, (value, index) => {
+        if (!callback) {
+            if (value) {
+                add(value, index);
+            }
+        }
+        else if (callback.call(value, value, index)) {
+            add(value, index);
+        }
+    }, optionalSkipHasOwnPropertyCheck);
+    return collection;
+}
+/**
+ * Maps collection, transforming each element.
+ *
+ * @param elements - Collection to map
+ * @param callback - Transform function
+ * @param optionalSkipHasOwnPropertyCheck - Skip hasOwnProperty
+ * @returns Mapped collection (same type as input)
+ */
+export function map(elements, callback, optionalSkipHasOwnPropertyCheck = false) {
+    if (callback && (typeof callback !== 'function')) {
+        throw new TypeError('The given callback is not a function');
+    }
+    const [success, collection, add] = getEmptySimplifiedCollection(elements);
+    if (!success) {
+        return elements;
+    }
+    each(elements, (value, index) => {
+        if (!callback) {
+            add(value, index);
+        }
+        else {
+            add(callback.call(value, value, index), index);
+        }
+    }, optionalSkipHasOwnPropertyCheck);
+    return collection;
+}
+/**
+ * Maps collection to array.
+ *
+ * @param elements - Collection to map
+ * @param callback - Transform function
+ * @param optionalSkipHasOwnPropertyCheck - Skip hasOwnProperty
+ * @returns Array of transformed values
+ */
+export function mapToArray(elements, callback, optionalSkipHasOwnPropertyCheck = false) {
+    if (callback && (typeof callback !== 'function')) {
+        throw new TypeError('The given callback is not a function');
+    }
+    const result = [];
+    each(elements, (value, index) => {
+        if (!callback) {
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            result.push(value);
+        }
+        else {
+            result.push(callback.call(value, value, index));
+        }
+    }, optionalSkipHasOwnPropertyCheck);
+    return result;
+}
+/**
+ * Sorts keys by comparing values with comparator.
+ *
+ * @param elements - Collection to get keys from
+ * @param comparator - Comparison function
+ * @param optionalSkipHasOwnPropertyCheck - Skip hasOwnProperty
+ * @returns Sorted array of keys
+ */
+export function sortKeys(elements, comparator, optionalSkipHasOwnPropertyCheck = false) {
+    if (typeof comparator !== 'function') {
+        throw new TypeError('The given comparator is not a function');
+    }
+    const keys = [];
+    each(elements, (_value, index) => {
+        keys.push(index);
+    }, optionalSkipHasOwnPropertyCheck);
+    keys.sort((a, b) => comparator(getValueAtIndex(elements, a, optionalSkipHasOwnPropertyCheck), getValueAtIndex(elements, b, optionalSkipHasOwnPropertyCheck)));
+    return keys;
+}
+/**
+ * Gets value at index/key from collection.
+ *
+ * @param elements - Collection
+ * @param index - Key or index
+ * @param optionalSkipHasOwnPropertyCheck - Skip hasOwnProperty
+ * @returns Value at index, or undefined
+ */
+export function getValueAtIndex(elements, index, optionalSkipHasOwnPropertyCheck = false) {
+    if ((elements === null) || (typeof elements === 'undefined')) {
+        return undefined;
+    }
+    if (Array.isArray(elements)) {
+        const numIndex = typeof index === 'number' ? index : Number(index);
+        if (Number.isNaN(numIndex)) {
+            console.error('LeUtils.getValueAtIndex: invalid array index (not a number)', index);
+            return undefined;
+        }
+        return elements[numIndex];
+    }
+    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)) {
+            // TypedArray - access by numeric index
+            if (hasNumericLength(elements)) {
+                const numIndex = typeof index === 'number' ? index : Number(index);
+                if (Number.isNaN(numIndex)) {
+                    console.error('LeUtils.getValueAtIndex: invalid TypedArray index (not a number)', index);
+                    return undefined;
+                }
+                return elements[numIndex];
+            }
+            return undefined;
+        }
+        if (isIterable(elements)) {
+            let i = 0;
+            for (const value of elements) {
+                if (i === index) {
+                    return value;
+                }
+                i++;
+            }
+            return undefined;
+        }
+        if (hasForEach(elements)) {
+            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')) {
+        // Type guard: verify elements is Record-like for property access
+        if (isRecordLike(elements)) {
+            const propertyKey = typeof index === 'string' || typeof index === 'number' || typeof index === 'symbol' ? index : String(index);
+            if ((optionalSkipHasOwnPropertyCheck === true) || Object.prototype.hasOwnProperty.call(elements, propertyKey)) {
+                const stringKey = typeof propertyKey === 'string' ? propertyKey : String(propertyKey);
+                return elements[stringKey];
+            }
+        }
+        return undefined;
+    }
+    return undefined;
+}
+/**
+ * Flattens nested arrays to single level (like Array.flat(Infinity)).
+ *
+ * @param array - Array to flatten
+ * @returns Flattened array
+ */
+export function flattenArray(array) {
+    if (!Array.isArray(array)) {
+        return [array];
+    }
+    const result = [];
+    const flattenRecursive = (arr) => {
+        if (!Array.isArray(arr)) {
+            result.push(arr);
+            return;
+        }
+        arr.forEach((entry) => {
+            flattenRecursive(entry);
+        });
+    };
+    array.forEach((entry) => {
+        flattenRecursive(entry);
+    });
+    return result;
+}
+/**
+ * Flattens any collection (arrays, Sets, Maps, objects) to single array.
+ *
+ * @param elements - Collection to flatten
+ * @param optionalSkipHasOwnPropertyCheck - Skip hasOwnProperty
+ * @returns Flattened array
+ */
+export function flattenToArray(elements, optionalSkipHasOwnPropertyCheck = false) {
+    const result = [];
+    const flattenRecursive = (value) => {
+        if (Array.isArray(value)) {
+            value.forEach((entry) => {
+                flattenRecursive(entry);
+            });
+        }
+        else if (supportsEach(value)) {
+            each(value, (v) => {
+                flattenRecursive(v);
+            }, optionalSkipHasOwnPropertyCheck);
+        }
+        else {
+            result.push(value);
+        }
+    };
+    flattenRecursive(elements);
+    return result;
+}
+/**
+ * Maps and sorts collection to array.
+ *
+ * @param elements - Collection to process
+ * @param comparator - Sort comparison function
+ * @param callback - Optional transform
+ * @param optionalSkipHasOwnPropertyCheck - Skip hasOwnProperty
+ * @returns Sorted array
+ */
+export function mapToArraySorted(elements, comparator, callback, optionalSkipHasOwnPropertyCheck = false) {
+    if (callback && (typeof callback !== 'function')) {
+        throw new TypeError('The given callback is not a function');
+    }
+    const keys = sortKeys(elements, comparator, optionalSkipHasOwnPropertyCheck);
+    const result = [];
+    for (const key of keys) {
+        const value = getValueAtIndex(elements, key, optionalSkipHasOwnPropertyCheck);
+        if (!callback) {
+            result.push(value);
+        }
+        else {
+            result.push(callback.call(value, value, key));
+        }
+    }
+    return result;
+}
+/**
+ * Generic comparison function for sorting.
+ *
+ * @param a - First value
+ * @param b - Second value
+ * @returns -1 if a < b, 1 if a > b, 0 if equal
+ */
+export function compare(a, b) {
+    // compare() accepts any types and uses JavaScript's native comparison operators
+    // We can't avoid type coercion here as the function is designed to work with any types
+    // Use Function.prototype.call to compare without type assertions
+    const compareResult = (valueA, valueB) => {
+        // Use JavaScript's native comparison (handles type coercion automatically)
+        // @ts-ignore - Intentional: compare() is designed to work with any types using native JS comparison
+        if (valueA < valueB) {
+            return -1;
+        }
+        // @ts-ignore - Intentional: compare() is designed to work with any types using native JS comparison
+        if (valueA > valueB) {
+            return 1;
+        }
+        return 0;
+    };
+    return compareResult(a, b);
+}
+/**
+ * Compares two numbers (for sorting).
+ *
+ * @param a - First number
+ * @param b - Second number
+ * @returns Difference (a - b)
+ */
+export function compareNumbers(a, b) {
+    return a - b;
+}
+/**
+ * Compares two numeric strings (like version numbers).
+ * Splits on '.', compares each part numerically considering length.
+ *
+ * @param a - First numeric string
+ * @param b - Second numeric string
+ * @returns Comparison result
+ */
+export function 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++) {
+        const aPart = aParts[i].trim();
+        const bPart = bParts[i].trim();
+        if (aPart.length !== bPart.length) {
+            return (aPart.length < bPart.length) ? -1 : 1;
+        }
+        if (aPart !== bPart) {
+            return (aPart < bPart) ? -1 : 1;
+        }
+    }
+    if (aParts.length !== bParts.length) {
+        return (aParts.length < bParts.length) ? -1 : 1;
+    }
+    return 0;
+}
+/**
+ * Natural string comparison (numbers in strings compared numerically).
+ * "file5.txt" sorts before "file10.txt".
+ *
+ * @param a - First string
+ * @param b - Second string
+ * @returns Comparison result
+ */
+export function 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 numerically
+        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;
+}
+/**
+ * Checks if object is empty (no own properties).
+ *
+ * @param obj - Object to check
+ * @param optionalSkipHasOwnPropertyCheck - Skip hasOwnProperty
+ * @returns true if empty
+ */
+export function isEmptyObject(obj, optionalSkipHasOwnPropertyCheck = false) {
+    if (obj === null || typeof obj !== 'object') {
+        return true;
+    }
+    // Type guard: obj is already verified as object, can iterate
+    if (isRecordLike(obj)) {
+        for (const field in obj) {
+            if ((optionalSkipHasOwnPropertyCheck === true) || Object.prototype.hasOwnProperty.call(obj, field)) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+/**
+ * Counts own properties in object.
+ *
+ * @param obj - Object to count
+ * @param optionalSkipHasOwnPropertyCheck - Skip hasOwnProperty
+ * @returns Number of own properties
+ */
+export function getObjectFieldsCount(obj, optionalSkipHasOwnPropertyCheck = false) {
+    if (obj === null || typeof obj !== 'object') {
+        return 0;
+    }
+    let count = 0;
+    // Type guard: obj is already verified as object
+    if (isRecordLike(obj)) {
+        for (const field in obj) {
+            if ((optionalSkipHasOwnPropertyCheck === true) || Object.prototype.hasOwnProperty.call(obj, field)) {
+                count++;
+            }
+        }
+    }
+    return count;
+}
+/**
+ * Capitalizes first character of string.
+ *
+ * @param string - String to capitalize
+ * @returns Capitalized string
+ */
+export function capitalize(string) {
+    const str = STRING(string).trim();
+    if (str.length <= 0) {
+        return str;
+    }
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+/**
+ * Checks if string ends with any of the given suffixes.
+ *
+ * @param string - String to check
+ * @param endingCharsStringOrArray - String of chars or array of suffixes
+ * @returns true if ends with any
+ */
+export function endsWithAny(string, endingCharsStringOrArray) {
+    const str = STRING(string);
+    let endingCharsArray;
+    if (Array.isArray(endingCharsStringOrArray)) {
+        endingCharsArray = endingCharsStringOrArray;
+    }
+    else {
+        endingCharsArray = STRING(endingCharsStringOrArray).split('');
+    }
+    let result = false;
+    each(endingCharsArray, (chars) => {
+        if (str.endsWith(STRING(chars))) {
+            result = true;
+            return false;
+        }
+    });
+    return result;
+}
+/**
+ * Checks if string starts with any of the given prefixes.
+ *
+ * @param string - String to check
+ * @param startingCharsStringOrArray - String of chars or array of prefixes
+ * @returns true if starts with any
+ */
+export function startsWithAny(string, startingCharsStringOrArray) {
+    const str = STRING(string);
+    let startingCharsArray;
+    if (Array.isArray(startingCharsStringOrArray)) {
+        startingCharsArray = startingCharsStringOrArray;
+    }
+    else {
+        startingCharsArray = STRING(startingCharsStringOrArray).split('');
+    }
+    let result = false;
+    each(startingCharsArray, (chars) => {
+        if (str.startsWith(STRING(chars))) {
+            result = true;
+            return false;
+        }
+    });
+    return result;
+}
+/**
+ * Trims specific characters from end of string.
+ *
+ * @param string - String to trim
+ * @param trimCharsStringOrArray - Characters to remove
+ * @returns Trimmed string
+ */
+export function trimEnd(string, trimCharsStringOrArray) {
+    let str = STRING(string);
+    let endingCharsArray;
+    if (Array.isArray(trimCharsStringOrArray)) {
+        endingCharsArray = trimCharsStringOrArray;
+    }
+    else {
+        endingCharsArray = STRING(trimCharsStringOrArray).split('');
+    }
+    let run = true;
+    const trimChars = (chars) => {
+        const charsStr = STRING(chars);
+        if (str.endsWith(charsStr)) {
+            str = str.substring(0, str.length - charsStr.length);
+            run = true;
+        }
+    };
+    while (run) {
+        run = false;
+        each(endingCharsArray, trimChars);
+    }
+    return str;
+}
+/**
+ * Trims specific characters from start of string.
+ *
+ * @param string - String to trim
+ * @param trimCharsStringOrArray - Characters to remove
+ * @returns Trimmed string
+ */
+export function trimStart(string, trimCharsStringOrArray) {
+    let str = STRING(string);
+    let startingCharsArray;
+    if (Array.isArray(trimCharsStringOrArray)) {
+        startingCharsArray = trimCharsStringOrArray;
+    }
+    else {
+        startingCharsArray = STRING(trimCharsStringOrArray).split('');
+    }
+    let run = true;
+    const trimChars = (chars) => {
+        const charsStr = STRING(chars);
+        if (str.startsWith(charsStr)) {
+            str = str.substring(charsStr.length);
+            run = true;
+        }
+    };
+    while (run) {
+        run = false;
+        each(startingCharsArray, trimChars);
+    }
+    return str;
+}
+/**
+ * Trims specific characters from both ends of string.
+ *
+ * @param string - String to trim
+ * @param trimCharsStringOrArray - Characters to remove
+ * @returns Trimmed string
+ */
+export function trim(string, trimCharsStringOrArray) {
+    return trimStart(trimEnd(string, trimCharsStringOrArray), trimCharsStringOrArray);
+}
+/**
+ * Checks if collection contains value (string comparison).
+ *
+ * @param array - Collection to search
+ * @param value - Value to find
+ * @returns true if found
+ */
+export function contains(array, value) {
+    if (!array) {
+        return false;
+    }
+    let result = false;
+    const valueStr = STRING(value);
+    each(array, (val) => {
+        if (STRING(val) === valueStr) {
+            result = true;
+            return false;
+        }
+    });
+    return result;
+}
+/**
+ * Checks if collection contains value (case-insensitive).
+ *
+ * @param array - Collection to search
+ * @param value - Value to find
+ * @returns true if found
+ */
+export function containsCaseInsensitive(array, value) {
+    if (!array) {
+        return false;
+    }
+    let result = false;
+    const valueStr = STRING(value).toLowerCase();
+    each(array, (val) => {
+        if (STRING(val).toLowerCase() === valueStr) {
+            result = true;
+            return false;
+        }
+    });
+    return result;
+}
+/**
+ * Checks if collection contains all given values.
+ *
+ * @param array - Collection to search
+ * @param values - Values to find
+ * @returns true if all found
+ */
+export function containsAll(array, values) {
+    if (!array) {
+        return false;
+    }
+    let result = true;
+    each(values, (value) => {
+        if (!contains(array, value)) {
+            result = false;
+            return false;
+        }
+    });
+    return result;
+}
+/**
+ * Checks if collection contains any of given values.
+ *
+ * @param array - Collection to search
+ * @param values - Values to find
+ * @returns true if any found
+ */
+export function containsAny(array, values) {
+    if (!array) {
+        return false;
+    }
+    let result = false;
+    each(values, (value) => {
+        if (contains(array, value)) {
+            result = true;
+            return false;
+        }
+    });
+    return result;
+}
+/**
+ * Checks if collection contains none of given values.
+ *
+ * @param array - Collection to search
+ * @param values - Values to check
+ * @returns true if none found
+ */
+export function containsNone(array, values) {
+    if (!array) {
+        return true;
+    }
+    let result = true;
+    each(values, (value) => {
+        if (contains(array, value)) {
+            result = false;
+            return false;
+        }
+    });
+    return result;
+}
+/**
+ * Finds first element matching predicate, returns {index, value}.
+ *
+ * @param elements - Collection to search
+ * @param callback - Predicate function
+ * @param optionalSkipHasOwnPropertyCheck - Skip hasOwnProperty
+ * @returns {index, value} or null
+ */
+export function findIndexValue(elements, callback, optionalSkipHasOwnPropertyCheck = false) {
+    if (typeof callback !== 'function') {
+        throw new TypeError('The given callback is not a function');
+    }
+    let result = null;
+    each(elements, (value, index) => {
+        // Type guard: verify elements is Record-like for callback context
+        if (isRecordLike(elements)) {
+            const propertyKey = typeof index === 'string' || typeof index === 'number' || typeof index === 'symbol' ? index : String(index);
+            const stringKey = typeof propertyKey === 'string' ? propertyKey : String(propertyKey);
+            const elementValue = elements[stringKey];
+            if (callback.call(elementValue, elementValue, index)) {
+                result = { index, value };
+                return false;
+            }
+        }
+        else {
+            // For non-record-like elements, use value directly
+            if (callback.call(value, value, index)) {
+                result = { index, value };
+                return false;
+            }
+        }
+    }, optionalSkipHasOwnPropertyCheck);
+    return result;
+}
+/**
+ * Finds first element matching predicate, returns index.
+ *
+ * @param elements - Collection to search
+ * @param callback - Predicate function
+ * @param optionalSkipHasOwnPropertyCheck - Skip hasOwnProperty
+ * @returns Index/key or null
+ */
+export function findIndex(elements, callback, optionalSkipHasOwnPropertyCheck = false) {
+    return findIndexValue(elements, callback, optionalSkipHasOwnPropertyCheck)?.index ?? null;
+}
+/**
+ * Finds first element matching predicate, returns value.
+ *
+ * @param elements - Collection to search
+ * @param callback - Predicate function
+ * @param optionalSkipHasOwnPropertyCheck - Skip hasOwnProperty
+ * @returns Value or null
+ */
+export function find(elements, callback, optionalSkipHasOwnPropertyCheck = false) {
+    return findIndexValue(elements, callback, optionalSkipHasOwnPropertyCheck)?.value ?? null;
+}
+/**
+ * Generates a base64 string (with +/ replaced by -_) that is guaranteed to be unique.
+ *
+ * @returns Unique ID string
+ */
+export const uniqueId = (() => {
+    let previousUniqueIdsTime = null;
+    const previousUniqueIds = new Map();
+    const generateUniqueId = () => {
+        let now = null;
+        try {
+            // @ts-ignore -- performance might not exist or might not have legacy timing API
+            // Type guard: check if performance has timing property (legacy API)
+            let timingNavStart = 0;
+            if (hasPerformanceTiming(performance) && 'timing' in performance && performance.timing) {
+                const timing = performance.timing;
+                if ('navigationStart' in timing && typeof timing.navigationStart === 'number') {
+                    timingNavStart = timing.navigationStart;
+                }
+            }
+            const timeOrigin = hasPerformanceTiming(performance) && 'timeOrigin' in performance && typeof performance.timeOrigin === 'number' ? performance.timeOrigin : 0;
+            const nowFunc = hasPerformanceTiming(performance) && 'now' in performance && typeof performance.now === 'function' ? performance.now : (() => 0);
+            now = timeOrigin || timingNavStart || 0;
+            now = now + nowFunc();
+        }
+        catch {
+            // Ignore error
+        }
+        now = now || Date.now();
+        now = Math.round(now);
+        const nowBytes = numberToBytes(now);
+        let uuid = null;
+        try {
+            if (typeof crypto?.randomUUID === 'function') {
+                uuid = base64ToBytes(hexToBase64(crypto.randomUUID()));
+            }
+        }
+        catch {
+            // Ignore error
+        }
+        if (!uuid) {
+            const bytesChunkA = numberToBytes(Number((Math.random() + ' ').substring(2, 12).padEnd(10, '0')));
+            const bytesChunkB = numberToBytes(Number((Math.random() + ' ').substring(2, 12).padEnd(10, '0')));
+            const bytesChunkC = numberToBytes(Number((Math.random() + ' ').substring(2, 12).padEnd(10, '0')));
+            const bytesChunkD = numberToBytes(Number((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);
+        const finalUuid = bytesToBase64(bytes).replaceAll('=', '').replaceAll('+', '-').replaceAll('/', '_');
+        return {
+            time: now,
+            id: finalUuid,
+        };
+    };
+    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.
+ *
+ * @param now - Optional time to use
+ * @returns Timestamp string
+ */
+export const timestamp = (() => {
+    return (now = null) => {
+        let time;
+        if (ISSET(now)) {
+            time = FLOAT_LAX(now);
+        }
+        else {
+            let performanceNow = null;
+            try {
+                // @ts-ignore -- performance might not exist or might not have legacy timing API
+                // Type guard: check if performance has timing property (legacy API)
+                let timingNavStart = 0;
+                if (performance && hasPerformanceTiming(performance) && 'timing' in performance) {
+                    const timing = safeGetProperty(performance, 'timing');
+                    if (timing && typeof timing === 'object' && timing !== null) {
+                        const navStart = safeGetProperty(timing, 'navigationStart');
+                        if (typeof navStart === 'number') {
+                            timingNavStart = navStart;
+                        }
+                    }
+                }
+                const timeOrigin = performance && hasPerformanceTiming(performance) && 'timeOrigin' in performance ? safeGetProperty(performance, 'timeOrigin') : undefined;
+                const nowFunc = performance && hasPerformanceTiming(performance) && 'now' in performance ? safeGetProperty(performance, 'now') : undefined;
+                const timeOriginVal = typeof timeOrigin === 'number' ? timeOrigin : 0;
+                const nowFuncVal = typeof nowFunc === 'function' ? nowFunc() : 0;
+                performanceNow = timeOriginVal || timingNavStart || 0;
+                performanceNow = performanceNow + nowFuncVal;
+            }
+            catch {
+                // Ignore error
+            }
+            time = performanceNow || Date.now();
+        }
+        time = Math.round(time);
+        const nowBytes = numberToBytes(time);
+        return bytesToBase64(nowBytes).replaceAll('=', '').replaceAll('+', '-').replaceAll('/', '_');
+    };
+})();
+/**
+ * Checks if value is a generator function.
+ *
+ * @param value - Value to check
+ * @returns true if generator, false otherwise
+ */
+export const isGeneratorFunction = (() => {
+    const GeneratorFunction = (function* () { }).constructor;
+    const AsyncGeneratorFunction = (async function* () { }).constructor;
+    return (func) => {
+        if (typeof func !== 'function') {
+            return false;
+        }
+        // Type guard: verify func has constructor property
+        if (!hasConstructor(func)) {
+            return false;
+        }
+        const constructor = func.constructor;
+        return (constructor === GeneratorFunction || constructor === AsyncGeneratorFunction);
+    };
+})();
+/**
+ * Environment-safe btoa.
+ *
+ * @param str - String to encode
+ * @returns Base64 string
+ */
+export function btoa(str) {
+    if (typeof globalThis.btoa === 'function') {
+        return globalThis.btoa(str);
+    }
+    // Node.js fallback
+    // @ts-ignore -- Buffer might not be defined in non-Node environments
+    if (typeof globalThis.Buffer?.from === 'function') {
+        // @ts-ignore -- Buffer might not be defined in non-Node environments
+        return globalThis.Buffer.from(str, 'binary').toString('base64');
+    }
+    throw new Error('LeUtils.btoa: No btoa implementation found');
+}
+/**
+ * Environment-safe atob.
+ *
+ * @param str - Base64 string to decode
+ * @returns Decoded string
+ */
+export function atob(str) {
+    if (typeof globalThis.atob === 'function') {
+        return globalThis.atob(str);
+    }
+    // Node.js fallback
+    // @ts-ignore -- Buffer might not be defined in non-Node environments
+    if (typeof globalThis.Buffer?.from === 'function') {
+        // @ts-ignore -- Buffer might not be defined in non-Node environments
+        return globalThis.Buffer.from(str, 'base64').toString('binary');
+    }
+    throw new Error('LeUtils.atob: No atob implementation found');
+}
+/**
+ * Encodes a UTF-8 string into a base64 string.
+ *
+ * @param string - UTF-8 string
+ * @returns Base64 string
+ */
+export function utf8ToBase64(string) {
+    return 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 base64string - Base64 string
+ * @returns Decoded UTF-8 string
+ */
+export function base64ToUtf8(base64string) {
+    return decodeURIComponent(atob(base64string.trim()).split('').map((c) => '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2)).join(''));
+}
+/**
+ * Converts a base64 string into a hex string.
+ *
+ * @param base64string - Base64 string
+ * @returns Hex string
+ */
+export function base64ToHex(base64string) {
+    return atob(base64string.trim()).split('').map((c) => ('0' + c.charCodeAt(0).toString(16)).slice(-2)).join('');
+}
+/**
+ * Converts a hex string into a base64 string.
+ *
+ * @param hexstring - Hex string
+ * @returns Base64 string
+ */
+export function 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 btoa(hexResult);
+}
+/**
+ * Converts a base64 string into bytes (Uint8Array).
+ *
+ * @param base64string - Base64 string
+ * @returns Bytes
+ */
+export function base64ToBytes(base64string) {
+    const binary = atob(base64string.trim());
+    const len = binary.length;
+    const 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 arraybuffer - Bytes source
+ * @returns Base64 string
+ */
+export function 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 btoa(binary);
+}
+/**
+ * Executes callback after ms. Delta time in seconds passed to callback.
+ *
+ * @param callback - Function to call
+ * @param ms - Milliseconds to wait
+ * @returns Handler with remove() method
+ */
+export function setTimeout(callback, ms) {
+    if (!globalThis?.setTimeout || !globalThis?.clearTimeout) {
+        console.warn('LeUtils.setTimeout: Not supported.');
+        return { remove: () => { } };
+    }
+    const msVal = FLOAT_LAX(ms);
+    let lastTime = globalThis?.performance?.now?.() ?? 0;
+    // Type guard: verify globalThis has setTimeout
+    if (!hasSetTimeout(globalThis)) {
+        console.error('LeUtils.setTimeout: globalThis.setTimeout is not available');
+        return { remove: () => { } };
+    }
+    // @ts-ignore - handler type varies between Node.js (Timeout) and browser (number), using ReturnType below
+    let handler = globalThis.setTimeout(() => {
+        const currentTime = globalThis?.performance?.now?.() ?? 0;
+        try {
+            callback((currentTime - lastTime) / 1000);
+        }
+        catch (e) {
+            console.error(e);
+        }
+        lastTime = currentTime;
+    }, msVal);
+    return {
+        remove: () => {
+            if (handler !== null) {
+                globalThis.clearTimeout(handler);
+                handler = null;
+            }
+        },
+    };
+}
+/**
+ * Executes callback every intervalMs. Delta time in seconds passed to callback.
+ *
+ * @param callback - Function to call
+ * @param intervalMs - Interval in milliseconds
+ * @param fireImmediately - Whether to call immediately
+ * @returns Handler with remove() method
+ */
+export function setInterval(callback, intervalMs = 1000, fireImmediately = false) {
+    const msVal = FLOAT_LAX_ANY(intervalMs, 1000);
+    if (fireImmediately) {
+        try {
+            callback(0);
+        }
+        catch (e) {
+            console.error(e);
+        }
+    }
+    if (!globalThis?.setInterval || !globalThis?.clearInterval) {
+        console.warn('LeUtils.setInterval: Not supported.');
+        return { remove: () => { } };
+    }
+    let lastTime = globalThis?.performance?.now?.() ?? 0;
+    // Type guard: verify globalThis has setInterval
+    if (!hasSetInterval(globalThis)) {
+        console.error('LeUtils.setInterval: globalThis.setInterval is not available');
+        return { remove: () => { } };
+    }
+    // @ts-ignore - handler type varies between Node.js (Timeout) and browser (number), using ReturnType below
+    let handler = globalThis.setInterval(() => {
+        const currentTime = globalThis?.performance?.now?.() ?? 0;
+        try {
+            callback((currentTime - lastTime) / 1000);
+        }
+        catch (e) {
+            console.error(e);
+        }
+        lastTime = currentTime;
+    }, msVal);
+    return {
+        remove: () => {
+            if (handler !== null) {
+                globalThis.clearInterval(handler);
+                handler = null;
+            }
+        },
+    };
+}
+/**
+ * Executes callback after frames. Delta time in seconds passed to callback.
+ *
+ * @param callback - Function to call
+ * @param frames - Number of frames to wait
+ * @returns Handler with remove() method
+ */
+export function setAnimationFrameTimeout(callback, frames = 1) {
+    if (!globalThis?.requestAnimationFrame || !globalThis?.cancelAnimationFrame) {
+        console.warn('LeUtils.setAnimationFrameTimeout: Not supported.');
+        return { remove: () => { } };
+    }
+    let framesLeft = INT_LAX_ANY(frames, 1);
+    let run = true;
+    let requestAnimationFrameId = null;
+    let lastTime = globalThis?.performance?.now?.() ?? 0;
+    const tick = () => {
+        if (run) {
+            if (framesLeft <= 0) {
+                run = false;
+                requestAnimationFrameId = null;
+                const currentTime = globalThis?.performance?.now?.() ?? 0;
+                try {
+                    callback((currentTime - lastTime) / 1000);
+                }
+                catch (e) {
+                    console.error(e);
+                }
+                lastTime = currentTime;
+                return;
+            }
+            framesLeft--;
+            requestAnimationFrameId = globalThis.requestAnimationFrame(tick);
+        }
+    };
+    tick();
+    return {
+        remove: () => {
+            run = false;
+            if (requestAnimationFrameId !== null) {
+                globalThis.cancelAnimationFrame(requestAnimationFrameId);
+                requestAnimationFrameId = null;
+            }
+        },
+    };
+}
+/**
+ * Executes callback every intervalFrames. Delta time in seconds passed to callback.
+ *
+ * @param callback - Function to call
+ * @param intervalFrames - Interval in frames
+ * @param fireImmediately - Whether to call immediately
+ * @returns Handler with remove() method
+ */
+export function setAnimationFrameInterval(callback, intervalFrames = 1, fireImmediately = false) {
+    const iFrames = INT_LAX_ANY(intervalFrames, 1);
+    if (fireImmediately) {
+        try {
+            callback(0);
+        }
+        catch (e) {
+            console.error(e);
+        }
+    }
+    if (!globalThis?.requestAnimationFrame || !globalThis?.cancelAnimationFrame) {
+        console.warn('LeUtils.setAnimationFrameInterval: Not supported.');
+        return { remove: () => { } };
+    }
+    let run = true;
+    let requestAnimationFrameId = null;
+    let lastTimestamp = 0;
+    let totalTime = 0;
+    let frames = iFrames;
+    const tick = (timestampVal) => {
+        if (run) {
+            if (lastTimestamp === 0) {
+                lastTimestamp = timestampVal;
+            }
+            totalTime += (timestampVal - lastTimestamp);
+            lastTimestamp = timestampVal;
+            frames--;
+            if (frames <= 0) {
+                try {
+                    callback(totalTime / 1000);
+                }
+                catch (e) {
+                    console.error(e);
+                }
+                totalTime = 0;
+                frames = iFrames;
+            }
+            if (run) {
+                requestAnimationFrameId = globalThis.requestAnimationFrame(tick);
+            }
+        }
+    };
+    globalThis.requestAnimationFrame(tick);
+    return {
+        remove: () => {
+            run = false;
+            if (requestAnimationFrameId !== null) {
+                globalThis.cancelAnimationFrame(requestAnimationFrameId);
+                requestAnimationFrameId = null;
+            }
+        },
+    };
+}
+/**
+ * Returns a promise resolved after ms.
+ *
+ * @param ms - Milliseconds to wait
+ * @returns Promise resolving to delta time
+ */
+export function promiseTimeout(ms) {
+    const msVal = FLOAT_LAX(ms);
+    if (msVal <= 0) {
+        return Promise.resolve(0);
+    }
+    return new Promise((resolve) => setTimeout(resolve, msVal));
+}
+/**
+ * Returns a promise resolved after frames.
+ *
+ * @param frames - Number of frames to wait
+ * @returns Promise resolving to delta time
+ */
+export function promiseAnimationFrameTimeout(frames) {
+    const iFrames = INT_LAX(frames);
+    if (iFrames <= 0) {
+        return Promise.resolve(0);
+    }
+    return new Promise((resolve) => setAnimationFrameTimeout(resolve, iFrames));
+}
+/**
+ * Fetch with retry and abort functionality.
+ *
+ * @param url - URL to fetch
+ * @param options - Fetch options including retries and delay
+ * @returns Object with then(), catch(), finally(), remove(), isRemoved()
+ */
+export function fetch(url, options) {
+    let currentRetries = 0;
+    // Type guard: check if options has retries property
+    const retriesValue = isRecordLike(options) && 'retries' in options ? options.retries : undefined;
+    const retries = INT_LAX(retriesValue);
+    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 globalThis.fetch(url, {
+                    signal: controller?.signal,
+                    ...(isRecordLike(options) ? options : {}),
+                    // @ts-ignore -- removing custom options from standard fetch options
+                    retries: undefined,
+                    // @ts-ignore -- removing custom options from standard fetch options
+                    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++;
+                // Type guard: check if delay is a function or a value
+                const delayValue = isRecordLike(options) && 'delay' in options ? options.delay : undefined;
+                const delay = typeof delayValue === 'function' ? INT_LAX_ANY(delayValue(currentRetries), 500) : INT_LAX_ANY(delayValue, 500);
+                await promiseTimeout(delay);
+                return await attemptFetch();
+            }
+        };
+        return await attemptFetch();
+    })();
+    const result = {
+        then: () => result,
+        catch: () => result,
+        finally: () => result,
+        remove: () => undefined,
+        isRemoved: () => false,
+    };
+    result.then = (...args) => {
+        // Type guard: verify promise is a Promise before chaining
+        if (isPromise(promise)) {
+            // Type guard: promise.then() returns a Promise, which we know is Promise<Response> in this context
+            // We've already verified promise is a Promise, so the result of .then() is also a Promise
+            // The generic Promise chain maintains the Response type in this context
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            const thenResult = promise.then(...args);
+            promise = thenResult;
+        }
+        return result;
+    };
+    result.catch = (...args) => {
+        // Type guard: verify promise is a Promise before chaining
+        if (isPromise(promise)) {
+            // Type guard: promise.catch() returns a Promise, which we know is Promise<Response> in this context
+            // We've already verified promise is a Promise, so the result of .catch() is also a Promise
+            // The generic Promise chain maintains the Response type in this context
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            const catchResult = promise.catch(...args);
+            promise = catchResult;
+        }
+        return result;
+    };
+    result.finally = (...args) => {
+        // Type guard: verify promise is a Promise before chaining
+        if (isPromise(promise)) {
+            // Type guard: promise.finally() returns a Promise, which we know is Promise<Response> in this context
+            // We've already verified promise is a Promise, so the result of .finally() is also a Promise
+            // The generic Promise chain maintains the Response type in this context
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            const finallyResult = promise.finally(...args);
+            promise = finallyResult;
+        }
+        return result;
+    };
+    result.remove = (...args) => {
+        controllerAborted = true;
+        if (controller) {
+            controller.abort(...args);
+        }
+        return result;
+    };
+    result.isRemoved = () => (controllerAborted || !!controller?.signal?.aborted);
+    return result;
+}
+/**
+ * Cached version of fetch.
+ *
+ * @param url - URL to fetch
+ * @param options - Fetch options
+ * @param responseFunction - Optional function to process response before caching
+ * @returns Promise resolving to data
+ */
+export const cachedFetch = (() => {
+    const cache = new Map();
+    return async (url, options, responseFunction) => {
+        if (cache.has(url)) {
+            const result = cache.get(url);
+            // Type guard: check result structure
+            if (isRecordLike(result)) {
+                if ('data' in result && result.data !== undefined) {
+                    return result.data;
+                }
+                if ('promise' in result && isPromise(result.promise)) {
+                    return await result.promise;
+                }
+                if ('error' in result && result.error !== undefined) {
+                    throw result.error;
+                }
+            }
+            return null;
+        }
+        // Type guard: fetch returns Promise<Response>
+        // Type guard: verify options is RequestInit-like for fetch
+        // RequestInit is compatible with Record<string, unknown>, so we can use it directly
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        const fetchOptions = isRecordLike(options) ? options : undefined;
+        const fetchPromise = globalThis.fetch(url, fetchOptions);
+        const promise = fetchPromise
+            .then(async (response) => {
+            const data = responseFunction ? (await responseFunction(response)) : response;
+            // Type guard: check if options has verify function
+            if (isRecordLike(options) && 'verify' in options) {
+                const verify = options.verify;
+                if (typeof verify === 'function') {
+                    await verify(data, response);
+                }
+            }
+            return data;
+        })
+            .then((data) => {
+            cache.set(url, { data });
+            return data;
+        })
+            .catch((error) => {
+            cache.set(url, { error });
+            throw error;
+        });
+        if (!cache.has(url)) {
+            cache.set(url, { promise });
+        }
+        return await promise;
+    };
+})();
+/**
+ * Creates a new transactional value.
+ *
+ * @param value - Initial value
+ * @returns Transactional value object
+ */
+export function createTransactionalValue(value) {
+    return {
+        value: (typeof value === 'undefined') ? null : value,
+        changes: [],
+    };
+}
+/**
+ * Validates a transactional value structure.
+ *
+ * @param transactionalValue - Value to check
+ * @returns true if valid
+ */
+export function isTransactionalValueValid(transactionalValue) {
+    return ((typeof transactionalValue === 'object') &&
+        (transactionalValue !== null) &&
+        isTransactionalValue(transactionalValue));
+}
+/**
+ * Private helper to ensure valid transactional value.
+ */
+function checkTransactionalValue(transactionalValue) {
+    if (!isTransactionalValueValid(transactionalValue)) {
+        throw new Error('Invalid TransactionalValue provided');
+    }
+}
+/**
+ * Private helper to find a change by ID.
+ */
+function findTransactionalValueChange(transactionalValue, changeId) {
+    for (let i = 0; i < transactionalValue.changes.length; i++) {
+        if (transactionalValue.changes[i].id === changeId) {
+            return { change: transactionalValue.changes[i], index: i };
+        }
+    }
+    return null;
+}
+/**
+ * Converts transactional value to string representation of its state.
+ *
+ * @param transactionalValue - Transactional value
+ * @returns State string
+ */
+export function transactionalValueToString(transactionalValue) {
+    if (!isTransactionalValueValid(transactionalValue)) {
+        return STRING(transactionalValue);
+    }
+    if (transactionalValue.changes.length <= 0) {
+        return STRING(transactionalValue.value);
+    }
+    let valuesString = STRING(transactionalValue.value);
+    for (let i = 0; i < transactionalValue.changes.length; i++) {
+        valuesString += ' -> ' + STRING(transactionalValue.changes[i].value);
+    }
+    return STRING(transactionalValue.changes[transactionalValue.changes.length - 1].value) + ' (' + valuesString + ')';
+}
+/**
+ * Sets and commits a value, clearing all uncommitted changes.
+ *
+ * @param transactionalValue - Transactional value
+ * @param value - New value
+ */
+export function transactionSetAndCommit(transactionalValue, value) {
+    checkTransactionalValue(transactionalValue);
+    transactionalValue.value = (typeof value === 'undefined') ? null : value;
+    transactionalValue.changes = [];
+}
+/**
+ * Adds an uncommitted change. Returns change ID.
+ *
+ * @param transactionalValue - Transactional value
+ * @param value - New value
+ * @returns Change ID
+ */
+export function transactionSetWithoutCommitting(transactionalValue, value) {
+    checkTransactionalValue(transactionalValue);
+    const id = uniqueId();
+    transactionalValue.changes.push({ id, value: (typeof value === 'undefined') ? null : value });
+    return id;
+}
+/**
+ * Commits a specific change by ID.
+ *
+ * @param transactionalValue - Transactional value
+ * @param changeId - Change ID
+ * @returns true if committed
+ */
+export function transactionCommitChange(transactionalValue, changeId) {
+    checkTransactionalValue(transactionalValue);
+    const result = findTransactionalValueChange(transactionalValue, changeId);
+    if (result === null) {
+        return false;
+    }
+    transactionalValue.value = result.change.value;
+    transactionalValue.changes.splice(0, result.index + 1);
+    return true;
+}
+/**
+ * Cancels a specific change by ID.
+ *
+ * @param transactionalValue - Transactional value
+ * @param changeId - Change ID
+ * @returns true if cancelled
+ */
+export function transactionCancelChange(transactionalValue, changeId) {
+    checkTransactionalValue(transactionalValue);
+    const result = findTransactionalValueChange(transactionalValue, changeId);
+    if (result === null) {
+        return false;
+    }
+    transactionalValue.changes.splice(result.index, 1);
+    return true;
+}
+/**
+ * Checks if a change is still relevant.
+ *
+ * @param transactionalValue - Transactional value
+ * @param changeId - Change ID
+ * @returns true if relevant
+ */
+export function transactionIsChangeRelevant(transactionalValue, changeId) {
+    checkTransactionalValue(transactionalValue);
+    return (findTransactionalValueChange(transactionalValue, changeId) !== null);
+}
+/**
+ * Gets current committed value.
+ *
+ * @param transactionalValue - Transactional value
+ * @returns Committed value
+ */
+export function transactionGetCommittedValue(transactionalValue) {
+    checkTransactionalValue(transactionalValue);
+    return transactionalValue.value;
+}
+/**
+ * Gets current value (including most recent uncommitted change).
+ *
+ * @param transactionalValue - Transactional value
+ * @returns Current value
+ */
+export function transactionGetValue(transactionalValue) {
+    checkTransactionalValue(transactionalValue);
+    if (transactionalValue.changes.length <= 0) {
+        return transactionalValue.value;
+    }
+    return transactionalValue.changes[transactionalValue.changes.length - 1].value;
+}
+/**
+ * Performs a deep equality comparison between two collections, sorting on keys first.
+ *
+ * @param elementsA - First collection
+ * @param elementsB - Second collection
+ * @param ignoreKeys - Keys to ignore
+ * @returns true if equivalent
+ */
+export function equalsMapLike(elementsA, elementsB, ignoreKeys = []) {
+    const sortKeyValueArrays = (pairA, pairB) => {
+        // Type guard: verify both are pairs
+        if (isPair(pairA) && isPair(pairB)) {
+            return compare(pairA[0], pairB[0]);
+        }
+        return 0;
+    };
+    // Type guard: verify mapToArray returns array of pairs
+    const aArray = mapToArray(elementsA, (value, key) => [key, value]);
+    const bArray = mapToArray(elementsB, (value, key) => [key, value]);
+    const aPairs = (Array.isArray(aArray) ? aArray.filter((item) => isPair(item)) : []).sort(sortKeyValueArrays);
+    const bPairs = (Array.isArray(bArray) ? bArray.filter((item) => isPair(item)) : []).sort(sortKeyValueArrays);
+    const ignore = (typeof ignoreKeys === 'string') ? ARRAY(ignoreKeys) : mapToArray(ignoreKeys);
+    let i = 0, j = 0;
+    while (i < aPairs.length && j < bPairs.length) {
+        const [ka, va] = aPairs[i];
+        const [kb, vb] = bPairs[j];
+        if (ignore.includes(ka)) {
+            i++;
+            if (ignore.includes(kb))
+                j++;
+            continue;
+        }
+        if (ignore.includes(kb)) {
+            j++;
+            continue;
+        }
+        if (!equals(ka, kb) || !equals(va, vb))
+            return false;
+        i++;
+        j++;
+    }
+    while (i < aPairs.length && ignore.includes(aPairs[i][0]))
+        i++;
+    if (i < aPairs.length)
+        return false;
+    while (j < bPairs.length && ignore.includes(bPairs[j][0]))
+        j++;
+    return j >= bPairs.length;
+}
+/**
+ * Executes callback when document is ready.
+ *
+ * @param callback - Function to call
+ * @returns Handler with remove() method
+ */
+export function onDomReady(callback) {
+    // @ts-ignore -- document might not be defined in non-browser environments
+    if (!globalThis?.document?.addEventListener) {
+        console.warn('LeUtils.onDomReady: No document found.');
+        return { remove: () => { } };
+    }
+    // @ts-ignore -- document might not be defined in non-browser environments
+    if (globalThis.document.readyState === 'interactive' || globalThis.document.readyState === 'complete') {
+        return setTimeout(callback, 0);
+    }
+    let listening = true;
+    const wrapper = () => {
+        if (listening) {
+            listening = false;
+            // @ts-ignore -- document might not be defined in non-browser environments
+            globalThis.document.removeEventListener('DOMContentLoaded', wrapper);
+            callback();
+        }
+    };
+    // @ts-ignore -- document might not be defined in non-browser environments
+    globalThis.document.addEventListener('DOMContentLoaded', wrapper);
+    return {
+        remove: () => {
+            if (listening) {
+                listening = false;
+                // @ts-ignore -- document might not be defined in non-browser environments
+                globalThis.document.removeEventListener('DOMContentLoaded', wrapper);
+            }
+        },
+    };
+}
+/**
+ * Parses version string into object with comparison helpers.
+ *
+ * @param version - Version string or object
+ * @returns Version object with comparison methods
+ */
+export function parseVersionString(version) {
+    // Type guard: verify version has major, minor, patch
+    if (isVersionObject(version)) {
+        const major = INT_LAX(version.major);
+        const minor = INT_LAX(version.minor);
+        const patch = INT_LAX(version.patch);
+        return {
+            major,
+            minor,
+            patch,
+            toString: () => `${major}.${minor}.${patch}`,
+            equals: (other) => {
+                if (!isVersionObject(other)) {
+                    return false;
+                }
+                return major === INT_LAX(other.major) && minor === INT_LAX(other.minor) && patch === INT_LAX(other.patch);
+            },
+            largerThan: (other) => {
+                if (!isVersionObject(other)) {
+                    return false;
+                }
+                const otherMajor = INT_LAX(other.major);
+                const otherMinor = INT_LAX(other.minor);
+                const otherPatch = INT_LAX(other.patch);
+                return (major > otherMajor) || (major === otherMajor && minor > otherMinor) || (major === otherMajor && minor === otherMinor && patch > otherPatch);
+            },
+            largerThanOrEquals: (other) => {
+                if (!isVersionObject(other)) {
+                    return false;
+                }
+                const otherMajor = INT_LAX(other.major);
+                const otherMinor = INT_LAX(other.minor);
+                const otherPatch = INT_LAX(other.patch);
+                return (major > otherMajor) || (major === otherMajor && minor > otherMinor) || (major === otherMajor && minor === otherMinor && patch >= otherPatch);
+            },
+            smallerThan: (other) => {
+                if (!isVersionObject(other)) {
+                    return false;
+                }
+                const otherMajor = INT_LAX(other.major);
+                const otherMinor = INT_LAX(other.minor);
+                const otherPatch = INT_LAX(other.patch);
+                return !((major > otherMajor) || (major === otherMajor && minor > otherMinor) || (major === otherMajor && minor === otherMinor && patch >= otherPatch));
+            },
+            smallerThanOrEquals: (other) => {
+                if (!isVersionObject(other)) {
+                    return false;
+                }
+                const otherMajor = INT_LAX(other.major);
+                const otherMinor = INT_LAX(other.minor);
+                const otherPatch = INT_LAX(other.patch);
+                return !((major > otherMajor) || (major === otherMajor && minor > otherMinor) || (major === otherMajor && minor === otherMinor && patch > otherPatch));
+            },
+        };
+    }
+    const v = STRING(version).trim();
+    const parts = v.split(' ')[0].split('-')[0].split('.');
+    const major = INT_LAX(parts[0]);
+    const minor = INT_LAX(parts[1]);
+    const patch = INT_LAX(parts[2]);
+    const obj = {
+        major,
+        minor,
+        patch,
+        toString: () => `${major}.${minor}.${patch}`,
+        equals: (other) => {
+            const o = parseVersionString(other);
+            return major === o.major && minor === o.minor && patch === o.patch;
+        },
+        largerThan: (other) => {
+            const o = parseVersionString(other);
+            if (major > o.major)
+                return true;
+            if (major < o.major)
+                return false;
+            if (minor > o.minor)
+                return true;
+            if (minor < o.minor)
+                return false;
+            return patch > o.patch;
+        },
+        largerThanOrEquals: (other) => {
+            const o = parseVersionString(other);
+            if (major > o.major)
+                return true;
+            if (major < o.major)
+                return false;
+            if (minor > o.minor)
+                return true;
+            if (minor < o.minor)
+                return false;
+            return patch >= o.patch;
+        },
+        smallerThan: (other) => {
+            return !obj.largerThanOrEquals(other);
+        },
+        smallerThanOrEquals: (other) => {
+            return !obj.largerThan(other);
+        },
+    };
+    return obj;
+}
+/**
+ * Increases numeric string by 1 without limit.
+ *
+ * @param str - Numeric string
+ * @returns Increased string
+ */
+export function increaseNumericStringByOne(str) {
+    const s = (typeof str !== 'string') ? String(str) : str;
+    if (!s || /[^0-9]/.test(s))
+        return '1';
+    const chars = s.split('');
+    for (let i = chars.length - 1; i >= 0; i--) {
+        const n = parseInt(chars[i], 10);
+        if (n < 9) {
+            chars[i] = String(n + 1);
+            return chars.join('');
+        }
+        chars[i] = '0';
+    }
+    return '1' + chars.join('');
+}
+/**
+ * Checks if collection contains all given values (case-insensitive).
+ *
+ * @param array - Collection to search
+ * @param values - Values to find
+ * @returns true if all found
+ */
+export function containsAllCaseInsensitive(array, values) {
+    if (!array)
+        return false;
+    let result = true;
+    each(values, (v) => {
+        if (!containsCaseInsensitive(array, v)) {
+            result = false;
+            return false;
+        }
+    });
+    return result;
+}
+/**
+ * Checks if collection contains any of given values (case-insensitive).
+ *
+ * @param array - Collection to search
+ * @param values - Values to find
+ * @returns true if any found
+ */
+export function containsAnyCaseInsensitive(array, values) {
+    if (!array)
+        return false;
+    let result = false;
+    each(values, (v) => {
+        if (containsCaseInsensitive(array, v)) {
+            result = true;
+            return false;
+        }
+    });
+    return result;
+}
+/**
+ * Checks if collection contains none of given values (case-insensitive).
+ *
+ * @param array - Collection to search
+ * @param values - Values to find
+ * @returns true if none found
+ */
+export function containsNoneCaseInsensitive(array, values) {
+    if (!array)
+        return true;
+    let result = true;
+    each(values, (v) => {
+        if (containsCaseInsensitive(array, v)) {
+            result = false;
+            return false;
+        }
+    });
+    return result;
+}
+/**
+ * Returns string with start/end trimmed and ensures valid sentence ending.
+ *
+ * @param sentence - String to purge
+ * @returns Purged sentence
+ */
+export function purgeSentence(sentence) {
+    let s = trimEnd(STRING(sentence).trim(), '.: \r\n\t');
+    s += (endsWithAny(s, '!?;') ? '' : '.');
+    return s;
+}
+/**
+ * Obtains error message from any input.
+ *
+ * @param error - Error source
+ * @returns Error message string
+ */
+export function purgeErrorMessage(error) {
+    let err = error;
+    // Type guard: check if error has message property
+    if (hasErrorMessage(err)) {
+        err = err.message;
+    }
+    if (typeof err === 'string') {
+        const errorParts = err.split('threw an error:');
+        err = errorParts[errorParts.length - 1];
+    }
+    else {
+        try {
+            err = JSON.stringify(err);
+        }
+        catch {
+            err = 'An unknown error occurred';
+        }
+    }
+    return STRING(err).trim();
+}
+/**
+ * Generates permutations of names (e.g. foobar, fooBar, FooBar, foo-bar, foo_bar).
+ *
+ * @param names - Parts to combine
+ * @returns Array of permutations
+ */
+export function generateNamePermutations(...names) {
+    const n = flattenToArray(names)
+        .map((name) => STRING(name).trim().toLowerCase())
+        .filter((name) => (name.length > 0));
+    const results = [];
+    if (n.length > 0) {
+        results.push(n.join('')); //foobar
+        results.push(n.map(capitalize).join('')); //FooBar
+    }
+    if (n.length > 1) {
+        results.push([n[0]].concat(n.slice(1).map(capitalize)).join('')); //fooBar
+        results.push(n.join('-')); //foo-bar
+        results.push(n.join('_')); //foo_bar
+    }
+    return results;
+}
+/**
+ * Compares two strings generated by LeUtils.timestamp(). Primarily used for sorting.
+ */
+export function compareTimestampStrings(a, b) {
+    try {
+        const ta = base64ToHex(STRING(a).replaceAll('-', '+').replaceAll('_', '/'));
+        const tb = base64ToHex(STRING(b).replaceAll('-', '+').replaceAll('_', '/'));
+        return compare(ta, tb);
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * Returns true if the user is on a smartphone device (mobile).
+ */
+export function platformIsMobile() {
+    // Type guard: check navigator and globalThis for vendor/opera properties
+    let userAgent = globalThis?.navigator?.userAgent || '';
+    if (!userAgent && globalThis?.navigator && hasNavigatorVendor(globalThis.navigator)) {
+        userAgent = globalThis.navigator.vendor || '';
+    }
+    if (!userAgent && hasOpera(globalThis)) {
+        const operaValue = safeGetProperty(globalThis, 'opera');
+        userAgent = typeof operaValue === 'string' ? operaValue : '';
+    }
+    const a = STRING(userAgent || '');
+    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(a));
+}
+/**
+ * Returns true if the user has a cursor (mouse).
+ */
+export function platformHasCursor() {
+    return !platformIsMobile() && !globalThis?.matchMedia?.('(any-hover: none)')?.matches;
+}
+/**
+ * Returns string with email purged (lowercased, trimmed).
+ */
+export function purgeEmail(email) {
+    const e = STRING(email).trim().toLowerCase().replace(/\s/g, '');
+    if (!e.includes('@') || !e.includes('.')) {
+        return '';
+    }
+    return e;
+}
+/**
+ * Returns true if the focus is effectively clear, meaning that the user is not typing in an input field.
+ */
+export const 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.
+ */
+export const getUserLocale = (() => {
+    let userLocale = null;
+    return () => {
+        if (userLocale === null) {
+            userLocale = (() => {
+                // Type guard: check if navigator has languages
+                let locales = [];
+                if (globalThis?.navigator && hasNavigatorLanguages(globalThis.navigator)) {
+                    const navLanguages = safeGetProperty(globalThis.navigator, 'languages');
+                    if (Array.isArray(navLanguages)) {
+                        locales = navLanguages;
+                    }
+                }
+                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) => STRING(locale).toLowerCase().startsWith('en-'));
+                if (localesNoEnglish.length <= 0) {
+                    return STRING(locales[0]);
+                }
+                return STRING(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.
+ */
+export const getUserLocaleDateFormat = (() => {
+    let userLocaleDateFormat = null;
+    return () => {
+        if (userLocaleDateFormat === null) {
+            userLocaleDateFormat = (() => {
+                let char = '/';
+                // Type guard: check if globalThis has Intl
+                if (hasIntl(globalThis) && globalThis.Intl && 'DateTimeFormat' in globalThis.Intl) {
+                    const DateTimeFormat = safeGetProperty(globalThis.Intl, 'DateTimeFormat');
+                    if (typeof DateTimeFormat === 'function') {
+                        // Type guard: DateTimeFormat constructor accepts locale and returns object with format method
+                        // We've already verified it's a function, now construct it
+                        // Use Function.prototype.apply to avoid type assertion
+                        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                        const dtfInstance = Function.prototype.apply.call(DateTimeFormat, null, [getUserLocale()]);
+                        if ('format' in dtfInstance && typeof dtfInstance.format === 'function') {
+                            const formattedDate = dtfInstance.format();
+                            if (formattedDate.includes('-')) {
+                                char = '-';
+                            }
+                            else if (formattedDate.includes('. ')) {
+                                char = '.';
+                            }
+                            else if (formattedDate.includes('.')) {
+                                char = '.';
+                            }
+                        }
+                    }
+                }
+                return 'YYYY' + char + 'MM' + char + 'DD';
+            })();
+        }
+        return userLocaleDateFormat;
+    };
+})();
+/**
+ * Returns an empty 1x1 transparent image data URL.
+ */
+export function getEmptyImageSrc() {
+    return 'data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==';
+}
+/**
+ * Calculates and returns the percentage of the part and total ((part / total) * 100).
+ */
+export function getPercentage(part, total) {
+    const p = FLOAT_LAX(part);
+    const t = FLOAT_LAX(total);
+    if (t === 0) {
+        return 100;
+    }
+    return Math.max(0, Math.min(100, ((p / t) * 100)));
+}
+/**
+ * Returns the pixels of the given Image object.
+ */
+export async function 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.
+ */
+export async function getColoredImage(image, color) {
+    if (!globalThis?.document?.createElement || !globalThis?.document?.body?.appendChild) {
+        console.warn('LeUtils.getColoredImage: Document is not available, returning empty image src.');
+        return 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 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).
+ */
+export function 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.
+ */
+export function hexToRgb(hexstring) {
+    const initialHexstring = hexstring;
+    const h = STRING(hexstring).replace(/[^0-9A-F]/gi, '');
+    const hasAlpha = ((h.length === 4) || (h.length === 8));
+    let finalH = h;
+    while (finalH.length < 6) {
+        finalH = finalH.replace(/(.)/g, '$1$1');
+    }
+    const result = finalH.match(/\w{2}/g)?.map((a) => parseInt(a, 16));
+    if (!result || (result.length < 3)) {
+        throw new Error('Invalid hex color: "' + finalH + '"  (was given "' + initialHexstring + '")');
+    }
+    return [
+        result[0],
+        result[1],
+        result[2],
+        ...(hasAlpha ? [result[3]] : []),
+    ];
+}
+/**
+ * Returns the HSL(A) of the given RGB(A).
+ */
+export function 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;
+    const 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).
+ */
+export const 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).
+ */
+export function 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.
+ */
+export function getDifferenceBetweenRgb(rgbA, rgbB) {
+    const labA = rgbToLab(rgbA);
+    const labB = rgbToLab(rgbB);
+    return getDifferenceBetweenLab(labA, labB);
+}
+/**
+ * Returns the difference (calculated with DeltaE) of the given LAB values.
+ */
+export function 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) between the two given RGB(A) values, based on the given percentage (0-100).
+ */
+export function getRgbBetween(startRgb, endRgb, percentage) {
+    const p = FLOAT_LAX(percentage);
+    const partEnd = Math.max(0, Math.min(1, (p / 100.0)));
+    const partStart = (1 - partEnd);
+    const length = Math.min(startRgb.length, endRgb.length);
+    const 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;
+}
+/**
+ * Returns the RGB(A) of the given RGB(A) values, based on the given percentage (0-100).
+ */
+export function getRgbOfGradient(gradient, percentage) {
+    const p = Math.max(0, Math.min(100, FLOAT_LAX(percentage)));
+    let closest = null;
+    each(gradient, (_color, percentStr) => {
+        const percent = INT_LAX(percentStr);
+        if (closest === null) {
+            closest = [percent, Math.abs(p - percent)];
+        }
+        else {
+            const difference = Math.abs(p - percent);
+            if (difference < closest[1]) {
+                closest = [percent, difference];
+            }
+        }
+    });
+    if (closest === null) {
+        return [0, 0, 0];
+    }
+    const closestPercent = closest[0];
+    const HIGHER = 99999;
+    const LOWER = -99999;
+    let higher = HIGHER;
+    let lower = LOWER;
+    each(gradient, (_color, percentStr) => {
+        const percent = INT_LAX(percentStr);
+        if (percent < closestPercent) {
+            if (percent > lower) {
+                lower = percent;
+            }
+        }
+        if (percent > closestPercent) {
+            if (percent < higher) {
+                higher = percent;
+            }
+        }
+    });
+    if (((higher === HIGHER) && (lower === LOWER)) || (higher === lower)) {
+        // Type guard: verify gradient entry is number array
+        const gradientValue = gradient[closestPercent];
+        if (isNumberArray(gradientValue)) {
+            return gradientValue;
+        }
+        console.error('LeUtils.getRgbFromGradient: gradient entry is not a number array', gradientValue);
+        return [0, 0, 0];
+    }
+    else if ((higher !== HIGHER) && (lower !== LOWER)) {
+        const higherDifference = Math.abs(higher - p);
+        const lowerDifference = Math.abs(p - lower);
+        if (higherDifference > lowerDifference) {
+            higher = closestPercent;
+        }
+        else {
+            lower = closestPercent;
+        }
+    }
+    else if (lower === LOWER) {
+        lower = closestPercent;
+    }
+    else {
+        higher = closestPercent;
+    }
+    if (lower > higher) {
+        const tmp = higher;
+        higher = lower;
+        lower = tmp;
+    }
+    const total = (higher - lower);
+    const part = (p - lower);
+    // Type guard: verify gradient entries are number arrays
+    const lowerGradient = gradient[lower];
+    const higherGradient = gradient[higher];
+    if (!isNumberArray(lowerGradient) || !isNumberArray(higherGradient)) {
+        console.error('LeUtils.getRgbFromGradient: gradient entries are not number arrays', lowerGradient, higherGradient);
+        return [0, 0, 0];
+    }
+    return getRgbBetween(lowerGradient, higherGradient, ((part / total) * 100));
+}
+/**
+ * Download file from URL or data.
+ */
+export function downloadFile(name, data) {
+    if (!globalThis.document?.createElement || !globalThis.URL?.createObjectURL)
+        return;
+    const a = globalThis.document.createElement('a');
+    a.style.display = 'none';
+    const url = (typeof data === 'string') ? data : globalThis.URL.createObjectURL(data);
+    a.href = url;
+    a.download = name;
+    globalThis.document.body.appendChild(a);
+    a.click();
+    setTimeout(() => {
+        globalThis.document.body.removeChild(a);
+        if (typeof data !== 'string')
+            globalThis.URL.revokeObjectURL(url);
+    }, 0);
+}
+/**
+ * LocalStorage Get.
+ */
+export function localStorageGet(key) {
+    try {
+        return globalThis.localStorage?.getItem(key) ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * LocalStorage Set.
+ */
+export function localStorageSet(key, value) {
+    try {
+        globalThis.localStorage?.setItem(key, value);
+    }
+    catch {
+        // Ignore error
+    }
+}
+/**
+ * LocalStorage Remove.
+ */
+export function localStorageRemove(key) {
+    try {
+        globalThis.localStorage?.removeItem(key);
+    }
+    catch {
+        // Ignore error
+    }
+}
+/**
+ * Checks if given host is private.
+ */
+export function isGivenHostPrivate(host) {
+    const h = STRING(host).trim().toLowerCase();
+    return h === 'localhost' || h === '127.0.0.1' || h.startsWith('192.168.') || h.startsWith('10.') || /^172\.(1[6-9]|2[0-9]|3[0-1])\./.test(h);
+}
+/**
+ * Checks if current host is private.
+ */
+export function isCurrentHostPrivate() {
+    return isGivenHostPrivate(globalThis?.location?.hostname);
+}
+/**
+ * Create worker thread.
+ */
+export function createWorkerThread(name) {
+    if (!globalThis?.Worker) {
+        console.warn('LeUtils.createWorkerThread: Workers are not supported, returning a dummy.');
+        return {
+            worker: null,
+            sendMessage: (_data, _options) => Promise.reject('Workers are not supported in this environment'),
+        };
+    }
+    const worker = new globalThis.Worker('/workers/' + name + '.worker.js');
+    const listeners = new Map();
+    const sendMessage = (data, options) => {
+        return new Promise((resolve, reject) => {
+            const id = uniqueId();
+            listeners.set(id, resolve);
+            globalThis.setTimeout(() => {
+                listeners.delete(id);
+                reject('timeout');
+            }, options?.timeout ?? 10000);
+            // Type guard: verify data is Record-like for spreading
+            const messageData = isRecordLike(data) ? data : { data };
+            worker.postMessage({ id, ...messageData });
+        });
+    };
+    worker.onerror = (error) => {
+        console.error('Worker ' + name + ':', error);
+    };
+    worker.onmessage = (message) => {
+        const data = message.data;
+        // Type guard: verify data has id property
+        if (hasId(data)) {
+            const callback = listeners.get(data.id);
+            if (callback) {
+                listeners.delete(data.id);
+                callback(data);
+            }
+        }
+    };
+    return { worker, sendMessage };
+}
+/**
+ * Send message to worker.
+ */
+export const sendWorkerMessage = (() => {
+    const workers = new Map();
+    return (workerName, data, options) => {
+        if (!workers.has(workerName)) {
+            workers.set(workerName, createWorkerThread(workerName));
+        }
+        // Type guard: verify worker has sendMessage method
+        const worker = workers.get(workerName);
+        if (worker && hasSendMessage(worker)) {
+            return worker.sendMessage(data, options);
+        }
+        console.error('LeUtils.createWorkerThread: worker does not have sendMessage method', worker);
+        return Promise.reject(new Error('Worker does not have sendMessage method'));
+    };
+})();
+//# sourceMappingURL=LeUtils.js.map