@lowentry/utils 2.0.4 → 2.0.7

package/dist/index.d.ts

@@ -1,11 +1,1045 @@
-import * as LeUtilsFunctions from './LeUtils';
-export * from './LeTypes';
-export * from './LeUtils';
-export * from './classes/EventEmitter';
-export * from './classes/LinkedList';
-export * from './classes/SerializableMap';
-export * from './classes/TreeSet';
-export declare const LeUtils: {
+/**
+ * LeUtils - Core utility functions
+ */
+/**
+ * Transactional Value Types
+ */
+interface TransactionChange {
+    id: string;
+    value: unknown;
+}
+interface TransactionalValue {
+    value: unknown;
+    changes: TransactionChange[];
+}
+/**
+ * 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
+ */
+declare function equals(a: unknown, b: unknown): boolean;
+/**
+ * Deep clones a value.
+ *
+ * @param value - Value to clone
+ * @returns Deep cloned value
+ */
+declare function clone<T>(value: T): T;
+/**
+ * Checks if the given elements can be iterated over using each().
+ *
+ * @param elements - Value to check
+ * @returns true if can iterate
+ */
+declare function supportsEach(elements: unknown): boolean;
+/**
+ * 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]
+ */
+declare function eachIterator(elements: unknown, optionalSkipHasOwnPropertyCheck?: boolean): Generator<[unknown, unknown]>;
+/**
+ * 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
+ */
+declare function each<T>(elements: T, callback: (value: unknown, key: unknown) => boolean | void, optionalSkipHasOwnPropertyCheck?: boolean): T;
+/**
+ * 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
+ */
+declare function eachAsync<T>(elements: T, asyncCallback: (value: unknown, key: unknown) => Promise<boolean | void>, parallelCount?: number, optionalSkipHasOwnPropertyCheck?: boolean): Promise<T>;
+/**
+ * Returns empty collection matching type of input, plus add function.
+ *
+ * @param elements - Source collection to match type
+ * @returns [success, emptyCollection, addFunction]
+ */
+declare function getEmptySimplifiedCollection(elements: unknown): [boolean, unknown, (value: unknown, index: unknown) => void];
+/**
+ * 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)
+ */
+declare function filter(elements: unknown, callback?: (value: unknown, index: unknown) => boolean, optionalSkipHasOwnPropertyCheck?: boolean): unknown;
+/**
+ * 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)
+ */
+declare function map(elements: unknown, callback?: (value: unknown, index: unknown) => unknown, optionalSkipHasOwnPropertyCheck?: boolean): unknown;
+/**
+ * Maps collection to array.
+ *
+ * @param elements - Collection to map
+ * @param callback - Transform function
+ * @param optionalSkipHasOwnPropertyCheck - Skip hasOwnProperty
+ * @returns Array of transformed values
+ */
+declare function mapToArray<T = unknown>(elements: unknown, callback?: (value: unknown, index: unknown) => T, optionalSkipHasOwnPropertyCheck?: boolean): T[];
+/**
+ * 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
+ */
+declare function sortKeys(elements: unknown, comparator: (a: unknown, b: unknown) => number, optionalSkipHasOwnPropertyCheck?: boolean): unknown[];
+/**
+ * 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
+ */
+declare function getValueAtIndex(elements: unknown, index: unknown, optionalSkipHasOwnPropertyCheck?: boolean): unknown;
+/**
+ * Flattens nested arrays to single level (like Array.flat(Infinity)).
+ *
+ * @param array - Array to flatten
+ * @returns Flattened array
+ */
+declare function flattenArray(array: unknown): unknown[];
+/**
+ * Flattens any collection (arrays, Sets, Maps, objects) to single array.
+ *
+ * @param elements - Collection to flatten
+ * @param optionalSkipHasOwnPropertyCheck - Skip hasOwnProperty
+ * @returns Flattened array
+ */
+declare function flattenToArray(elements: unknown, optionalSkipHasOwnPropertyCheck?: boolean): unknown[];
+/**
+ * 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
+ */
+declare function mapToArraySorted(elements: unknown, comparator: (a: unknown, b: unknown) => number, callback?: (value: unknown, key: unknown) => unknown, optionalSkipHasOwnPropertyCheck?: boolean): unknown[];
+/**
+ * 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
+ */
+declare function compare(a: unknown, b: unknown): number;
+/**
+ * Compares two numbers (for sorting).
+ *
+ * @param a - First number
+ * @param b - Second number
+ * @returns Difference (a - b)
+ */
+declare function compareNumbers(a: number, b: number): number;
+/**
+ * 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
+ */
+declare function compareNumericStrings(a: string | number, b: string | number): number;
+/**
+ * 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
+ */
+declare function compareNaturalStrings(a: string, b: string): number;
+/**
+ * Checks if object is empty (no own properties).
+ *
+ * @param obj - Object to check
+ * @param optionalSkipHasOwnPropertyCheck - Skip hasOwnProperty
+ * @returns true if empty
+ */
+declare function isEmptyObject(obj: unknown, optionalSkipHasOwnPropertyCheck?: boolean): boolean;
+/**
+ * Counts own properties in object.
+ *
+ * @param obj - Object to count
+ * @param optionalSkipHasOwnPropertyCheck - Skip hasOwnProperty
+ * @returns Number of own properties
+ */
+declare function getObjectFieldsCount(obj: unknown, optionalSkipHasOwnPropertyCheck?: boolean): number;
+/**
+ * Capitalizes first character of string.
+ *
+ * @param string - String to capitalize
+ * @returns Capitalized string
+ */
+declare function capitalize(string: unknown): string;
+/**
+ * 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
+ */
+declare function endsWithAny(string: unknown, endingCharsStringOrArray: string | string[]): boolean;
+/**
+ * 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
+ */
+declare function startsWithAny(string: unknown, startingCharsStringOrArray: string | string[]): boolean;
+/**
+ * Trims specific characters from end of string.
+ *
+ * @param string - String to trim
+ * @param trimCharsStringOrArray - Characters to remove
+ * @returns Trimmed string
+ */
+declare function trimEnd(string: unknown, trimCharsStringOrArray: string | string[]): string;
+/**
+ * Trims specific characters from start of string.
+ *
+ * @param string - String to trim
+ * @param trimCharsStringOrArray - Characters to remove
+ * @returns Trimmed string
+ */
+declare function trimStart(string: unknown, trimCharsStringOrArray: string | string[]): string;
+/**
+ * Trims specific characters from both ends of string.
+ *
+ * @param string - String to trim
+ * @param trimCharsStringOrArray - Characters to remove
+ * @returns Trimmed string
+ */
+declare function trim(string: unknown, trimCharsStringOrArray: string | string[]): string;
+/**
+ * Checks if collection contains value (string comparison).
+ *
+ * @param array - Collection to search
+ * @param value - Value to find
+ * @returns true if found
+ */
+declare function contains(array: unknown, value: unknown): boolean;
+/**
+ * Checks if collection contains value (case-insensitive).
+ *
+ * @param array - Collection to search
+ * @param value - Value to find
+ * @returns true if found
+ */
+declare function containsCaseInsensitive(array: unknown, value: unknown): boolean;
+/**
+ * Checks if collection contains all given values.
+ *
+ * @param array - Collection to search
+ * @param values - Values to find
+ * @returns true if all found
+ */
+declare function containsAll(array: unknown, values: unknown): boolean;
+/**
+ * Checks if collection contains any of given values.
+ *
+ * @param array - Collection to search
+ * @param values - Values to find
+ * @returns true if any found
+ */
+declare function containsAny(array: unknown, values: unknown): boolean;
+/**
+ * Checks if collection contains none of given values.
+ *
+ * @param array - Collection to search
+ * @param values - Values to check
+ * @returns true if none found
+ */
+declare function containsNone(array: unknown, values: unknown): boolean;
+/**
+ * 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
+ */
+declare function findIndexValue(elements: unknown, callback: (value: unknown, index: unknown) => boolean, optionalSkipHasOwnPropertyCheck?: boolean): {
+    index: unknown;
+    value: unknown;
+} | null;
+/**
+ * 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
+ */
+declare function findIndex(elements: unknown, callback: (value: unknown, index: unknown) => boolean, optionalSkipHasOwnPropertyCheck?: boolean): unknown;
+/**
+ * Finds first element matching predicate, returns value.
+ *
+ * @param elements - Collection to search
+ * @param callback - Predicate function
+ * @param optionalSkipHasOwnPropertyCheck - Skip hasOwnProperty
+ * @returns Value or null
+ */
+declare function find(elements: unknown, callback: (value: unknown, index: unknown) => boolean, optionalSkipHasOwnPropertyCheck?: boolean): unknown;
+/**
+ * Generates a base64 string (with +/ replaced by -_) that is guaranteed to be unique.
+ *
+ * @returns Unique ID string
+ */
+declare const uniqueId: () => string;
+/**
+ * Generates a base64 string (with +/ replaced by -_) of the current time.
+ *
+ * @param now - Optional time to use
+ * @returns Timestamp string
+ */
+declare const timestamp: (now?: number | null) => string;
+/**
+ * Checks if value is a generator function.
+ *
+ * @param value - Value to check
+ * @returns true if generator, false otherwise
+ */
+declare const isGeneratorFunction: (value: unknown) => boolean;
+/**
+ * Environment-safe btoa.
+ *
+ * @param str - String to encode
+ * @returns Base64 string
+ */
+declare function btoa(str: string): string;
+/**
+ * Environment-safe atob.
+ *
+ * @param str - Base64 string to decode
+ * @returns Decoded string
+ */
+declare function atob(str: string): string;
+/**
+ * Encodes a UTF-8 string into a base64 string.
+ *
+ * @param string - UTF-8 string
+ * @returns Base64 string
+ */
+declare function utf8ToBase64(string: string): string;
+/**
+ * Decodes a base64 string back into a UTF-8 string.
+ *
+ * @param base64string - Base64 string
+ * @returns Decoded UTF-8 string
+ */
+declare function base64ToUtf8(base64string: string): string;
+/**
+ * Converts a base64 string into a hex string.
+ *
+ * @param base64string - Base64 string
+ * @returns Hex string
+ */
+declare function base64ToHex(base64string: string): string;
+/**
+ * Converts a hex string into a base64 string.
+ *
+ * @param hexstring - Hex string
+ * @returns Base64 string
+ */
+declare function hexToBase64(hexstring: string): string;
+/**
+ * Converts a base64 string into bytes (Uint8Array).
+ *
+ * @param base64string - Base64 string
+ * @returns Bytes
+ */
+declare function base64ToBytes(base64string: string): Uint8Array;
+/**
+ * Converts bytes into a base64 string.
+ *
+ * @param arraybuffer - Bytes source
+ * @returns Base64 string
+ */
+declare function bytesToBase64(arraybuffer: ArrayLike<number> | ArrayBuffer): string;
+/**
+ * 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
+ */
+declare function setTimeout(callback: (deltaTime: number) => unknown, ms: number): {
+    remove: () => void;
+};
+/**
+ * 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
+ */
+declare function setInterval(callback: (deltaTime: number) => unknown, intervalMs?: number, fireImmediately?: boolean): {
+    remove: () => void;
+};
+/**
+ * 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
+ */
+declare function setAnimationFrameTimeout(callback: (deltaTime: number) => unknown, frames?: number): {
+    remove: () => void;
+};
+/**
+ * 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
+ */
+declare function setAnimationFrameInterval(callback: (deltaTime: number) => unknown, intervalFrames?: number, fireImmediately?: boolean): {
+    remove: () => void;
+};
+/**
+ * Returns a promise resolved after ms.
+ *
+ * @param ms - Milliseconds to wait
+ * @returns Promise resolving to delta time
+ */
+declare function promiseTimeout(ms: number): Promise<number>;
+/**
+ * Returns a promise resolved after frames.
+ *
+ * @param frames - Number of frames to wait
+ * @returns Promise resolving to delta time
+ */
+declare function promiseAnimationFrameTimeout(frames: number): Promise<number>;
+/**
+ * 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()
+ */
+declare function fetch(url: string, options?: unknown): {
+    then: (onfulfilled?: (value: Response) => unknown, onrejected?: (reason: unknown) => unknown) => unknown;
+    catch: (onrejected?: (reason: unknown) => unknown) => unknown;
+    finally: (onfinally?: () => unknown) => unknown;
+    remove: () => unknown;
+    isRemoved: () => boolean;
+};
+/**
+ * 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
+ */
+declare const cachedFetch: (url: string, options?: unknown, responseFunction?: (response: Response) => unknown) => Promise<unknown>;
+/**
+ * Creates a new transactional value.
+ *
+ * @param value - Initial value
+ * @returns Transactional value object
+ */
+declare function createTransactionalValue(value?: unknown): TransactionalValue;
+/**
+ * Validates a transactional value structure.
+ *
+ * @param transactionalValue - Value to check
+ * @returns true if valid
+ */
+declare function isTransactionalValueValid(transactionalValue: unknown): transactionalValue is TransactionalValue;
+/**
+ * Converts transactional value to string representation of its state.
+ *
+ * @param transactionalValue - Transactional value
+ * @returns State string
+ */
+declare function transactionalValueToString(transactionalValue: unknown): string;
+/**
+ * Sets and commits a value, clearing all uncommitted changes.
+ *
+ * @param transactionalValue - Transactional value
+ * @param value - New value
+ */
+declare function transactionSetAndCommit(transactionalValue: TransactionalValue, value: unknown): void;
+/**
+ * Adds an uncommitted change. Returns change ID.
+ *
+ * @param transactionalValue - Transactional value
+ * @param value - New value
+ * @returns Change ID
+ */
+declare function transactionSetWithoutCommitting(transactionalValue: TransactionalValue, value: unknown): string;
+/**
+ * Commits a specific change by ID.
+ *
+ * @param transactionalValue - Transactional value
+ * @param changeId - Change ID
+ * @returns true if committed
+ */
+declare function transactionCommitChange(transactionalValue: TransactionalValue, changeId: string): boolean;
+/**
+ * Cancels a specific change by ID.
+ *
+ * @param transactionalValue - Transactional value
+ * @param changeId - Change ID
+ * @returns true if cancelled
+ */
+declare function transactionCancelChange(transactionalValue: TransactionalValue, changeId: string): boolean;
+/**
+ * Checks if a change is still relevant.
+ *
+ * @param transactionalValue - Transactional value
+ * @param changeId - Change ID
+ * @returns true if relevant
+ */
+declare function transactionIsChangeRelevant(transactionalValue: TransactionalValue, changeId: string): boolean;
+/**
+ * Gets current committed value.
+ *
+ * @param transactionalValue - Transactional value
+ * @returns Committed value
+ */
+declare function transactionGetCommittedValue(transactionalValue: TransactionalValue): unknown;
+/**
+ * Gets current value (including most recent uncommitted change).
+ *
+ * @param transactionalValue - Transactional value
+ * @returns Current value
+ */
+declare function transactionGetValue(transactionalValue: TransactionalValue): unknown;
+/**
+ * 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
+ */
+declare function equalsMapLike(elementsA: unknown, elementsB: unknown, ignoreKeys?: string | string[]): boolean;
+/**
+ * Executes callback when document is ready.
+ *
+ * @param callback - Function to call
+ * @returns Handler with remove() method
+ */
+declare function onDomReady(callback: () => void): {
+    remove: () => void;
+};
+/**
+ * Parses version string into object with comparison helpers.
+ *
+ * @param version - Version string or object
+ * @returns Version object with comparison methods
+ */
+declare function parseVersionString(version: unknown): {
+    major: number;
+    minor: number;
+    patch: number;
+    toString: () => string;
+    equals: (other: unknown) => boolean;
+    largerThan: (other: unknown) => boolean;
+    largerThanOrEquals: (other: unknown) => boolean;
+    smallerThan: (other: unknown) => boolean;
+    smallerThanOrEquals: (other: unknown) => boolean;
+};
+/**
+ * Increases numeric string by 1 without limit.
+ *
+ * @param str - Numeric string
+ * @returns Increased string
+ */
+declare function increaseNumericStringByOne(str: string): string;
+/**
+ * Checks if collection contains all given values (case-insensitive).
+ *
+ * @param array - Collection to search
+ * @param values - Values to find
+ * @returns true if all found
+ */
+declare function containsAllCaseInsensitive(array: unknown, values: unknown): boolean;
+/**
+ * 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
+ */
+declare function containsAnyCaseInsensitive(array: unknown, values: unknown): boolean;
+/**
+ * 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
+ */
+declare function containsNoneCaseInsensitive(array: unknown, values: unknown): boolean;
+/**
+ * Returns string with start/end trimmed and ensures valid sentence ending.
+ *
+ * @param sentence - String to purge
+ * @returns Purged sentence
+ */
+declare function purgeSentence(sentence: unknown): string;
+/**
+ * Obtains error message from any input.
+ *
+ * @param error - Error source
+ * @returns Error message string
+ */
+declare function purgeErrorMessage(error: unknown): string;
+/**
+ * Generates permutations of names (e.g. foobar, fooBar, FooBar, foo-bar, foo_bar).
+ *
+ * @param names - Parts to combine
+ * @returns Array of permutations
+ */
+declare function generateNamePermutations(...names: unknown[]): string[];
+/**
+ * Compares two strings generated by LeUtils.timestamp(). Primarily used for sorting.
+ */
+declare function compareTimestampStrings(a: string | null, b: string | null): number;
+/**
+ * Returns true if the user is on a smartphone device (mobile).
+ */
+declare function platformIsMobile(): boolean;
+/**
+ * Returns true if the user has a cursor (mouse).
+ */
+declare function platformHasCursor(): boolean;
+/**
+ * Returns string with email purged (lowercased, trimmed).
+ */
+declare function purgeEmail(email: unknown): string;
+/**
+ * Returns true if the focus is effectively clear, meaning that the user is not typing in an input field.
+ */
+declare const isFocusClear: () => boolean;
+/**
+ * Returns the user's locale. Returns 'en-US' if it can't be determined.
+ */
+declare const getUserLocale: () => string;
+/**
+ * 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.
+ */
+declare const getUserLocaleDateFormat: () => string;
+/**
+ * Returns an empty 1x1 transparent image data URL.
+ */
+declare function getEmptyImageSrc(): string;
+/**
+ * Calculates and returns the percentage of the part and total ((part / total) * 100).
+ */
+declare function getPercentage(part: number | string, total: number | string): number;
+/**
+ * Returns the pixels of the given Image object.
+ */
+declare function getImagePixels(image: HTMLImageElement): Promise<Uint8ClampedArray>;
+/**
+ * Returns the data URL (mimetype "image/png") of a colored version of the given Image object.
+ */
+declare function getColoredImage(image: HTMLImageElement, color: string): Promise<string>;
+/**
+ * Returns the hex color of the given RGB(A).
+ */
+declare function rgbToHex(rgb: number[]): string;
+/**
+ * Returns the RGB(A) of the given hex color.
+ */
+declare function hexToRgb(hexstring: string): number[];
+/**
+ * Returns the HSL(A) of the given RGB(A).
+ */
+declare function rgbToHsl(rgb: number[]): number[];
+/**
+ * Returns the RGB(A) of the given HSL(A).
+ */
+declare const hslToRgb: (hsl: number[]) => number[];
+/**
+ * Returns the LAB(A) of the given RGB(A).
+ */
+declare function rgbToLab(rgb: number[]): number[];
+/**
+ * Returns the difference (calculated with DeltaE) of the LAB values of the given RGB values.
+ */
+declare function getDifferenceBetweenRgb(rgbA: number[], rgbB: number[]): number;
+/**
+ * Returns the difference (calculated with DeltaE) of the given LAB values.
+ */
+declare function getDifferenceBetweenLab(labA: number[], labB: number[]): number;
+/**
+ * Returns the RGB(A) between the two given RGB(A) values, based on the given percentage (0-100).
+ */
+declare function getRgbBetween(startRgb: number[], endRgb: number[], percentage: number): number[];
+/**
+ * Returns the RGB(A) of the given RGB(A) values, based on the given percentage (0-100).
+ */
+declare function getRgbOfGradient(gradient: Record<number, number[]>, percentage: number): number[];
+/**
+ * Download file from URL or data.
+ */
+declare function downloadFile(name: string, data: string | Blob): void;
+/**
+ * LocalStorage Get.
+ */
+declare function localStorageGet(key: string): string | null;
+/**
+ * LocalStorage Set.
+ */
+declare function localStorageSet(key: string, value: string): void;
+/**
+ * LocalStorage Remove.
+ */
+declare function localStorageRemove(key: string): void;
+/**
+ * Checks if given host is private.
+ */
+declare function isGivenHostPrivate(host: string): boolean;
+/**
+ * Checks if current host is private.
+ */
+declare function isCurrentHostPrivate(): boolean;
+/**
+ * Create worker thread.
+ */
+declare function createWorkerThread(name: string): {
+    worker: Worker | null;
+    sendMessage: (data: unknown, options?: {
+        timeout?: number;
+    }) => Promise<unknown>;
+};
+/**
+ * Send message to worker.
+ */
+declare const sendWorkerMessage: (workerName: string, data: unknown, options?: {
+    timeout?: number;
+}) => Promise<unknown>;
+
+/**
+ * LeTypes - Type validation and conversion utilities
+ */
+/**
+ * Checks if a value is set (not null and not undefined).
+ */
+declare function ISSET(value: unknown): boolean;
+/**
+ * Converts value to string. Returns empty string if not set.
+ */
+declare function STRING(value: unknown): string;
+/**
+ * Checks if value is an array.
+ */
+declare function IS_ARRAY(value: unknown): value is unknown[];
+/**
+ * Ensures value is an array. Wraps in array if not already one.
+ */
+declare function ARRAY(value: unknown): unknown[];
+/**
+ * Checks if value is an object (and not an array).
+ */
+declare function IS_OBJECT(value: unknown): value is Record<string, unknown>;
+/**
+ * Ensures value is an object. Returns empty object if not set.
+ */
+declare function OBJECT(value: unknown): Record<string, unknown>;
+/**
+ * Converts value to number. Returns 0 if NaN.
+ */
+declare function FLOAT(value: unknown): number;
+/**
+ * Converts value to integer. Returns 0 if NaN.
+ */
+declare function INT(value: unknown): number;
+/**
+ * Returns first set string among arguments.
+ */
+declare function STRING_ANY(...values: unknown[]): string;
+/**
+ * Returns first set float among arguments.
+ */
+declare function FLOAT_ANY(...values: unknown[]): number;
+/**
+ * Returns first set integer among arguments.
+ */
+declare function INT_ANY(...values: unknown[]): number;
+/**
+ * Converts value to boolean.
+ * Matches strings "true", "1", "yes", "on" (case-insensitive).
+ */
+declare function BOOL(value: unknown): boolean;
+/**
+ * Returns the first non-null non-undefined boolean-castable value as a boolean.
+ */
+declare function BOOL_ANY(...values: unknown[]): boolean;
+/**
+ * Lax float conversion. Strips non-numeric characters.
+ */
+declare function FLOAT_LAX(value: unknown): number;
+/**
+ * Lax integer conversion.
+ */
+declare function INT_LAX(value: unknown): number;
+/**
+ * Returns first set lax float.
+ */
+declare function FLOAT_LAX_ANY(...values: unknown[]): number;
+/**
+ * Returns first set lax integer.
+ */
+declare function INT_LAX_ANY(...values: unknown[]): number;
+
+/**
+ * A simple event emitter class that allows you to register listeners for events, emit events, and remove listeners.
+ */
+declare class EventEmitter {
+    #private;
+    /**
+     * Creates a new EventEmitter instance.
+     */
+    constructor();
+    /**
+     * Registers a listener for a specific event.
+     *
+     * @param {string} event - The name of the event to listen for.
+     * @param {Function} listener - The function to call when the event is emitted.
+     * @returns {{remove:(()=>void)}}
+     */
+    on(event: string, listener: (...args: unknown[]) => unknown): {
+        remove: () => void;
+    };
+    /**
+     * Registers a listener for a specific event, this listener will be called only once.
+     *
+     * @param {string} event - The name of the event to listen for.
+     * @param {Function} listener - The function to call when the event is emitted.
+     * @returns {{remove:()=>void}}
+     */
+    once(event: string, listener: (...args: unknown[]) => unknown): {
+        remove: () => void;
+    };
+    /**
+     * Removes a listener for a specific event.
+     *
+     * @param {string} event - The name of the event to stop listening for.
+     * @param {Function} listener - The function to remove from the event listeners.
+     */
+    off(event: string, listener: (...args: unknown[]) => unknown): void;
+    /**
+     * Emits an event, calling all registered listeners with the provided arguments.
+     *
+     * @param {string} event - The name of the event to emit.
+     * @param {...*} args - The arguments to pass to the listeners.
+     */
+    emit(event: string, ...args: unknown[]): void;
+    /**
+     * Clears all listeners for a specific event or all events if no event is specified.
+     *
+     * @param {string} [event] - The name of the event to clear listeners for. If not provided, all events will be cleared.
+     */
+    clear(event?: string): void;
+}
+
+declare class LinkedList<T> {
+    #private;
+    constructor();
+    /**
+     * Returns the number of elements in the list.
+     *
+     * @returns {number}
+     */
+    get size(): number;
+    /**
+     * Adds a new value to the beginning of the list.
+     *
+     * @param {*} value
+     */
+    unshift(value: T): void;
+    /**
+     * Adds a new value to the end of the list.
+     *
+     * @param {*} value
+     */
+    push(value: T): void;
+    /**
+     * Removes the first value from the list and returns it.
+     *
+     * @returns {*|undefined}
+     */
+    shift(): T | undefined;
+    /**
+     * Removes the last value from the list and returns it.
+     *
+     * @returns {*|undefined}
+     */
+    pop(): T | undefined;
+}
+
+/**
+ * SerializableMap class extends the native Map to provide a JSON representation.
+ *
+ * This class can only have string keys, as JSON does not support non-string keys.
+ */
+declare class SerializableMap<K, V> extends Map<K, V> {
+    /**
+     * Returns a JSON representation of the map.
+     *
+     * @returns {Record<string, V>}
+     */
+    toJSON(): Record<string, V>;
+}
+
+/**
+ * A TreeSet is a set of elements, sorted by a comparator.
+ * Binary search is used to find elements, which makes it very fast to find elements.
+ *
+ * The comparator is also used to determine if two values are equal to each other.
+ * This way, you can have values that aren't the same be treated as if they are. This can be used to deal with issues such as floating point errors for example.
+ */
+declare class TreeSet<T> {
+    #private;
+    /**
+     * Creates a new TreeSet with the given elements and comparator.
+     *
+     * @param {*[]} [elements=[]] - The initial elements of the set.
+     * @param {(valueA:*, valueB:*) => number} [comparator=defaultCompare] - The comparator function to use for sorting.
+     */
+    constructor(elements?: T[], comparator?: (valueA: T, valueB: T) => number);
+    /**
+     * @param {*} value - The value to search for in the set.
+     * @returns {{found:boolean, index:number, value:*|undefined}} - An object containing whether the value was found, the index where it would be inserted, and the value at that index (if found).
+     * @private
+     */
+    private binarySearch;
+    /**
+     * Returns the elements of the set.
+     */
+    getElements(): T[];
+    /**
+     * Returns the comparator of the set.
+     *
+     * @returns {(valueA:*, valueB:*) => number}
+     */
+    getComparator(): (valueA: T, valueB: T) => number;
+    /**
+     * Returns the size of the set.
+     *
+     * @returns {number}
+     */
+    size(): number;
+    /**
+     * Returns true if the set is empty, false otherwise.
+     *
+     * @returns {boolean}
+     */
+    isEmpty(): boolean;
+    /**
+     * Returns true if the set contains a value that is equal to the given value, returns false otherwise.
+     *
+     * @param {*} value - The value to check for in the set.
+     * @return {boolean} - True if the set contains the value, false otherwise.
+     */
+    contains(value: T): boolean;
+    /**
+     * Returns the first element of the set, or undefined if it is empty.
+     *
+     * @return {*|undefined} - The first element of the set, or undefined if it is empty.
+     */
+    first(): T | undefined;
+    /**
+     * Returns the last element of the set, or undefined if it is empty.
+     *
+     * @return {*|undefined} - The last element of the set, or undefined if it is empty.
+     */
+    last(): T | undefined;
+    /**
+     * Removes and returns the first element of the set, or undefined if it is empty.
+     *
+     * @returns {*|undefined} - The first element of the set, or undefined if it is empty.
+     */
+    pollFirst(): T | undefined;
+    /**
+     * Removes and returns the last element of the set, or undefined if it is empty.
+     *
+     * @returns {*|undefined} - The last element of the set, or undefined if it is empty.
+     */
+    pollLast(): T | undefined;
+    /**
+     * Adds the given value to the set. Will only do so if no equal value already exists.
+     * @param {*} value - The value to add to the set.
+     */
+    add(value: T): void;
+    /**
+     * Removes the given value from the set.
+     * @param value - The value to remove
+     * @returns true if removed
+     */
+    remove(value: T): boolean;
+    /**
+     * Adds all the given values to the set. Will only do so if no equal value already exists.
+     *
+     * @param {unknown} values - The values to add to the set.
+     */
+    addAll(values: unknown): void;
+    /**
+     * Returns an equal value that's already in the tree set, or undefined if no equal values in it exist.
+     *
+     * @param {*} value - The value to search for in the set.
+     * @return {*|undefined} - The equal value if found, or undefined if not found.
+     */
+    getEqualValue(value: T): T | undefined;
+    /**
+     * Returns an equal value that's already in the tree set. If no equal values in it exist, the given value will be added and returned.
+     *
+     * @param {*} value - The value to search for in the set.
+     * @return {*} - The equal value if found, or the added value if not found.
+     */
+    getEqualValueOrAdd(value: T): T;
+    /**
+     * Returns a string representation of the TreeSet.
+     *
+     * @returns {string} - A string representation of the TreeSet, including its elements and comparator.
+     */
+    toString(): string;
+    /**
+     * Returns a JSON representation of the TreeSet.
+     *
+     * @returns {Object} - An object containing the elements and comparator of the TreeSet.
+     */
+    toJSON(): {
+        elements: T[];
+        comparator: string;
+    };
+}
+
+declare const LeUtils: {
     equals(a: unknown, b: unknown): boolean;
     clone<T>(value: T): T;
     supportsEach(elements: unknown): boolean;
@@ -73,16 +1107,16 @@ export declare const LeUtils: {
         remove: () => unknown;
         isRemoved: () => boolean;
     };
-    createTransactionalValue(value?: unknown): LeUtilsFunctions.TransactionalValue;
-    isTransactionalValueValid(transactionalValue: unknown): transactionalValue is LeUtilsFunctions.TransactionalValue;
+    createTransactionalValue(value?: unknown): TransactionalValue;
+    isTransactionalValueValid(transactionalValue: unknown): transactionalValue is TransactionalValue;
     transactionalValueToString(transactionalValue: unknown): string;
-    transactionSetAndCommit(transactionalValue: LeUtilsFunctions.TransactionalValue, value: unknown): void;
-    transactionSetWithoutCommitting(transactionalValue: LeUtilsFunctions.TransactionalValue, value: unknown): string;
-    transactionCommitChange(transactionalValue: LeUtilsFunctions.TransactionalValue, changeId: string): boolean;
-    transactionCancelChange(transactionalValue: LeUtilsFunctions.TransactionalValue, changeId: string): boolean;
-    transactionIsChangeRelevant(transactionalValue: LeUtilsFunctions.TransactionalValue, changeId: string): boolean;
-    transactionGetCommittedValue(transactionalValue: LeUtilsFunctions.TransactionalValue): unknown;
-    transactionGetValue(transactionalValue: LeUtilsFunctions.TransactionalValue): unknown;
+    transactionSetAndCommit(transactionalValue: TransactionalValue, value: unknown): void;
+    transactionSetWithoutCommitting(transactionalValue: TransactionalValue, value: unknown): string;
+    transactionCommitChange(transactionalValue: TransactionalValue, changeId: string): boolean;
+    transactionCancelChange(transactionalValue: TransactionalValue, changeId: string): boolean;
+    transactionIsChangeRelevant(transactionalValue: TransactionalValue, changeId: string): boolean;
+    transactionGetCommittedValue(transactionalValue: TransactionalValue): unknown;
+    transactionGetValue(transactionalValue: TransactionalValue): unknown;
     equalsMapLike(elementsA: unknown, elementsB: unknown, ignoreKeys?: string | string[]): boolean;
     onDomReady(callback: () => void): {
         remove: () => void;
@@ -145,4 +1179,5 @@ export declare const LeUtils: {
         timeout?: number;
     }) => Promise<unknown>;
 };
-//# sourceMappingURL=index.d.ts.map
+
+export { ARRAY, BOOL, BOOL_ANY, EventEmitter, FLOAT, FLOAT_ANY, FLOAT_LAX, FLOAT_LAX_ANY, INT, INT_ANY, INT_LAX, INT_LAX_ANY, ISSET, IS_ARRAY, IS_OBJECT, LeUtils, LinkedList, OBJECT, STRING, STRING_ANY, SerializableMap, type TransactionChange, type TransactionalValue, TreeSet, atob, base64ToBytes, base64ToHex, base64ToUtf8, btoa, bytesToBase64, cachedFetch, capitalize, clone, compare, compareNaturalStrings, compareNumbers, compareNumericStrings, compareTimestampStrings, contains, containsAll, containsAllCaseInsensitive, containsAny, containsAnyCaseInsensitive, containsCaseInsensitive, containsNone, containsNoneCaseInsensitive, createTransactionalValue, createWorkerThread, downloadFile, each, eachAsync, eachIterator, endsWithAny, equals, equalsMapLike, fetch, filter, find, findIndex, findIndexValue, flattenArray, flattenToArray, generateNamePermutations, getColoredImage, getDifferenceBetweenLab, getDifferenceBetweenRgb, getEmptyImageSrc, getEmptySimplifiedCollection, getImagePixels, getObjectFieldsCount, getPercentage, getRgbBetween, getRgbOfGradient, getUserLocale, getUserLocaleDateFormat, getValueAtIndex, hexToBase64, hexToRgb, hslToRgb, increaseNumericStringByOne, isCurrentHostPrivate, isEmptyObject, isFocusClear, isGeneratorFunction, isGivenHostPrivate, isTransactionalValueValid, localStorageGet, localStorageRemove, localStorageSet, map, mapToArray, mapToArraySorted, onDomReady, parseVersionString, platformHasCursor, platformIsMobile, promiseAnimationFrameTimeout, promiseTimeout, purgeEmail, purgeErrorMessage, purgeSentence, rgbToHex, rgbToHsl, rgbToLab, sendWorkerMessage, setAnimationFrameInterval, setAnimationFrameTimeout, setInterval, setTimeout, sortKeys, startsWithAny, supportsEach, timestamp, transactionCancelChange, transactionCommitChange, transactionGetCommittedValue, transactionGetValue, transactionIsChangeRelevant, transactionSetAndCommit, transactionSetWithoutCommitting, transactionalValueToString, trim, trimEnd, trimStart, uniqueId, utf8ToBase64 };