@lowentry/utils 2.0.4 → 2.0.6

package/dist/index.js

@@ -1,13 +1,3101 @@
-// Main entry point for @lowentry/utils
-// eslint-disable-next-line @typescript-eslint/naming-convention
-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 const LeUtils = {
-    ...LeUtilsFunctions,
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/LeUtils.ts
+var LeUtils_exports = {};
+__export(LeUtils_exports, {
+  atob: () => atob,
+  base64ToBytes: () => base64ToBytes,
+  base64ToHex: () => base64ToHex,
+  base64ToUtf8: () => base64ToUtf8,
+  btoa: () => btoa,
+  bytesToBase64: () => bytesToBase64,
+  cachedFetch: () => cachedFetch,
+  capitalize: () => capitalize,
+  clone: () => clone,
+  compare: () => compare,
+  compareNaturalStrings: () => compareNaturalStrings,
+  compareNumbers: () => compareNumbers,
+  compareNumericStrings: () => compareNumericStrings,
+  compareTimestampStrings: () => compareTimestampStrings,
+  contains: () => contains,
+  containsAll: () => containsAll,
+  containsAllCaseInsensitive: () => containsAllCaseInsensitive,
+  containsAny: () => containsAny,
+  containsAnyCaseInsensitive: () => containsAnyCaseInsensitive,
+  containsCaseInsensitive: () => containsCaseInsensitive,
+  containsNone: () => containsNone,
+  containsNoneCaseInsensitive: () => containsNoneCaseInsensitive,
+  createTransactionalValue: () => createTransactionalValue,
+  createWorkerThread: () => createWorkerThread,
+  downloadFile: () => downloadFile,
+  each: () => each,
+  eachAsync: () => eachAsync,
+  eachIterator: () => eachIterator,
+  endsWithAny: () => endsWithAny,
+  equals: () => equals,
+  equalsMapLike: () => equalsMapLike,
+  fetch: () => fetch,
+  filter: () => filter,
+  find: () => find,
+  findIndex: () => findIndex,
+  findIndexValue: () => findIndexValue,
+  flattenArray: () => flattenArray,
+  flattenToArray: () => flattenToArray,
+  generateNamePermutations: () => generateNamePermutations,
+  getColoredImage: () => getColoredImage,
+  getDifferenceBetweenLab: () => getDifferenceBetweenLab,
+  getDifferenceBetweenRgb: () => getDifferenceBetweenRgb,
+  getEmptyImageSrc: () => getEmptyImageSrc,
+  getEmptySimplifiedCollection: () => getEmptySimplifiedCollection,
+  getImagePixels: () => getImagePixels,
+  getObjectFieldsCount: () => getObjectFieldsCount,
+  getPercentage: () => getPercentage,
+  getRgbBetween: () => getRgbBetween,
+  getRgbOfGradient: () => getRgbOfGradient,
+  getUserLocale: () => getUserLocale,
+  getUserLocaleDateFormat: () => getUserLocaleDateFormat,
+  getValueAtIndex: () => getValueAtIndex,
+  hexToBase64: () => hexToBase64,
+  hexToRgb: () => hexToRgb,
+  hslToRgb: () => hslToRgb,
+  increaseNumericStringByOne: () => increaseNumericStringByOne,
+  isCurrentHostPrivate: () => isCurrentHostPrivate,
+  isEmptyObject: () => isEmptyObject,
+  isFocusClear: () => isFocusClear,
+  isGeneratorFunction: () => isGeneratorFunction,
+  isGivenHostPrivate: () => isGivenHostPrivate,
+  isTransactionalValueValid: () => isTransactionalValueValid,
+  localStorageGet: () => localStorageGet,
+  localStorageRemove: () => localStorageRemove,
+  localStorageSet: () => localStorageSet,
+  map: () => map,
+  mapToArray: () => mapToArray,
+  mapToArraySorted: () => mapToArraySorted,
+  onDomReady: () => onDomReady,
+  parseVersionString: () => parseVersionString,
+  platformHasCursor: () => platformHasCursor,
+  platformIsMobile: () => platformIsMobile,
+  promiseAnimationFrameTimeout: () => promiseAnimationFrameTimeout,
+  promiseTimeout: () => promiseTimeout,
+  purgeEmail: () => purgeEmail,
+  purgeErrorMessage: () => purgeErrorMessage,
+  purgeSentence: () => purgeSentence,
+  rgbToHex: () => rgbToHex,
+  rgbToHsl: () => rgbToHsl,
+  rgbToLab: () => rgbToLab,
+  sendWorkerMessage: () => sendWorkerMessage,
+  setAnimationFrameInterval: () => setAnimationFrameInterval,
+  setAnimationFrameTimeout: () => setAnimationFrameTimeout,
+  setInterval: () => setInterval,
+  setTimeout: () => setTimeout,
+  sortKeys: () => sortKeys,
+  startsWithAny: () => startsWithAny,
+  supportsEach: () => supportsEach,
+  timestamp: () => timestamp,
+  transactionCancelChange: () => transactionCancelChange,
+  transactionCommitChange: () => transactionCommitChange,
+  transactionGetCommittedValue: () => transactionGetCommittedValue,
+  transactionGetValue: () => transactionGetValue,
+  transactionIsChangeRelevant: () => transactionIsChangeRelevant,
+  transactionSetAndCommit: () => transactionSetAndCommit,
+  transactionSetWithoutCommitting: () => transactionSetWithoutCommitting,
+  transactionalValueToString: () => transactionalValueToString,
+  trim: () => trim,
+  trimEnd: () => trimEnd,
+  trimStart: () => trimStart,
+  uniqueId: () => uniqueId,
+  utf8ToBase64: () => utf8ToBase64
+});
+
+// src/LeTypes.ts
+function ISSET(value) {
+  return value !== null && typeof value !== "undefined";
+}
+function STRING(value) {
+  if (!ISSET(value)) {
+    return "";
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (typeof value === "symbol") {
+    return value.description ?? "";
+  }
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  try {
+    if (typeof value === "object" && value !== null) {
+      if (Object.getPrototypeOf(value) === null) {
+        if ("toString" in value && typeof value.toString === "function" && value.toString !== Object.prototype.toString) {
+          try {
+            const result = value.toString();
+            if (typeof result === "string") {
+              return result;
+            }
+          } catch {
+          }
+        }
+        return "";
+      }
+      return String(value);
+    }
+    return String(value);
+  } catch {
+    return "";
+  }
+}
+function IS_ARRAY(value) {
+  return Array.isArray(value);
+}
+function ARRAY(value) {
+  if (Array.isArray(value)) {
+    return value;
+  }
+  if (typeof value === "undefined") {
+    return [];
+  }
+  return [value];
+}
+function IS_OBJECT(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function OBJECT(value) {
+  if (IS_OBJECT(value)) {
+    return value;
+  }
+  return {};
+}
+function FLOAT(value) {
+  if (typeof value === "symbol") {
+    const v2 = Number(value.description ?? "");
+    return isNaN(v2) ? 0 : v2;
+  }
+  if (typeof value === "bigint") {
+    if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
+      return Number.MAX_SAFE_INTEGER;
+    }
+    if (value < BigInt(Number.MIN_SAFE_INTEGER)) {
+      return Number.MIN_SAFE_INTEGER;
+    }
+    return Number(value);
+  }
+  const v = Number(value);
+  if (!isNaN(v)) {
+    return v;
+  }
+  return 0;
+}
+function INT(value) {
+  return Math.round(FLOAT(value));
+}
+function STRING_ANY(...values) {
+  for (const value of values) {
+    if (ISSET(value)) {
+      return STRING(value);
+    }
+  }
+  return "";
+}
+function FLOAT_ANY(...values) {
+  for (const value of values) {
+    if (ISSET(value)) {
+      const v = FLOAT(value);
+      if (v !== 0 || value === 0 || value === "0") {
+        return v;
+      }
+    }
+  }
+  return 0;
+}
+function INT_ANY(...values) {
+  return Math.round(FLOAT_ANY(...values));
+}
+function BOOL(value) {
+  return BOOL_ANY(value);
+}
+function BOOL_ANY(...values) {
+  for (const value of values) {
+    if (!ISSET(value)) {
+      continue;
+    }
+    if (typeof value === "boolean") {
+      return value;
+    }
+    if (typeof value === "number") {
+      if (!isNaN(value)) {
+        return value !== 0;
+      }
+      return false;
+    }
+    if (typeof value === "string") {
+      const s = value.toLowerCase().trim();
+      if (s === "" || s === "false" || s === "no" || s === "off" || s === "0") {
+        return false;
+      }
+      if (s === "true" || s === "yes" || s === "on" || s === "1") {
+        return true;
+      }
+      const float = Number(s);
+      if (!isNaN(float)) {
+        return float !== 0;
+      }
+      continue;
+    }
+    if (Array.isArray(value) || typeof value === "object" && value !== null) {
+      return true;
+    }
+  }
+  return false;
+}
+var REGEX_ALL_NON_FLOAT_CHARACTERS = /[^0-9.-]/g;
+function FLOAT_LAX(value) {
+  if (typeof value === "number") {
+    return isNaN(value) ? 0 : value;
+  }
+  const s = STRING(value).replace(REGEX_ALL_NON_FLOAT_CHARACTERS, "");
+  if (s === "") {
+    return 0;
+  }
+  const v = parseFloat(s);
+  if (!isNaN(v)) {
+    return v;
+  }
+  return 0;
+}
+function INT_LAX(value) {
+  return Math.round(FLOAT_LAX(value));
+}
+function FLOAT_LAX_ANY(...values) {
+  for (const value of values) {
+    if (ISSET(value)) {
+      const v = FLOAT_LAX(value);
+      if (v !== 0 || value === 0 || value === "0") {
+        return v;
+      }
+    }
+  }
+  return 0;
+}
+function INT_LAX_ANY(...values) {
+  return Math.round(FLOAT_LAX_ANY(...values));
+}
+
+// src/LeUtils.ts
+function safeGetProperty(obj, prop) {
+  if (typeof obj !== "object" && typeof obj !== "function" || obj === null) {
+    return void 0;
+  }
+  if (!(prop in obj)) {
+    return void 0;
+  }
+  const desc = Object.getOwnPropertyDescriptor(obj, prop);
+  if (desc === void 0) {
+    return obj[prop];
+  }
+  return desc.value;
+}
+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;
+}
+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;
+}
+function isRegExp(val) {
+  return val instanceof RegExp;
+}
+function isRecordLike(val) {
+  return (typeof val === "object" || typeof val === "function") && val !== null && !Array.isArray(val) && !(val instanceof Map) && !(val instanceof Set);
+}
+function isUnknownArray(val) {
+  return Array.isArray(val);
+}
+function isMapLike(val) {
+  return val instanceof Map;
+}
+function isSetLike(val) {
+  return val instanceof Set;
+}
+function isArrayBufferView(val) {
+  return ArrayBuffer.isView(val);
+}
+function hasConstructor(val) {
+  if (typeof val !== "object" && typeof val !== "function" || val === null) {
+    return false;
+  }
+  const constructorValue = safeGetProperty(val, "constructor");
+  return typeof constructorValue === "function";
+}
+function isIterable(val) {
+  if (typeof val !== "object" && typeof val !== "function" || val === null) {
+    return false;
+  }
+  if (!(Symbol.iterator in val)) {
+    return false;
+  }
+  const desc = Object.getOwnPropertyDescriptor(val, Symbol.iterator);
+  if (desc === void 0) {
+    return typeof val[Symbol.iterator] === "function";
+  }
+  return typeof desc.value === "function";
+}
+function hasForEach(val) {
+  if (typeof val !== "object" || val === null) {
+    return false;
+  }
+  const forEach = safeGetProperty(val, "forEach");
+  return typeof forEach === "function";
+}
+function isPlainObject(val) {
+  if (typeof val !== "object" || val === null) {
+    return false;
+  }
+  const constructor = safeGetProperty(val, "constructor");
+  return constructor === Object;
+}
+function isPair(val) {
+  if (!Array.isArray(val)) {
+    return false;
+  }
+  return val.length === 2;
+}
+function isPromise(val) {
+  if (typeof val !== "object" || val === null) {
+    return false;
+  }
+  const then = safeGetProperty(val, "then");
+  return typeof then === "function";
+}
+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;
+}
+function hasPerformanceTiming(perf) {
+  if (typeof perf !== "object" || perf === null) {
+    return false;
+  }
+  return true;
+}
+function hasSetTimeout(global) {
+  if (typeof global !== "object" || global === null) {
+    return false;
+  }
+  const setTimeout2 = safeGetProperty(global, "setTimeout");
+  return typeof setTimeout2 === "function";
+}
+function hasSetInterval(global) {
+  if (typeof global !== "object" || global === null) {
+    return false;
+  }
+  const setInterval2 = safeGetProperty(global, "setInterval");
+  return typeof setInterval2 === "function";
+}
+function isNumberArray(val) {
+  if (!Array.isArray(val)) {
+    return false;
+  }
+  return val.every((item) => typeof item === "number");
+}
+function hasNavigatorVendor(nav) {
+  if (typeof nav !== "object" || nav === null) {
+    return false;
+  }
+  return true;
+}
+function hasOpera(global) {
+  if (typeof global !== "object" || global === null) {
+    return false;
+  }
+  return true;
+}
+function hasNavigatorLanguages(nav) {
+  if (typeof nav !== "object" || nav === null) {
+    return false;
+  }
+  return true;
+}
+function hasIntl(global) {
+  if (typeof global !== "object" || global === null) {
+    return false;
+  }
+  return true;
+}
+function hasId(obj) {
+  if (typeof obj !== "object" || obj === null) {
+    return false;
+  }
+  const id = safeGetProperty(obj, "id");
+  return typeof id === "string";
+}
+function hasSendMessage(worker) {
+  if (typeof worker !== "object" || worker === null) {
+    return false;
+  }
+  const sendMessage = safeGetProperty(worker, "sendMessage");
+  return typeof sendMessage === "function";
+}
+function hasErrorMessage(err) {
+  if (typeof err !== "object" || err === null) {
+    return false;
+  }
+  const message = safeGetProperty(err, "message");
+  return typeof message === "string";
+}
+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 !== void 0 && minor !== void 0 && patch !== void 0;
+}
+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 & 255;
+    bytes[i] = rightByte;
+    x = Math.floor(x / 256);
+  }
+  return bytes;
+}
+function equals(a, b) {
+  const seen = /* @__PURE__ */ 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);
+      const constructorAValue = safeGetProperty(valA, "constructor");
+      const constructorBValue = safeGetProperty(valB, "constructor");
+      if (constructorAValue !== constructorBValue) {
+        return false;
+      }
+      if (Array.isArray(valA)) {
+        if (!Array.isArray(valB)) {
+          return false;
+        }
+        const length2 = valA.length;
+        if (length2 !== valB.length) {
+          return false;
+        }
+        for (let i = length2; 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;
+          }
+          const a2 = valA;
+          const b2 = valB;
+          for (let i = lengthA; i-- !== 0; ) {
+            if (a2[i] !== b2[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)) {
+          return false;
+        }
+        return valA.source === valB.source && valA.flags === valB.flags;
+      }
+      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) {
+          console.error("LeUtils.equals: error calling valueOf - invalid data or implementation", e);
+        }
+      }
+      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) {
+          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)) {
+        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;
+    }
+    return valA !== valA && valB !== valB;
+  }
+  return recursiveEquals(a, b);
+}
+function clone(value) {
+  const seen = /* @__PURE__ */ 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 = /* @__PURE__ */ 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 = /* @__PURE__ */ new Set();
+      result = resultSet;
+      seen.set(val, result);
+      for (const v of val.values()) {
+        resultSet.add(recursiveClone(v));
+      }
+    } else if (isArrayBufferView(val)) {
+      if (!hasConstructor(val)) {
+        console.error("LeUtils.clone: ArrayBufferView value does not have constructor property");
+        return value;
+      }
+      const Constructor = val.constructor;
+      const buffer = val.buffer.slice(val.byteOffset, val.byteOffset + val.byteLength);
+      result = new Constructor(buffer);
+      seen.set(val, result);
+    } else if (isRecordLike(val)) {
+      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 {
+      console.error("LeUtils.clone: unsupported object type, cannot clone properly", val);
+      return value;
+    }
+    return result;
+  }
+  const cloned = recursiveClone(value);
+  if (cloned === void 0 && value !== void 0) {
+    console.error("LeUtils.clone: clone returned undefined for non-undefined input - cloning failed");
+    return value;
+  }
+  return cloned;
+}
+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"));
+}
+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) {
+    if (isRecordLike(elements)) {
+      for (const i in elements) {
+        if (optionalSkipHasOwnPropertyCheck === true || Object.prototype.hasOwnProperty.call(elements, i)) {
+          yield [elements[i], i];
+        }
+      }
+      return;
+    }
+  }
+  console.error("LeUtils.eachIterator: executed on invalid/unsupported type", typeof elements, elements);
+}
+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;
+}
+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 = /* @__PURE__ */ 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;
+}
+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 = /* @__PURE__ */ 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 {
+    console.error("LeUtils.getEmptySimplifiedCollection: executed on invalid/unsupported type", typeof elements, elements);
+    return [false, [], (_value, _index) => {
+    }];
+  }
+  return [true, collection, add];
+}
+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;
+}
+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;
+}
+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) {
+      result.push(value);
+    } else {
+      result.push(callback.call(value, value, index));
+    }
+  }, optionalSkipHasOwnPropertyCheck);
+  return result;
+}
+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;
+}
+function getValueAtIndex(elements, index, optionalSkipHasOwnPropertyCheck = false) {
+  if (elements === null || typeof elements === "undefined") {
+    return void 0;
+  }
+  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 void 0;
+    }
+    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)) {
+      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 void 0;
+        }
+        return elements[numIndex];
+      }
+      return void 0;
+    }
+    if (isIterable(elements)) {
+      let i = 0;
+      for (const value of elements) {
+        if (i === index) {
+          return value;
+        }
+        i++;
+      }
+      return void 0;
+    }
+    if (hasForEach(elements)) {
+      let result = void 0;
+      let shouldContinue = true;
+      elements.forEach((value, i) => {
+        if (shouldContinue) {
+          if (i === index) {
+            result = value;
+            shouldContinue = false;
+          }
+        }
+      });
+      return result;
+    }
+  }
+  if (typeof elements === "object" || typeof elements === "function") {
+    if (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 void 0;
+  }
+  return void 0;
+}
+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;
+}
+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;
+}
+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;
+}
+function compare(a, b) {
+  const compareResult = (valueA, valueB) => {
+    if (valueA < valueB) {
+      return -1;
+    }
+    if (valueA > valueB) {
+      return 1;
+    }
+    return 0;
+  };
+  return compareResult(a, b);
+}
+function compareNumbers(a, b) {
+  return a - b;
+}
+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;
+}
+function compareNaturalStrings(a, b) {
+  const re = /(\d+|\D+)/g;
+  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;
+    }
+    const nx = parseInt(x, 10);
+    const ny = parseInt(y, 10);
+    if (!isNaN(nx) && !isNaN(ny)) {
+      return nx - ny;
+    }
+    return x < y ? -1 : 1;
+  }
+  return aTokens.length - bTokens.length;
+}
+function isEmptyObject(obj, optionalSkipHasOwnPropertyCheck = false) {
+  if (obj === null || typeof obj !== "object") {
+    return true;
+  }
+  if (isRecordLike(obj)) {
+    for (const field in obj) {
+      if (optionalSkipHasOwnPropertyCheck === true || Object.prototype.hasOwnProperty.call(obj, field)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function getObjectFieldsCount(obj, optionalSkipHasOwnPropertyCheck = false) {
+  if (obj === null || typeof obj !== "object") {
+    return 0;
+  }
+  let count = 0;
+  if (isRecordLike(obj)) {
+    for (const field in obj) {
+      if (optionalSkipHasOwnPropertyCheck === true || Object.prototype.hasOwnProperty.call(obj, field)) {
+        count++;
+      }
+    }
+  }
+  return count;
+}
+function capitalize(string) {
+  const str = STRING(string).trim();
+  if (str.length <= 0) {
+    return str;
+  }
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+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;
+}
+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;
+}
+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;
+}
+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;
+}
+function trim(string, trimCharsStringOrArray) {
+  return trimStart(trimEnd(string, trimCharsStringOrArray), trimCharsStringOrArray);
+}
+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;
+}
+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;
+}
+function containsAll(array, values) {
+  if (!array) {
+    return false;
+  }
+  let result = true;
+  each(values, (value) => {
+    if (!contains(array, value)) {
+      result = false;
+      return false;
+    }
+  });
+  return result;
+}
+function containsAny(array, values) {
+  if (!array) {
+    return false;
+  }
+  let result = false;
+  each(values, (value) => {
+    if (contains(array, value)) {
+      result = true;
+      return false;
+    }
+  });
+  return result;
+}
+function containsNone(array, values) {
+  if (!array) {
+    return true;
+  }
+  let result = true;
+  each(values, (value) => {
+    if (contains(array, value)) {
+      result = false;
+      return false;
+    }
+  });
+  return result;
+}
+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) => {
+    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 {
+      if (callback.call(value, value, index)) {
+        result = { index, value };
+        return false;
+      }
+    }
+  }, optionalSkipHasOwnPropertyCheck);
+  return result;
+}
+function findIndex(elements, callback, optionalSkipHasOwnPropertyCheck = false) {
+  return findIndexValue(elements, callback, optionalSkipHasOwnPropertyCheck)?.index ?? null;
+}
+function find(elements, callback, optionalSkipHasOwnPropertyCheck = false) {
+  return findIndexValue(elements, callback, optionalSkipHasOwnPropertyCheck)?.value ?? null;
+}
+var uniqueId = /* @__PURE__ */ (() => {
+  let previousUniqueIdsTime = null;
+  const previousUniqueIds = /* @__PURE__ */ new Map();
+  const generateUniqueId = () => {
+    let now = null;
+    try {
+      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 {
+    }
+    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 {
+    }
+    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;
+      }
+    }
+  };
+})();
+var timestamp = /* @__PURE__ */ (() => {
+  return (now = null) => {
+    let time;
+    if (ISSET(now)) {
+      time = FLOAT_LAX(now);
+    } else {
+      let performanceNow = null;
+      try {
+        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") : void 0;
+        const nowFunc = performance && hasPerformanceTiming(performance) && "now" in performance ? safeGetProperty(performance, "now") : void 0;
+        const timeOriginVal = typeof timeOrigin === "number" ? timeOrigin : 0;
+        const nowFuncVal = typeof nowFunc === "function" ? nowFunc() : 0;
+        performanceNow = timeOriginVal || timingNavStart || 0;
+        performanceNow = performanceNow + nowFuncVal;
+      } catch {
+      }
+      time = performanceNow || Date.now();
+    }
+    time = Math.round(time);
+    const nowBytes = numberToBytes(time);
+    return bytesToBase64(nowBytes).replaceAll("=", "").replaceAll("+", "-").replaceAll("/", "_");
+  };
+})();
+var isGeneratorFunction = (() => {
+  const GeneratorFunction = (function* () {
+  }).constructor;
+  const AsyncGeneratorFunction = (async function* () {
+  }).constructor;
+  return (func) => {
+    if (typeof func !== "function") {
+      return false;
+    }
+    if (!hasConstructor(func)) {
+      return false;
+    }
+    const constructor = func.constructor;
+    return constructor === GeneratorFunction || constructor === AsyncGeneratorFunction;
+  };
+})();
+function btoa(str) {
+  if (typeof globalThis.btoa === "function") {
+    return globalThis.btoa(str);
+  }
+  if (typeof globalThis.Buffer?.from === "function") {
+    return globalThis.Buffer.from(str, "binary").toString("base64");
+  }
+  throw new Error("LeUtils.btoa: No btoa implementation found");
+}
+function atob(str) {
+  if (typeof globalThis.atob === "function") {
+    return globalThis.atob(str);
+  }
+  if (typeof globalThis.Buffer?.from === "function") {
+    return globalThis.Buffer.from(str, "base64").toString("binary");
+  }
+  throw new Error("LeUtils.atob: No atob implementation found");
+}
+function utf8ToBase64(string) {
+  return btoa(encodeURIComponent(string).replace(/%([0-9A-F]{2})/g, (_match, p1) => String.fromCharCode(parseInt(p1, 16))));
+}
+function base64ToUtf8(base64string) {
+  return decodeURIComponent(atob(base64string.trim()).split("").map((c) => "%" + ("00" + c.charCodeAt(0).toString(16)).slice(-2)).join(""));
+}
+function base64ToHex(base64string) {
+  return atob(base64string.trim()).split("").map((c) => ("0" + c.charCodeAt(0).toString(16)).slice(-2)).join("");
+}
+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);
+}
+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;
+}
+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);
+}
+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;
+  if (!hasSetTimeout(globalThis)) {
+    console.error("LeUtils.setTimeout: globalThis.setTimeout is not available");
+    return { remove: () => {
+    } };
+  }
+  let handler = globalThis.setTimeout(() => {
+    const currentTime = globalThis?.performance?.now?.() ?? 0;
+    try {
+      callback((currentTime - lastTime) / 1e3);
+    } catch (e) {
+      console.error(e);
+    }
+    lastTime = currentTime;
+  }, msVal);
+  return {
+    remove: () => {
+      if (handler !== null) {
+        globalThis.clearTimeout(handler);
+        handler = null;
+      }
+    }
+  };
+}
+function setInterval(callback, intervalMs = 1e3, fireImmediately = false) {
+  const msVal = FLOAT_LAX_ANY(intervalMs, 1e3);
+  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;
+  if (!hasSetInterval(globalThis)) {
+    console.error("LeUtils.setInterval: globalThis.setInterval is not available");
+    return { remove: () => {
+    } };
+  }
+  let handler = globalThis.setInterval(() => {
+    const currentTime = globalThis?.performance?.now?.() ?? 0;
+    try {
+      callback((currentTime - lastTime) / 1e3);
+    } catch (e) {
+      console.error(e);
+    }
+    lastTime = currentTime;
+  }, msVal);
+  return {
+    remove: () => {
+      if (handler !== null) {
+        globalThis.clearInterval(handler);
+        handler = null;
+      }
+    }
+  };
+}
+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) / 1e3);
+        } 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;
+      }
+    }
+  };
+}
+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 / 1e3);
+        } 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;
+      }
+    }
+  };
+}
+function promiseTimeout(ms) {
+  const msVal = FLOAT_LAX(ms);
+  if (msVal <= 0) {
+    return Promise.resolve(0);
+  }
+  return new Promise((resolve) => setTimeout(resolve, msVal));
+}
+function promiseAnimationFrameTimeout(frames) {
+  const iFrames = INT_LAX(frames);
+  if (iFrames <= 0) {
+    return Promise.resolve(0);
+  }
+  return new Promise((resolve) => setAnimationFrameTimeout(resolve, iFrames));
+}
+function fetch(url, options) {
+  let currentRetries = 0;
+  const retriesValue = isRecordLike(options) && "retries" in options ? options.retries : void 0;
+  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: void 0,
+          // @ts-ignore -- removing custom options from standard fetch options
+          delay: void 0
+        });
+        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++;
+        const delayValue = isRecordLike(options) && "delay" in options ? options.delay : void 0;
+        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: () => void 0,
+    isRemoved: () => false
+  };
+  result.then = (...args) => {
+    if (isPromise(promise)) {
+      const thenResult = promise.then(...args);
+      promise = thenResult;
+    }
+    return result;
+  };
+  result.catch = (...args) => {
+    if (isPromise(promise)) {
+      const catchResult = promise.catch(...args);
+      promise = catchResult;
+    }
+    return result;
+  };
+  result.finally = (...args) => {
+    if (isPromise(promise)) {
+      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;
+}
+var cachedFetch = /* @__PURE__ */ (() => {
+  const cache = /* @__PURE__ */ new Map();
+  return async (url, options, responseFunction) => {
+    if (cache.has(url)) {
+      const result = cache.get(url);
+      if (isRecordLike(result)) {
+        if ("data" in result && result.data !== void 0) {
+          return result.data;
+        }
+        if ("promise" in result && isPromise(result.promise)) {
+          return await result.promise;
+        }
+        if ("error" in result && result.error !== void 0) {
+          throw result.error;
+        }
+      }
+      return null;
+    }
+    const fetchOptions = isRecordLike(options) ? options : void 0;
+    const fetchPromise = globalThis.fetch(url, fetchOptions);
+    const promise = fetchPromise.then(async (response) => {
+      const data = responseFunction ? await responseFunction(response) : response;
+      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;
+  };
+})();
+function createTransactionalValue(value) {
+  return {
+    value: typeof value === "undefined" ? null : value,
+    changes: []
+  };
+}
+function isTransactionalValueValid(transactionalValue) {
+  return typeof transactionalValue === "object" && transactionalValue !== null && isTransactionalValue(transactionalValue);
+}
+function checkTransactionalValue(transactionalValue) {
+  if (!isTransactionalValueValid(transactionalValue)) {
+    throw new Error("Invalid TransactionalValue provided");
+  }
+}
+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;
+}
+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 + ")";
+}
+function transactionSetAndCommit(transactionalValue, value) {
+  checkTransactionalValue(transactionalValue);
+  transactionalValue.value = typeof value === "undefined" ? null : value;
+  transactionalValue.changes = [];
+}
+function transactionSetWithoutCommitting(transactionalValue, value) {
+  checkTransactionalValue(transactionalValue);
+  const id = uniqueId();
+  transactionalValue.changes.push({ id, value: typeof value === "undefined" ? null : value });
+  return id;
+}
+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;
+}
+function transactionCancelChange(transactionalValue, changeId) {
+  checkTransactionalValue(transactionalValue);
+  const result = findTransactionalValueChange(transactionalValue, changeId);
+  if (result === null) {
+    return false;
+  }
+  transactionalValue.changes.splice(result.index, 1);
+  return true;
+}
+function transactionIsChangeRelevant(transactionalValue, changeId) {
+  checkTransactionalValue(transactionalValue);
+  return findTransactionalValueChange(transactionalValue, changeId) !== null;
+}
+function transactionGetCommittedValue(transactionalValue) {
+  checkTransactionalValue(transactionalValue);
+  return transactionalValue.value;
+}
+function transactionGetValue(transactionalValue) {
+  checkTransactionalValue(transactionalValue);
+  if (transactionalValue.changes.length <= 0) {
+    return transactionalValue.value;
+  }
+  return transactionalValue.changes[transactionalValue.changes.length - 1].value;
+}
+function equalsMapLike(elementsA, elementsB, ignoreKeys = []) {
+  const sortKeyValueArrays = (pairA, pairB) => {
+    if (isPair(pairA) && isPair(pairB)) {
+      return compare(pairA[0], pairB[0]);
+    }
+    return 0;
+  };
+  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;
+}
+function onDomReady(callback) {
+  if (!globalThis?.document?.addEventListener) {
+    console.warn("LeUtils.onDomReady: No document found.");
+    return { remove: () => {
+    } };
+  }
+  if (globalThis.document.readyState === "interactive" || globalThis.document.readyState === "complete") {
+    return setTimeout(callback, 0);
+  }
+  let listening = true;
+  const wrapper = () => {
+    if (listening) {
+      listening = false;
+      globalThis.document.removeEventListener("DOMContentLoaded", wrapper);
+      callback();
+    }
+  };
+  globalThis.document.addEventListener("DOMContentLoaded", wrapper);
+  return {
+    remove: () => {
+      if (listening) {
+        listening = false;
+        globalThis.document.removeEventListener("DOMContentLoaded", wrapper);
+      }
+    }
+  };
+}
+function parseVersionString(version) {
+  if (isVersionObject(version)) {
+    const major2 = INT_LAX(version.major);
+    const minor2 = INT_LAX(version.minor);
+    const patch2 = INT_LAX(version.patch);
+    return {
+      major: major2,
+      minor: minor2,
+      patch: patch2,
+      toString: () => `${major2}.${minor2}.${patch2}`,
+      equals: (other) => {
+        if (!isVersionObject(other)) {
+          return false;
+        }
+        return major2 === INT_LAX(other.major) && minor2 === INT_LAX(other.minor) && patch2 === 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 major2 > otherMajor || major2 === otherMajor && minor2 > otherMinor || major2 === otherMajor && minor2 === otherMinor && patch2 > 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 major2 > otherMajor || major2 === otherMajor && minor2 > otherMinor || major2 === otherMajor && minor2 === otherMinor && patch2 >= 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 !(major2 > otherMajor || major2 === otherMajor && minor2 > otherMinor || major2 === otherMajor && minor2 === otherMinor && patch2 >= 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 !(major2 > otherMajor || major2 === otherMajor && minor2 > otherMinor || major2 === otherMajor && minor2 === otherMinor && patch2 > 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;
+}
+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("");
+}
+function containsAllCaseInsensitive(array, values) {
+  if (!array) return false;
+  let result = true;
+  each(values, (v) => {
+    if (!containsCaseInsensitive(array, v)) {
+      result = false;
+      return false;
+    }
+  });
+  return result;
+}
+function containsAnyCaseInsensitive(array, values) {
+  if (!array) return false;
+  let result = false;
+  each(values, (v) => {
+    if (containsCaseInsensitive(array, v)) {
+      result = true;
+      return false;
+    }
+  });
+  return result;
+}
+function containsNoneCaseInsensitive(array, values) {
+  if (!array) return true;
+  let result = true;
+  each(values, (v) => {
+    if (containsCaseInsensitive(array, v)) {
+      result = false;
+      return false;
+    }
+  });
+  return result;
+}
+function purgeSentence(sentence) {
+  let s = trimEnd(STRING(sentence).trim(), ".: \r\n	");
+  s += endsWithAny(s, "!?;") ? "" : ".";
+  return s;
+}
+function purgeErrorMessage(error) {
+  let err = error;
+  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();
+}
+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(""));
+    results.push(n.map(capitalize).join(""));
+  }
+  if (n.length > 1) {
+    results.push([n[0]].concat(n.slice(1).map(capitalize)).join(""));
+    results.push(n.join("-"));
+    results.push(n.join("_"));
+  }
+  return results;
+}
+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;
+  }
+}
+function platformIsMobile() {
+  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));
+}
+function platformHasCursor() {
+  return !platformIsMobile() && !globalThis?.matchMedia?.("(any-hover: none)")?.matches;
+}
+function purgeEmail(email) {
+  const e = STRING(email).trim().toLowerCase().replace(/\s/g, "");
+  if (!e.includes("@") || !e.includes(".")) {
+    return "";
+  }
+  return e;
+}
+var isFocusClear = /* @__PURE__ */ (() => {
+  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() ?? ""));
+})();
+var getUserLocale = /* @__PURE__ */ (() => {
+  let userLocale = null;
+  return () => {
+    if (userLocale === null) {
+      userLocale = (() => {
+        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;
+  };
+})();
+var getUserLocaleDateFormat = /* @__PURE__ */ (() => {
+  let userLocaleDateFormat = null;
+  return () => {
+    if (userLocaleDateFormat === null) {
+      userLocaleDateFormat = (() => {
+        let char = "/";
+        if (hasIntl(globalThis) && globalThis.Intl && "DateTimeFormat" in globalThis.Intl) {
+          const DateTimeFormat = safeGetProperty(globalThis.Intl, "DateTimeFormat");
+          if (typeof DateTimeFormat === "function") {
+            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;
+  };
+})();
+function getEmptyImageSrc() {
+  return "data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==";
+}
+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));
+}
+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);
+  }
+}
+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);
+  }
+}
+function rgbToHex(rgb) {
+  return "#" + rgb.map((x) => {
+    const hex = x.toString(16);
+    return hex.length === 1 ? "0" + hex : hex;
+  }).join("");
+}
+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]] : []
+  ];
+}
+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] : []];
+}
+var hslToRgb = /* @__PURE__ */ (() => {
+  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))));
+  };
+})();
+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 > 8856e-6 ? Math.pow(x, 1 / 3) : 7.787 * x + 16 / 116;
+  y = y > 8856e-6 ? Math.pow(y, 1 / 3) : 7.787 * y + 16 / 116;
+  z = z > 8856e-6 ? 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] : []];
+}
+function getDifferenceBetweenRgb(rgbA, rgbB) {
+  const labA = rgbToLab(rgbA);
+  const labB = rgbToLab(rgbB);
+  return getDifferenceBetweenLab(labA, labB);
+}
+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.045 * c1;
+  const sh = 1 + 0.015 * c1;
+  const deltaLKlsl = deltaL / 1;
+  const deltaCkcsc = deltaC / sc;
+  const deltaHkhsh = deltaH / sh;
+  const i = deltaLKlsl * deltaLKlsl + deltaCkcsc * deltaCkcsc + deltaHkhsh * deltaHkhsh;
+  return i < 0 ? 0 : Math.sqrt(i);
+}
+function getRgbBetween(startRgb, endRgb, percentage) {
+  const p = FLOAT_LAX(percentage);
+  const partEnd = Math.max(0, Math.min(1, p / 100));
+  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;
+}
+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) {
+    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;
+  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);
+}
+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);
+}
+function localStorageGet(key) {
+  try {
+    return globalThis.localStorage?.getItem(key) ?? null;
+  } catch {
+    return null;
+  }
+}
+function localStorageSet(key, value) {
+  try {
+    globalThis.localStorage?.setItem(key, value);
+  } catch {
+  }
+}
+function localStorageRemove(key) {
+  try {
+    globalThis.localStorage?.removeItem(key);
+  } catch {
+  }
+}
+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);
+}
+function isCurrentHostPrivate() {
+  return isGivenHostPrivate(globalThis?.location?.hostname);
+}
+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 = /* @__PURE__ */ 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 ?? 1e4);
+      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;
+    if (hasId(data)) {
+      const callback = listeners.get(data.id);
+      if (callback) {
+        listeners.delete(data.id);
+        callback(data);
+      }
+    }
+  };
+  return { worker, sendMessage };
+}
+var sendWorkerMessage = /* @__PURE__ */ (() => {
+  const workers = /* @__PURE__ */ new Map();
+  return (workerName, data, options) => {
+    if (!workers.has(workerName)) {
+      workers.set(workerName, createWorkerThread(workerName));
+    }
+    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"));
+  };
+})();
+
+// src/classes/EventEmitter.ts
+var EventEmitter = class {
+  #events;
+  /**
+   * Creates a new EventEmitter instance.
+   */
+  constructor() {
+    this.#events = /* @__PURE__ */ new Map();
+  }
+  /**
+   * 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, listener) {
+    if (!this.#events.has(event)) {
+      this.#events.set(event, /* @__PURE__ */ new Set());
+    }
+    this.#events.get(event).add(listener);
+    return {
+      remove: () => this.off(event, listener)
+    };
+  }
+  /**
+   * 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, listener) {
+    const wrapper = (...args) => {
+      this.off(event, wrapper);
+      listener(...args);
+    };
+    this.on(event, wrapper);
+    return {
+      remove: () => this.off(event, wrapper)
+    };
+  }
+  /**
+   * 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, listener) {
+    const listeners = this.#events.get(event);
+    if (listeners) {
+      listeners.delete(listener);
+      if (listeners.size === 0) {
+        this.#events.delete(event);
+      }
+    }
+  }
+  /**
+   * 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, ...args) {
+    const listeners = this.#events.get(event);
+    if (listeners) {
+      const snapshot = Array.from(listeners);
+      for (const listener of snapshot) {
+        try {
+          listener(...args);
+        } catch (err) {
+          console.error(`Error in listener for "${event}":`, err);
+        }
+      }
+    }
+  }
+  /**
+   * 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) {
+    if (typeof event !== "undefined") {
+      this.#events.delete(event);
+    } else {
+      this.#events.clear();
+    }
+  }
+};
+
+// src/classes/LinkedList.ts
+var LinkedListNode = class {
+  value;
+  next = null;
+  previous = null;
+  constructor(value) {
+    this.value = value;
+  }
+};
+var LinkedList = class {
+  #head = null;
+  #tail = null;
+  #size = 0;
+  constructor() {
+  }
+  /**
+   * Returns the number of elements in the list.
+   *
+   * @returns {number}
+   */
+  get size() {
+    return this.#size;
+  }
+  /**
+   * Adds a new value to the beginning of the list.
+   *
+   * @param {*} value
+   */
+  unshift(value) {
+    const newNode = new LinkedListNode(value);
+    if (this.#head === null) {
+      this.#head = newNode;
+      this.#tail = newNode;
+    } else {
+      newNode.next = this.#head;
+      this.#head.previous = newNode;
+      this.#head = newNode;
+    }
+    this.#size++;
+  }
+  /**
+   * Adds a new value to the end of the list.
+   *
+   * @param {*} value
+   */
+  push(value) {
+    const newNode = new LinkedListNode(value);
+    if (this.#tail === null) {
+      this.#head = newNode;
+      this.#tail = newNode;
+    } else {
+      newNode.previous = this.#tail;
+      this.#tail.next = newNode;
+      this.#tail = newNode;
+    }
+    this.#size++;
+  }
+  /**
+   * Removes the first value from the list and returns it.
+   *
+   * @returns {*|undefined}
+   */
+  shift() {
+    if (this.#head === null) {
+      return void 0;
+    }
+    const value = this.#head.value;
+    this.#head = this.#head.next;
+    if (this.#head !== null) {
+      this.#head.previous = null;
+    } else {
+      this.#tail = null;
+    }
+    this.#size--;
+    return value;
+  }
+  /**
+   * Removes the last value from the list and returns it.
+   *
+   * @returns {*|undefined}
+   */
+  pop() {
+    if (this.#tail === null) {
+      return void 0;
+    }
+    const value = this.#tail.value;
+    this.#tail = this.#tail.previous;
+    if (this.#tail !== null) {
+      this.#tail.next = null;
+    } else {
+      this.#head = null;
+    }
+    this.#size--;
+    return value;
+  }
+};
+
+// src/classes/SerializableMap.ts
+var SerializableMap = class extends Map {
+  /**
+   * Returns a JSON representation of the map.
+   *
+   * @returns {Record<string, V>}
+   */
+  toJSON() {
+    if (this && typeof this === "object" && Symbol.iterator in this) {
+      const entries = [];
+      for (const [key, value] of this) {
+        const stringKey = typeof key === "string" ? key : String(key);
+        entries.push([stringKey, value]);
+      }
+      return Object.fromEntries(entries);
+    }
+    return {};
+  }
+};
+
+// src/classes/TreeSet.ts
+var TreeSet = class {
+  #elements;
+  #comparator;
+  /**
+   * 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, comparator) {
+    this.#comparator = comparator || compare;
+    this.#elements = elements ? [...elements] : [];
+    this.#elements.sort(this.#comparator);
+  }
+  /**
+   * @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
+   */
+  binarySearch(value) {
+    let low = 0;
+    let high = this.#elements.length - 1;
+    while (low <= high) {
+      const mid = Math.floor((low + high) / 2);
+      const midValue = this.#elements[mid];
+      const cmp = this.#comparator(midValue, value);
+      if (cmp < 0) {
+        low = mid + 1;
+      } else if (cmp > 0) {
+        high = mid - 1;
+      } else {
+        return { found: true, index: mid, value: midValue };
+      }
+    }
+    return { found: false, index: low, value: void 0 };
+  }
+  /**
+   * Returns the elements of the set.
+   */
+  getElements() {
+    return this.#elements;
+  }
+  /**
+   * Returns the comparator of the set.
+   *
+   * @returns {(valueA:*, valueB:*) => number}
+   */
+  getComparator() {
+    return this.#comparator;
+  }
+  /**
+   * Returns the size of the set.
+   *
+   * @returns {number}
+   */
+  size() {
+    return this.#elements.length;
+  }
+  /**
+   * Returns true if the set is empty, false otherwise.
+   *
+   * @returns {boolean}
+   */
+  isEmpty() {
+    return this.#elements.length <= 0;
+  }
+  /**
+   * 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) {
+    return this.binarySearch(value).found;
+  }
+  /**
+   * 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() {
+    return this.#elements.length > 0 ? this.#elements[0] : void 0;
+  }
+  /**
+   * 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() {
+    return this.#elements.length > 0 ? this.#elements[this.#elements.length - 1] : void 0;
+  }
+  /**
+   * 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() {
+    return this.#elements.length > 0 ? this.#elements.splice(0, 1)[0] : void 0;
+  }
+  /**
+   * 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() {
+    return this.#elements.length > 0 ? this.#elements.splice(this.#elements.length - 1, 1)[0] : void 0;
+  }
+  /**
+   * 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) {
+    const result = this.binarySearch(value);
+    if (result.found) {
+      return;
+    }
+    this.#elements.splice(result.index, 0, value);
+  }
+  /**
+   * Removes the given value from the set.
+   * @param value - The value to remove
+   * @returns true if removed
+   */
+  remove(value) {
+    const result = this.binarySearch(value);
+    if (result.found) {
+      this.#elements.splice(result.index, 1);
+      return true;
+    }
+    return false;
+  }
+  /**
+   * 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) {
+    each(values, (v) => {
+      if (v !== null && v !== void 0) {
+        Function.prototype.apply.call(this.add, this, [v]);
+      }
+    });
+  }
+  /**
+   * 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) {
+    const result = this.binarySearch(value);
+    if (result.found) {
+      return result.value;
+    }
+    return void 0;
+  }
+  /**
+   * 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) {
+    const result = this.binarySearch(value);
+    if (result.found) {
+      return result.value;
+    }
+    this.#elements.splice(result.index, 0, value);
+    return value;
+  }
+  /**
+   * Returns a string representation of the TreeSet.
+   *
+   * @returns {string} - A string representation of the TreeSet, including its elements and comparator.
+   */
+  toString() {
+    return `TreeSet{elements:${this.#elements}, comparator:${this.#comparator}}`;
+  }
+  /**
+   * Returns a JSON representation of the TreeSet.
+   *
+   * @returns {Object} - An object containing the elements and comparator of the TreeSet.
+   */
+  toJSON() {
+    return {
+      elements: this.#elements,
+      comparator: this.#comparator.toString()
+    };
+  }
+};
+
+// src/index.ts
+var LeUtils = {
+  ...LeUtils_exports
+};
+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,
+  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
 };
 //# sourceMappingURL=index.js.map