@sv443-network/userutils 9.4.3 → 10.0.0

package/dist/UserUtils.cjs

@@ -0,0 +1,1889 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// lib/index.ts
+var lib_exports = {};
+__export(lib_exports, {
+  Dialog: () => Dialog,
+  GMStorageEngine: () => GMStorageEngine,
+  Mixins: () => Mixins,
+  PlatformError: () => PlatformError,
+  SelectorObserver: () => SelectorObserver,
+  addGlobalStyle: () => addGlobalStyle,
+  addParent: () => addParent,
+  currentDialogId: () => currentDialogId,
+  defaultDialogCss: () => defaultDialogCss,
+  defaultStrings: () => defaultStrings,
+  getSiblingsFrame: () => getSiblingsFrame,
+  getUnsafeWindow: () => getUnsafeWindow,
+  interceptEvent: () => interceptEvent,
+  interceptWindowEvent: () => interceptWindowEvent,
+  isDomLoaded: () => isDomLoaded,
+  isScrollable: () => isScrollable,
+  observeElementProp: () => observeElementProp,
+  onDomLoad: () => onDomLoad,
+  openDialogs: () => openDialogs,
+  openInNewTab: () => openInNewTab,
+  preloadImages: () => preloadImages,
+  probeElementStyle: () => probeElementStyle,
+  setInnerHtmlUnsafe: () => setInnerHtmlUnsafe,
+  tr: () => tr
+});
+module.exports = __toCommonJS(lib_exports);
+
+// node_modules/.pnpm/@sv443-network+coreutils@3.0.1/node_modules/@sv443-network/coreutils/dist/CoreUtils.min.umd.js
+(function(g, f) {
+  if ("object" == typeof exports && "object" == typeof module) {
+    module.exports = f();
+  } else if ("function" == typeof define && define.amd) {
+    define("CoreUtils", [], f);
+  } else if ("object" == typeof exports) {
+    exports["CoreUtils"] = f();
+  } else {
+    g["CoreUtils"] = f();
+  }
+})(void 0, () => {
+  var exports2 = {};
+  var module2 = { exports: exports2 };
+  "use strict";
+  var X = Object.create;
+  var F = Object.defineProperty;
+  var Y = Object.getOwnPropertyDescriptor;
+  var ee = Object.getOwnPropertyNames;
+  var te = Object.getPrototypeOf, re = Object.prototype.hasOwnProperty;
+  var ie = (r, e) => {
+    for (var t in e) F(r, t, { get: e[t], enumerable: true });
+  }, B = (r, e, t, i) => {
+    if (e && typeof e == "object" || typeof e == "function") for (let n of ee(e)) !re.call(r, n) && n !== t && F(r, n, { get: () => e[n], enumerable: !(i = Y(e, n)) || i.enumerable });
+    return r;
+  };
+  var I = (r, e, t) => (t = r != null ? X(te(r)) : {}, B(e || !r || !r.__esModule ? F(t, "default", { value: r, enumerable: true }) : t, r)), ne = (r) => B(F({}, "__esModule", { value: true }), r);
+  var _e = {};
+  ie(_e, { BrowserStorageEngine: () => U, ChecksumMismatchError: () => S, CustomError: () => v, DataStore: () => z, DataStoreEngine: () => E, DataStoreSerializer: () => j, DatedError: () => d, Debouncer: () => A, FileStorageEngine: () => R, MigrationError: () => w, NanoEmitter: () => P, NetworkError: () => x, ScriptContextError: () => g, ValidationError: () => $, abtoa: () => H, atoab: () => W, autoPlural: () => Pe, bitSetHas: () => ae, capitalize: () => Oe, clamp: () => D, compress: () => N, computeHash: () => k, consumeGen: () => ge, consumeStringGen: () => be, createProgressBar: () => Fe, darkenColor: () => L, debounce: () => Ie, decompress: () => fe, defaultPbChars: () => Q, digitCount: () => oe, fetchAdvanced: () => ye, formatNumber: () => se, getCallStack: () => Ee, getListLength: () => De, hexToRgb: () => q, insertValues: () => Ve, joinArrayReadable: () => Ne, lightenColor: () => pe, mapRange: () => V, overflowVal: () => ue, pauseFor: () => Te, pureObj: () => Se, randRange: () => T, randomId: () => he, randomItem: () => le, randomItemIndex: () => C, randomizeArray: () => de, rgbToHex: () => J, roundFixed: () => _, scheduleExit: () => xe, secsToTimeStr: () => Ae, setImmediateInterval: () => ve, setImmediateTimeoutLoop: () => we, takeRandomItem: () => me, takeRandomItemIndex: () => K, truncStr: () => Me, valsWithin: () => ce });
+  module2.exports = ne(_e);
+  function ae(r, e) {
+    return (r & e) === e;
+  }
+  function D(r, e, t) {
+    return typeof t != "number" && (t = e, e = 0), Math.max(Math.min(r, t), e);
+  }
+  function oe(r, e = true) {
+    if (r = Number(["string", "number"].includes(typeof r) ? r : String(r)), typeof r == "number" && isNaN(r)) return NaN;
+    let [t, i] = r.toString().split("."), n = t === "0" ? 1 : Math.floor(Math.log10(Math.abs(Number(t))) + 1), o = e && i ? i.length : 0;
+    return n + o;
+  }
+  function se(r, e, t) {
+    return r.toLocaleString(e, t === "short" ? { notation: "compact", compactDisplay: "short", maximumFractionDigits: 1 } : { style: "decimal", maximumFractionDigits: 0 });
+  }
+  function V(r, e, t, i, n) {
+    return (typeof i > "u" || typeof n > "u") && (n = t, t = e, i = e = 0), Number(e) === 0 && Number(i) === 0 ? r * (n / t) : (r - e) * ((n - i) / (t - e)) + i;
+  }
+  function ue(r, e, t) {
+    let i = typeof t == "number" ? e : 0;
+    if (t = typeof t == "number" ? t : e, i > t) throw new RangeError(`Parameter "min" can't be bigger than "max"`);
+    if (isNaN(r) || isNaN(i) || isNaN(t) || !isFinite(r) || !isFinite(i) || !isFinite(t)) return NaN;
+    if (r >= i && r <= t) return r;
+    let n = t - i + 1;
+    return ((r - i) % n + n) % n + i;
+  }
+  function T(...r) {
+    let e, t, i = false;
+    if (typeof r[0] == "number" && typeof r[1] == "number") [e, t] = r;
+    else if (typeof r[0] == "number" && typeof r[1] != "number") e = 0, [t] = r;
+    else throw new TypeError(`Wrong parameter(s) provided - expected (number, boolean|undefined) or (number, number, boolean|undefined) but got (${r.map((n) => typeof n).join(", ")}) instead`);
+    if (typeof r[2] == "boolean" ? i = r[2] : typeof r[1] == "boolean" && (i = r[1]), e = Number(e), t = Number(t), isNaN(e) || isNaN(t)) return NaN;
+    if (e > t) throw new TypeError(`Parameter "min" can't be bigger than "max"`);
+    if (i) {
+      let n = new Uint8Array(1);
+      return crypto.getRandomValues(n), Number(Array.from(n, (o) => Math.round(V(o, 0, 255, e, t)).toString(10)).join(""));
+    } else return Math.floor(Math.random() * (t - e + 1)) + e;
+  }
+  function _(r, e) {
+    let t = 10 ** e;
+    return Math.round(r * t) / t;
+  }
+  function ce(r, e, t = 1, i = 0.5) {
+    return Math.abs(_(r, t) - _(e, t)) <= i;
+  }
+  function le(r) {
+    return C(r)[0];
+  }
+  function C(r) {
+    if (r.length === 0) return [void 0, void 0];
+    let e = T(r.length - 1);
+    return [r[e], e];
+  }
+  function de(r) {
+    let e = [...r];
+    if (r.length === 0) return e;
+    for (let t = e.length - 1; t > 0; t--) {
+      let i = Math.floor(Math.random() * (t + 1));
+      [e[t], e[i]] = [e[i], e[t]];
+    }
+    return e;
+  }
+  function me(r) {
+    var e;
+    return (e = K(r)) == null ? void 0 : e[0];
+  }
+  function K(r) {
+    let [e, t] = C(r);
+    return t === void 0 ? [void 0, void 0] : (r.splice(t, 1), [e, t]);
+  }
+  function L(r, e, t = false) {
+    var l;
+    r = r.trim();
+    let i = (c, p, m, b) => (c = Math.max(0, Math.min(255, c - c * b / 100)), p = Math.max(0, Math.min(255, p - p * b / 100)), m = Math.max(0, Math.min(255, m - m * b / 100)), [c, p, m]), n, o, a, s, u = r.match(/^#?([0-9A-Fa-f]{3}|[0-9A-Fa-f]{4}|[0-9A-Fa-f]{6}|[0-9A-Fa-f]{8})$/);
+    if (u) [n, o, a, s] = q(r);
+    else if (r.startsWith("rgb")) {
+      let c = (l = r.match(/\d+(\.\d+)?/g)) == null ? void 0 : l.map(Number);
+      if (!c) throw new TypeError("Invalid RGB/RGBA color format");
+      [n, o, a, s] = c;
+    } else throw new TypeError("Unsupported color format");
+    return [n, o, a] = i(n, o, a, e), u ? J(n, o, a, s, r.startsWith("#"), t) : r.startsWith("rgba") ? `rgba(${n}, ${o}, ${a}, ${s ?? NaN})` : `rgb(${n}, ${o}, ${a})`;
+  }
+  function q(r) {
+    r = (r.startsWith("#") ? r.slice(1) : r).trim();
+    let e = r.length === 8 || r.length === 4 ? parseInt(r.slice(-(r.length / 4)), 16) / (r.length === 8 ? 255 : 15) : void 0;
+    isNaN(Number(e)) || (r = r.slice(0, -(r.length / 4))), (r.length === 3 || r.length === 4) && (r = r.split("").map((a) => a + a).join(""));
+    let t = parseInt(r, 16), i = t >> 16 & 255, n = t >> 8 & 255, o = t & 255;
+    return [D(i, 0, 255), D(n, 0, 255), D(o, 0, 255), typeof e == "number" ? D(e, 0, 1) : void 0];
+  }
+  function pe(r, e, t = false) {
+    return L(r, e * -1, t);
+  }
+  function J(r, e, t, i, n = true, o = false) {
+    let a = (s) => D(Math.round(s), 0, 255).toString(16).padStart(2, "0")[o ? "toUpperCase" : "toLowerCase"]();
+    return `${n ? "#" : ""}${a(r)}${a(e)}${a(t)}${i ? a(i * 255) : ""}`;
+  }
+  function H(r) {
+    return btoa(new Uint8Array(r).reduce((e, t) => e + String.fromCharCode(t), ""));
+  }
+  function W(r) {
+    return Uint8Array.from(atob(r), (e) => e.charCodeAt(0));
+  }
+  async function N(r, e, t = "string") {
+    let i = r instanceof Uint8Array ? r : new TextEncoder().encode((r == null ? void 0 : r.toString()) ?? String(r)), n = new CompressionStream(e), o = n.writable.getWriter();
+    o.write(i), o.close();
+    let a = new Uint8Array(await new Response(n.readable).arrayBuffer());
+    return t === "arrayBuffer" ? a : H(a);
+  }
+  async function fe(r, e, t = "string") {
+    let i = r instanceof Uint8Array ? r : W((r == null ? void 0 : r.toString()) ?? String(r)), n = new DecompressionStream(e), o = n.writable.getWriter();
+    o.write(i), o.close();
+    let a = new Uint8Array(await new Response(n.readable).arrayBuffer());
+    return t === "arrayBuffer" ? a : new TextDecoder().decode(a);
+  }
+  async function k(r, e = "SHA-256") {
+    let t;
+    typeof r == "string" ? t = new TextEncoder().encode(r) : t = r;
+    let i = await crypto.subtle.digest(e, t);
+    return Array.from(new Uint8Array(i)).map((a) => a.toString(16).padStart(2, "0")).join("");
+  }
+  function he(r = 16, e = 16, t = false, i = true) {
+    if (r < 1) throw new RangeError("The length argument must be at least 1");
+    if (e < 2 || e > 36) throw new RangeError("The radix argument must be between 2 and 36");
+    let n = [], o = i ? [0, 1] : [0];
+    if (t) {
+      let a = new Uint8Array(r);
+      crypto.getRandomValues(a), n = Array.from(a, (s) => V(s, 0, 255, 0, e).toString(e).substring(0, 1));
+    } else n = Array.from({ length: r }, () => Math.floor(Math.random() * e).toString(e));
+    return n.some((a) => /[a-zA-Z]/.test(a)) ? n.map((a) => o[T(0, o.length - 1, t)] === 1 ? a.toUpperCase() : a).join("") : n.join("");
+  }
+  var d = class extends Error {
+    date;
+    constructor(e, t) {
+      super(e, t), this.name = this.constructor.name, this.date = /* @__PURE__ */ new Date();
+    }
+  }, S = class extends d {
+    constructor(e, t) {
+      super(e, t), this.name = "ChecksumMismatchError";
+    }
+  }, v = class extends d {
+    constructor(e, t, i) {
+      super(t, i), this.name = e;
+    }
+  }, w = class extends d {
+    constructor(e, t) {
+      super(e, t), this.name = "MigrationError";
+    }
+  }, $ = class extends d {
+    constructor(e, t) {
+      super(e, t), this.name = "ValidationError";
+    }
+  }, g = class extends d {
+    constructor(e, t) {
+      super(e, t), this.name = "ScriptContextError";
+    }
+  }, x = class extends d {
+    constructor(e, t) {
+      super(e, t), this.name = "NetworkError";
+    }
+  };
+  async function ge(r) {
+    return await (typeof r == "function" ? r() : r);
+  }
+  async function be(r) {
+    return typeof r == "string" ? r : String(typeof r == "function" ? await r() : r);
+  }
+  async function ye(r, e = {}) {
+    let { timeout: t = 1e4, signal: i, ...n } = e, o = new AbortController();
+    i == null || i.addEventListener("abort", () => o.abort());
+    let a = {}, s;
+    t >= 0 && (s = setTimeout(() => o.abort(), t), a = { signal: o.signal });
+    try {
+      let u = await fetch(r, { ...n, ...a });
+      return typeof s < "u" && clearTimeout(s), u;
+    } catch (u) {
+      throw typeof s < "u" && clearTimeout(s), new x("Error while calling fetch", { cause: u });
+    }
+  }
+  function De(r, e = true) {
+    return "length" in r ? r.length : "size" in r ? r.size : "count" in r ? r.count : e ? 0 : NaN;
+  }
+  function Te(r, e, t = false) {
+    return new Promise((i, n) => {
+      let o = setTimeout(() => i(), r);
+      e == null || e.addEventListener("abort", () => {
+        clearTimeout(o), t ? n(new v("AbortError", "The pause was aborted")) : i();
+      });
+    });
+  }
+  function Se(r) {
+    return Object.assign(/* @__PURE__ */ Object.create(null), r ?? {});
+  }
+  function ve(r, e, t) {
+    let i, n = () => clearInterval(i), o = () => {
+      if (t != null && t.aborted) return n();
+      r();
+    };
+    t == null || t.addEventListener("abort", n), o(), i = setInterval(o, e);
+  }
+  function we(r, e, t) {
+    let i, n = () => clearTimeout(i), o = async () => {
+      if (t != null && t.aborted) return n();
+      await r(), i = setTimeout(o, e);
+    };
+    t == null || t.addEventListener("abort", n), o();
+  }
+  function xe(r = 0, e = 0) {
+    if (e < 0) throw new TypeError("Timeout must be a non-negative number");
+    let t;
+    if (typeof process < "u" && "exit" in process && typeof process.exit == "function") t = () => process.exit(r);
+    else if (typeof Deno < "u" && "exit" in Deno && typeof Deno.exit == "function") t = () => Deno.exit(r);
+    else throw new g("Cannot exit the process, no exit method available");
+    setTimeout(t, e);
+  }
+  function Ee(r, e = 1 / 0) {
+    if (typeof e != "number" || isNaN(e) || e < 0) throw new TypeError("lines parameter must be a non-negative number");
+    try {
+      throw new Error("This is to capture a stack trace with CoreUtils.getCallStack(). (If you see this somewhere, you can safely ignore it.)");
+    } catch (t) {
+      let i = (t.stack ?? "").split(`
+`).map((n) => n.trim()).slice(2, e + 2);
+      return r !== false ? i : i.join(`
+`);
+    }
+  }
+  function Pe(r, e, t = "auto") {
+    switch (typeof e != "number" && ("length" in e ? e = e.length : "size" in e ? e = e.size : "count" in e && (e = e.count)), ["-s", "-ies"].includes(t) || (t = "auto"), isNaN(e) && (e = 2), t === "auto" ? String(r).endsWith("y") ? "-ies" : "-s" : t) {
+      case "-s":
+        return `${r}${e === 1 ? "" : "s"}`;
+      case "-ies":
+        return `${String(r).slice(0, -1)}${e === 1 ? "y" : "ies"}`;
+    }
+  }
+  function Oe(r) {
+    return r.charAt(0).toUpperCase() + r.slice(1);
+  }
+  var Q = { 100: "\u2588", 75: "\u2593", 50: "\u2592", 25: "\u2591", 0: "\u2500" };
+  function Fe(r, e, t = Q) {
+    if (r === 100) return t[100].repeat(e);
+    let i = Math.floor(r / 100 * e), n = r / 10 * e - i, o = "";
+    n >= 0.75 ? o = t[75] : n >= 0.5 ? o = t[50] : n >= 0.25 && (o = t[25]);
+    let a = t[100].repeat(i), s = t[0].repeat(e - i - (o ? 1 : 0));
+    return `${a}${o}${s}`;
+  }
+  function Ve(r, ...e) {
+    return r.replace(/%\d/gm, (t) => {
+      var n;
+      let i = Number(t.substring(1)) - 1;
+      return (n = e[i] ?? t) == null ? void 0 : n.toString();
+    });
+  }
+  function Ne(r, e = ", ", t = " and ") {
+    let i = [...r];
+    if (i.length === 0) return "";
+    if (i.length === 1) return String(i[0]);
+    if (i.length === 2) return i.join(t);
+    let n = t + i[i.length - 1];
+    return i.pop(), i.join(e) + n;
+  }
+  function Ae(r) {
+    let e = r < 0, t = Math.abs(r);
+    if (isNaN(t) || !isFinite(t)) throw new TypeError("The seconds argument must be a valid number");
+    let i = Math.floor(t / 3600), n = Math.floor(t % 3600 / 60), o = Math.floor(t % 60);
+    return (e ? "-" : "") + [i ? i + ":" : "", String(n).padStart(n > 0 || i > 0 ? 2 : 1, "0"), ":", String(o).padStart(o > 0 || n > 0 || i > 0 || r === 0 ? 2 : 1, "0")].join("");
+  }
+  function Me(r, e, t = "...") {
+    let i = (r == null ? void 0 : r.toString()) ?? String(r), n = i.length > e ? i.substring(0, e - t.length) + t : i;
+    return n.length > e ? n.substring(0, e) : n;
+  }
+  var G = 1, z = class {
+    id;
+    formatVersion;
+    defaultData;
+    encodeData;
+    decodeData;
+    compressionFormat = "deflate-raw";
+    memoryCache = true;
+    engine;
+    options;
+    firstInit = true;
+    cachedData;
+    migrations;
+    migrateIds = [];
+    constructor(e) {
+      var t;
+      if (this.id = e.id, this.formatVersion = e.formatVersion, this.defaultData = e.defaultData, this.memoryCache = !!(e.memoryCache ?? true), this.cachedData = this.memoryCache ? e.defaultData : {}, this.migrations = e.migrations, e.migrateIds && (this.migrateIds = Array.isArray(e.migrateIds) ? e.migrateIds : [e.migrateIds]), this.encodeData = e.encodeData, this.decodeData = e.decodeData, this.engine = typeof e.engine == "function" ? e.engine() : e.engine, this.options = e, typeof e.compressionFormat > "u" && (this.compressionFormat = e.compressionFormat = ((t = e.encodeData) == null ? void 0 : t[0]) ?? "deflate-raw"), typeof e.compressionFormat == "string") this.encodeData = [e.compressionFormat, async (i) => await N(i, e.compressionFormat, "string")], this.decodeData = [e.compressionFormat, async (i) => await N(i, e.compressionFormat, "string")];
+      else if ("encodeData" in e && "decodeData" in e && Array.isArray(e.encodeData) && Array.isArray(e.decodeData)) this.encodeData = [e.encodeData[0], e.encodeData[1]], this.decodeData = [e.decodeData[0], e.decodeData[1]], this.compressionFormat = e.encodeData[0] ?? null;
+      else if (e.compressionFormat === null) this.encodeData = void 0, this.decodeData = void 0, this.compressionFormat = null;
+      else throw new TypeError("Either `compressionFormat` or `encodeData` and `decodeData` have to be set and valid, but not all three at a time. Please refer to the documentation for more info.");
+      this.engine.setDataStoreOptions(e);
+    }
+    async loadData() {
+      try {
+        if (this.firstInit) {
+          this.firstInit = false;
+          let u = Number(await this.engine.getValue("__ds_fmt_ver", 0)), l = await this.engine.getValue(`_uucfg-${this.id}`, null);
+          if (l) {
+            let c = Number(await this.engine.getValue(`_uucfgver-${this.id}`, NaN)), p = await this.engine.getValue(`_uucfgenc-${this.id}`, null), m = [], b = (O, h, y) => {
+              m.push(this.engine.setValue(h, y)), m.push(this.engine.deleteValue(O));
+            };
+            b(`_uucfg-${this.id}`, `__ds-${this.id}-dat`, l), isNaN(c) || b(`_uucfgver-${this.id}`, `__ds-${this.id}-ver`, c), typeof p == "boolean" ? b(`_uucfgenc-${this.id}`, `__ds-${this.id}-enf`, p === true ? this.compressionFormat ?? null : null) : (m.push(this.engine.setValue(`__ds-${this.id}-enf`, this.compressionFormat)), m.push(this.engine.deleteValue(`_uucfgenc-${this.id}`))), await Promise.allSettled(m);
+          }
+          (isNaN(u) || u < G) && await this.engine.setValue("__ds_fmt_ver", G);
+        }
+        this.migrateIds.length > 0 && (await this.migrateId(this.migrateIds), this.migrateIds = []);
+        let e = await this.engine.getValue(`__ds-${this.id}-dat`, null), t = Number(await this.engine.getValue(`__ds-${this.id}-ver`, NaN));
+        if (typeof e != "string") return await this.saveDefaultData(), this.engine.deepCopy(this.defaultData);
+        let i = e ?? JSON.stringify(this.defaultData), n = String(await this.engine.getValue(`__ds-${this.id}-enf`, null)), o = n !== "null" && n !== "false", a = false;
+        isNaN(t) && (await this.engine.setValue(`__ds-${this.id}-ver`, t = this.formatVersion), a = true);
+        let s = await this.engine.deserializeData(i, o);
+        return t < this.formatVersion && this.migrations && (s = await this.runMigrations(s, t)), a && await this.setData(s), this.memoryCache ? this.cachedData = this.engine.deepCopy(s) : this.engine.deepCopy(s);
+      } catch (e) {
+        return console.warn("Error while parsing JSON data, resetting it to the default value.", e), await this.saveDefaultData(), this.defaultData;
+      }
+    }
+    getData() {
+      if (!this.memoryCache) throw new d("In-memory cache is disabled for this DataStore instance, so getData() can't be used. Please use loadData() instead.");
+      return this.engine.deepCopy(this.cachedData);
+    }
+    setData(e) {
+      return this.memoryCache && (this.cachedData = e), new Promise(async (t) => {
+        await Promise.allSettled([this.engine.setValue(`__ds-${this.id}-dat`, await this.engine.serializeData(e, this.encodingEnabled())), this.engine.setValue(`__ds-${this.id}-ver`, this.formatVersion), this.engine.setValue(`__ds-${this.id}-enf`, this.compressionFormat)]), t();
+      });
+    }
+    async saveDefaultData() {
+      this.memoryCache && (this.cachedData = this.defaultData), await Promise.allSettled([this.engine.setValue(`__ds-${this.id}-dat`, await this.engine.serializeData(this.defaultData, this.encodingEnabled())), this.engine.setValue(`__ds-${this.id}-ver`, this.formatVersion), this.engine.setValue(`__ds-${this.id}-enf`, this.compressionFormat)]);
+    }
+    async deleteData() {
+      var e, t;
+      await Promise.allSettled([this.engine.deleteValue(`__ds-${this.id}-dat`), this.engine.deleteValue(`__ds-${this.id}-ver`), this.engine.deleteValue(`__ds-${this.id}-enf`)]), await ((t = (e = this.engine).deleteStorage) == null ? void 0 : t.call(e));
+    }
+    encodingEnabled() {
+      return !!(this.encodeData && this.decodeData) && this.compressionFormat !== null || !!this.compressionFormat;
+    }
+    async runMigrations(e, t, i = true) {
+      if (!this.migrations) return e;
+      let n = e, o = Object.entries(this.migrations).sort(([s], [u]) => Number(s) - Number(u)), a = t;
+      for (let [s, u] of o) {
+        let l = Number(s);
+        if (t < this.formatVersion && t < l) try {
+          let c = u(n);
+          n = c instanceof Promise ? await c : c, a = t = l;
+        } catch (c) {
+          if (!i) throw new w(`Error while running migration function for format version '${s}'`, { cause: c });
+          return await this.saveDefaultData(), this.getData();
+        }
+      }
+      return await Promise.allSettled([this.engine.setValue(`__ds-${this.id}-dat`, await this.engine.serializeData(n)), this.engine.setValue(`__ds-${this.id}-ver`, a), this.engine.setValue(`__ds-${this.id}-enf`, this.compressionFormat)]), this.memoryCache ? this.cachedData = this.engine.deepCopy(n) : this.engine.deepCopy(n);
+    }
+    async migrateId(e) {
+      let t = Array.isArray(e) ? e : [e];
+      await Promise.all(t.map(async (i) => {
+        let [n, o, a] = await (async () => {
+          let [u, l, c] = await Promise.all([this.engine.getValue(`__ds-${i}-dat`, JSON.stringify(this.defaultData)), this.engine.getValue(`__ds-${i}-ver`, NaN), this.engine.getValue(`__ds-${i}-enf`, null)]);
+          return [u, Number(l), !!c && String(c) !== "null"];
+        })();
+        if (n === void 0 || isNaN(o)) return;
+        let s = await this.engine.deserializeData(n, a);
+        await Promise.allSettled([this.engine.setValue(`__ds-${this.id}-dat`, await this.engine.serializeData(s)), this.engine.setValue(`__ds-${this.id}-ver`, o), this.engine.setValue(`__ds-${this.id}-enf`, this.compressionFormat), this.engine.deleteValue(`__ds-${i}-dat`), this.engine.deleteValue(`__ds-${i}-ver`), this.engine.deleteValue(`__ds-${i}-enf`)]);
+      }));
+    }
+  };
+  var E = class {
+    dataStoreOptions;
+    constructor(e) {
+      e && (this.dataStoreOptions = e);
+    }
+    setDataStoreOptions(e) {
+      this.dataStoreOptions = e;
+    }
+    async serializeData(e, t) {
+      var o, a, s, u, l;
+      this.ensureDataStoreOptions();
+      let i = JSON.stringify(e);
+      if (!t || !((o = this.dataStoreOptions) != null && o.encodeData) || !((a = this.dataStoreOptions) != null && a.decodeData)) return i;
+      let n = (l = (u = (s = this.dataStoreOptions) == null ? void 0 : s.encodeData) == null ? void 0 : u[1]) == null ? void 0 : l.call(u, i);
+      return n instanceof Promise ? await n : n;
+    }
+    async deserializeData(e, t) {
+      var n, o, a;
+      this.ensureDataStoreOptions();
+      let i = (n = this.dataStoreOptions) != null && n.decodeData && t ? (a = (o = this.dataStoreOptions.decodeData) == null ? void 0 : o[1]) == null ? void 0 : a.call(o, e) : void 0;
+      return i instanceof Promise && (i = await i), JSON.parse(i ?? e);
+    }
+    ensureDataStoreOptions() {
+      if (!this.dataStoreOptions) throw new d("DataStoreEngine must be initialized with DataStore options before use. If you are using this instance standalone, set them in the constructor or call `setDataStoreOptions()` with the DataStore options.");
+      if (!this.dataStoreOptions.id) throw new d("DataStoreEngine must be initialized with a valid DataStore ID");
+    }
+    deepCopy(e) {
+      try {
+        if ("structuredClone" in globalThis) return structuredClone(e);
+      } catch {
+      }
+      return JSON.parse(JSON.stringify(e));
+    }
+  }, U = class extends E {
+    options;
+    constructor(e) {
+      super(e == null ? void 0 : e.dataStoreOptions), this.options = { type: "localStorage", ...e };
+    }
+    async getValue(e, t) {
+      let i = this.options.type === "localStorage" ? globalThis.localStorage.getItem(e) : globalThis.sessionStorage.getItem(e);
+      return typeof i > "u" ? t : i;
+    }
+    async setValue(e, t) {
+      this.options.type === "localStorage" ? globalThis.localStorage.setItem(e, String(t)) : globalThis.sessionStorage.setItem(e, String(t));
+    }
+    async deleteValue(e) {
+      this.options.type === "localStorage" ? globalThis.localStorage.removeItem(e) : globalThis.sessionStorage.removeItem(e);
+    }
+  }, f, R = class extends E {
+    options;
+    fileAccessQueue = Promise.resolve();
+    constructor(e) {
+      super(e == null ? void 0 : e.dataStoreOptions), this.options = { filePath: (t) => `.ds-${t}`, ...e };
+    }
+    async readFile() {
+      var e, t, i, n;
+      this.ensureDataStoreOptions();
+      try {
+        if (f || (f = (e = await import("fs/promises")) == null ? void 0 : e.default), !f) throw new g("FileStorageEngine requires Node.js or Deno with Node compatibility (v1.31+)", { cause: new d("'node:fs/promises' module not available") });
+        let o = typeof this.options.filePath == "string" ? this.options.filePath : this.options.filePath(this.dataStoreOptions.id), a = await f.readFile(o, "utf-8");
+        return a ? JSON.parse(await ((n = (i = (t = this.dataStoreOptions) == null ? void 0 : t.decodeData) == null ? void 0 : i[1]) == null ? void 0 : n.call(i, a)) ?? a) : void 0;
+      } catch {
+        return;
+      }
+    }
+    async writeFile(e) {
+      var t, i, n, o;
+      this.ensureDataStoreOptions();
+      try {
+        if (f || (f = (t = await import("fs/promises")) == null ? void 0 : t.default), !f) throw new g("FileStorageEngine requires Node.js or Deno with Node compatibility (v1.31+)", { cause: new d("'node:fs/promises' module not available") });
+        let a = typeof this.options.filePath == "string" ? this.options.filePath : this.options.filePath(this.dataStoreOptions.id);
+        await f.mkdir(a.slice(0, a.lastIndexOf(a.includes("/") ? "/" : "\\")), { recursive: true }), await f.writeFile(a, await ((o = (n = (i = this.dataStoreOptions) == null ? void 0 : i.encodeData) == null ? void 0 : n[1]) == null ? void 0 : o.call(n, JSON.stringify(e))) ?? JSON.stringify(e, void 0, 2), "utf-8");
+      } catch (a) {
+        console.error("Error writing file:", a);
+      }
+    }
+    async getValue(e, t) {
+      let i = await this.readFile();
+      if (!i) return t;
+      let n = i == null ? void 0 : i[e];
+      return typeof n > "u" ? t : n;
+    }
+    async setValue(e, t) {
+      this.fileAccessQueue = this.fileAccessQueue.then(async () => {
+        let i = await this.readFile();
+        i || (i = {}), i[e] = t, await this.writeFile(i);
+      }).catch((i) => {
+        throw console.error("Error in setValue:", i), i;
+      }), await this.fileAccessQueue.catch(() => {
+      });
+    }
+    async deleteValue(e) {
+      this.fileAccessQueue = this.fileAccessQueue.then(async () => {
+        let t = await this.readFile();
+        t && (delete t[e], await this.writeFile(t));
+      }).catch((t) => {
+        throw console.error("Error in deleteValue:", t), t;
+      }), await this.fileAccessQueue.catch(() => {
+      });
+    }
+    async deleteStorage() {
+      var e;
+      this.ensureDataStoreOptions();
+      try {
+        if (f || (f = (e = await import("fs/promises")) == null ? void 0 : e.default), !f) throw new g("FileStorageEngine requires Node.js or Deno with Node compatibility (v1.31+)", { cause: new d("'node:fs/promises' module not available") });
+        let t = typeof this.options.filePath == "string" ? this.options.filePath : this.options.filePath(this.dataStoreOptions.id);
+        return await f.unlink(t);
+      } catch (t) {
+        console.error("Error deleting file:", t);
+      }
+    }
+  };
+  var j = class r {
+    stores;
+    options;
+    constructor(e, t = {}) {
+      if (!crypto || !crypto.subtle) throw new g("DataStoreSerializer has to run in a secure context (HTTPS) or in another environment that implements the subtleCrypto API!");
+      this.stores = e, this.options = { addChecksum: true, ensureIntegrity: true, remapIds: {}, ...t };
+    }
+    async calcChecksum(e) {
+      return k(e, "SHA-256");
+    }
+    async serializePartial(e, t = true, i = true) {
+      var a;
+      let n = [], o = this.stores.filter((s) => typeof e == "function" ? e(s.id) : e.includes(s.id));
+      for (let s of o) {
+        let u = !!(t && s.encodingEnabled() && ((a = s.encodeData) != null && a[1])), l = s.memoryCache ? s.getData() : await s.loadData(), c = u ? await s.encodeData[1](JSON.stringify(l)) : JSON.stringify(l);
+        n.push({ id: s.id, data: c, formatVersion: s.formatVersion, encoded: u, checksum: this.options.addChecksum ? await this.calcChecksum(c) : void 0 });
+      }
+      return i ? JSON.stringify(n) : n;
+    }
+    async serialize(e = true, t = true) {
+      return this.serializePartial(this.stores.map((i) => i.id), e, t);
+    }
+    async deserializePartial(e, t) {
+      let i = typeof t == "string" ? JSON.parse(t) : t;
+      if (!Array.isArray(i) || !i.every(r.isSerializedDataStoreObj)) throw new TypeError("Invalid serialized data format! Expected an array of SerializedDataStore objects.");
+      let n = (a) => {
+        var s;
+        return ((s = Object.entries(this.options.remapIds).find(([, u]) => u.includes(a))) == null ? void 0 : s[0]) ?? a;
+      }, o = (a) => typeof e == "function" ? e(a) : e.includes(a);
+      for (let a of i) {
+        let s = n(a.id);
+        if (!o(s)) continue;
+        let u = this.stores.find((c) => c.id === s);
+        if (!u) throw new d(`Can't deserialize data because no DataStore instance with the ID "${s}" was found! Make sure to provide it in the DataStoreSerializer constructor.`);
+        if (this.options.ensureIntegrity && typeof a.checksum == "string") {
+          let c = await this.calcChecksum(a.data);
+          if (c !== a.checksum) throw new S(`Checksum mismatch for DataStore with ID "${a.id}"!
+Expected: ${a.checksum}
+Has: ${c}`);
+        }
+        let l = a.encoded && u.encodingEnabled() ? await u.decodeData[1](a.data) : a.data;
+        a.formatVersion && !isNaN(Number(a.formatVersion)) && Number(a.formatVersion) < u.formatVersion ? await u.runMigrations(JSON.parse(l), Number(a.formatVersion), false) : await u.setData(JSON.parse(l));
+      }
+    }
+    async deserialize(e) {
+      return this.deserializePartial(this.stores.map((t) => t.id), e);
+    }
+    async loadStoresData(e) {
+      return Promise.allSettled(this.getStoresFiltered(e).map(async (t) => ({ id: t.id, data: await t.loadData() })));
+    }
+    async resetStoresData(e) {
+      return Promise.allSettled(this.getStoresFiltered(e).map((t) => t.saveDefaultData()));
+    }
+    async deleteStoresData(e) {
+      return Promise.allSettled(this.getStoresFiltered(e).map((t) => t.deleteData()));
+    }
+    static isSerializedDataStoreObjArray(e) {
+      return Array.isArray(e) && e.every((t) => typeof t == "object" && t !== null && "id" in t && "data" in t && "formatVersion" in t && "encoded" in t);
+    }
+    static isSerializedDataStoreObj(e) {
+      return typeof e == "object" && e !== null && "id" in e && "data" in e && "formatVersion" in e && "encoded" in e;
+    }
+    getStoresFiltered(e) {
+      return this.stores.filter((t) => typeof e > "u" ? true : Array.isArray(e) ? e.includes(t.id) : e(t.id));
+    }
+  };
+  var Z = () => ({ emit(r, ...e) {
+    for (let t = this.events[r] || [], i = 0, n = t.length; i < n; i++) t[i](...e);
+  }, events: {}, on(r, e) {
+    return (this.events[r] ||= []).push(e), () => {
+      var t;
+      this.events[r] = (t = this.events[r]) == null ? void 0 : t.filter((i) => e !== i);
+    };
+  } });
+  var P = class {
+    events = Z();
+    eventUnsubscribes = [];
+    emitterOptions;
+    constructor(e = {}) {
+      this.emitterOptions = { publicEmit: false, ...e };
+    }
+    on(e, t) {
+      let i, n = () => {
+        i && (i(), this.eventUnsubscribes = this.eventUnsubscribes.filter((o) => o !== i));
+      };
+      return i = this.events.on(e, t), this.eventUnsubscribes.push(i), n;
+    }
+    once(e, t) {
+      return new Promise((i) => {
+        let n, o = ((...a) => {
+          t == null || t(...a), n == null || n(), i(a);
+        });
+        n = this.events.on(e, o), this.eventUnsubscribes.push(n);
+      });
+    }
+    onMulti(e) {
+      let t = [], i = () => {
+        for (let n of t) n();
+        t.splice(0, t.length), this.eventUnsubscribes = this.eventUnsubscribes.filter((n) => !t.includes(n));
+      };
+      for (let n of Array.isArray(e) ? e : [e]) {
+        let o = { allOf: [], oneOf: [], once: false, ...n }, { oneOf: a, allOf: s, once: u, signal: l, callback: c } = o;
+        if (l != null && l.aborted) return i;
+        if (a.length === 0 && s.length === 0) throw new TypeError("NanoEmitter.onMulti(): Either `oneOf` or `allOf` or both must be provided in the options");
+        let p = [], m = (h = false) => {
+          if (!(!(l != null && l.aborted) && !h)) {
+            for (let y of p) y();
+            p.splice(0, p.length), this.eventUnsubscribes = this.eventUnsubscribes.filter((y) => !p.includes(y));
+          }
+        }, b = /* @__PURE__ */ new Set(), O = () => s.length === 0 || b.size === s.length;
+        for (let h of a) {
+          let y = this.events.on(h, ((...M) => {
+            m(), O() && (c(h, ...M), u && m(true));
+          }));
+          p.push(y);
+        }
+        for (let h of s) {
+          let y = this.events.on(h, ((...M) => {
+            m(), b.add(h), O() && (a.length === 0 || a.includes(h)) && (c(h, ...M), u && m(true));
+          }));
+          p.push(y);
+        }
+        t.push(() => m(true));
+      }
+      return i;
+    }
+    emit(e, ...t) {
+      return this.emitterOptions.publicEmit ? (this.events.emit(e, ...t), true) : false;
+    }
+    unsubscribeAll() {
+      for (let e of this.eventUnsubscribes) e();
+      this.eventUnsubscribes = [];
+    }
+  };
+  var A = class extends P {
+    constructor(t = 200, i = "immediate") {
+      super();
+      this.timeout = t;
+      this.type = i;
+    }
+    listeners = [];
+    activeTimeout;
+    queuedCall;
+    addListener(t) {
+      this.listeners.push(t);
+    }
+    removeListener(t) {
+      let i = this.listeners.findIndex((n) => n === t);
+      i !== -1 && this.listeners.splice(i, 1);
+    }
+    removeAllListeners() {
+      this.listeners = [];
+    }
+    getListeners() {
+      return this.listeners;
+    }
+    setTimeout(t) {
+      this.emit("change", this.timeout = t, this.type);
+    }
+    getTimeout() {
+      return this.timeout;
+    }
+    isTimeoutActive() {
+      return typeof this.activeTimeout < "u";
+    }
+    setType(t) {
+      this.emit("change", this.timeout, this.type = t);
+    }
+    getType() {
+      return this.type;
+    }
+    call(...t) {
+      let i = (...o) => {
+        this.queuedCall = void 0, this.emit("call", ...o), this.listeners.forEach((a) => a.call(this, ...o));
+      }, n = () => {
+        this.activeTimeout = setTimeout(() => {
+          this.queuedCall ? (this.queuedCall(), n()) : this.activeTimeout = void 0;
+        }, this.timeout);
+      };
+      switch (this.type) {
+        case "immediate":
+          typeof this.activeTimeout > "u" ? (i(...t), n()) : this.queuedCall = () => i(...t);
+          break;
+        case "idle":
+          this.activeTimeout && clearTimeout(this.activeTimeout), this.activeTimeout = setTimeout(() => {
+            i(...t), this.activeTimeout = void 0;
+          }, this.timeout);
+          break;
+        default:
+          throw new TypeError(`Invalid debouncer type: ${this.type}`);
+      }
+    }
+  };
+  function Ie(r, e = 200, t = "immediate") {
+    let i = new A(e, t);
+    i.addListener(r);
+    let n = ((...o) => i.call(...o));
+    return n.debouncer = i, n;
+  }
+  if (typeof module2.exports == "object" && typeof exports2 == "object") {
+    var __cp = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of Object.getOwnPropertyNames(from)) {
+          if (!Object.prototype.hasOwnProperty.call(to, key) && key !== except)
+            Object.defineProperty(to, key, {
+              get: () => from[key],
+              enumerable: !(desc = Object.getOwnPropertyDescriptor(from, key)) || desc.enumerable
+            });
+        }
+      }
+      return to;
+    };
+    module2.exports = __cp(module2.exports, exports2);
+  }
+  return module2.exports;
+});
+
+// lib/Errors.ts
+var PlatformError = class extends (void 0) {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "PlatformError";
+  }
+};
+
+// lib/dom.ts
+function getUnsafeWindow() {
+  try {
+    return unsafeWindow;
+  } catch {
+    return window;
+  }
+}
+function addParent(element, newParent) {
+  const oldParent = element.parentNode;
+  if (!oldParent)
+    throw new Error("Element doesn't have a parent node");
+  oldParent.replaceChild(newParent, element);
+  newParent.appendChild(element);
+  return newParent;
+}
+function addGlobalStyle(style) {
+  const styleElem = document.createElement("style");
+  setInnerHtmlUnsafe(styleElem, style);
+  document.head.appendChild(styleElem);
+  return styleElem;
+}
+function preloadImages(srcUrls, rejects = false) {
+  const promises = srcUrls.map((src) => new Promise((res, rej) => {
+    const image = new Image();
+    image.addEventListener("load", () => res(image), { once: true });
+    image.addEventListener("error", (evt) => rejects ? rej(evt) : res(image), { once: true });
+    image.src = src;
+  }));
+  return Promise.allSettled(promises);
+}
+function openInNewTab(href, background, additionalProps) {
+  try {
+    if (typeof window.GM === "object")
+      GM.openInTab(href, background);
+  } catch {
+    const openElem = document.createElement("a");
+    Object.assign(openElem, {
+      className: "userutils-open-in-new-tab",
+      target: "_blank",
+      rel: "noopener noreferrer",
+      tabIndex: -1,
+      ariaHidden: "true",
+      href,
+      ...additionalProps
+    });
+    Object.assign(openElem.style, {
+      display: "none",
+      pointerEvents: "none"
+    });
+    document.body.appendChild(openElem);
+    openElem.click();
+    setTimeout(() => {
+      try {
+        openElem.remove();
+      } catch {
+      }
+    }, 0);
+  }
+}
+function interceptEvent(eventObject, eventName, predicate = () => true) {
+  var _a;
+  if (typeof window.GM === "object" && ((_a = GM == null ? void 0 : GM.info) == null ? void 0 : _a.scriptHandler) && GM.info.scriptHandler === "FireMonkey" && (eventObject === window || eventObject === getUnsafeWindow()))
+    throw new PlatformError("Intercepting window events is not supported on FireMonkey due to the isolated context the userscript is forced to run in.");
+  if ("stackTraceLimit" in Error) {
+    Error.stackTraceLimit = Math.max(Error.stackTraceLimit, 100);
+    if (isNaN(Error.stackTraceLimit))
+      Error.stackTraceLimit = 100;
+  }
+  (function(original) {
+    eventObject.__proto__.addEventListener = function(...args) {
+      var _a2;
+      const origListener = typeof args[1] === "function" ? args[1] : ((_a2 = args[1]) == null ? void 0 : _a2.handleEvent) ?? (() => void 0);
+      args[1] = function(...a) {
+        if (args[0] === eventName && predicate(Array.isArray(a) ? a[0] : a))
+          return;
+        else
+          return origListener.apply(this, a);
+      };
+      original.apply(this, args);
+    };
+  })(eventObject.__proto__.addEventListener);
+}
+function interceptWindowEvent(eventName, predicate = () => true) {
+  return interceptEvent(getUnsafeWindow(), eventName, predicate);
+}
+function isScrollable(element) {
+  const { overflowX, overflowY } = getComputedStyle(element);
+  return {
+    vertical: (overflowY === "scroll" || overflowY === "auto") && element.scrollHeight > element.clientHeight,
+    horizontal: (overflowX === "scroll" || overflowX === "auto") && element.scrollWidth > element.clientWidth
+  };
+}
+function observeElementProp(element, property, callback) {
+  const elementPrototype = Object.getPrototypeOf(element);
+  if (elementPrototype.hasOwnProperty(property)) {
+    const descriptor = Object.getOwnPropertyDescriptor(elementPrototype, property);
+    Object.defineProperty(element, property, {
+      get: function() {
+        var _a;
+        return (_a = descriptor == null ? void 0 : descriptor.get) == null ? void 0 : _a.apply(this, arguments);
+      },
+      set: function() {
+        var _a;
+        const oldValue = this[property];
+        (_a = descriptor == null ? void 0 : descriptor.set) == null ? void 0 : _a.apply(this, arguments);
+        const newValue = this[property];
+        if (typeof callback === "function")
+          callback.bind(this, oldValue, newValue);
+        return newValue;
+      }
+    });
+  }
+}
+function getSiblingsFrame(refElement, siblingAmount, refElementAlignment = "center-top", includeRef = true) {
+  var _a;
+  const siblings = [...((_a = refElement.parentNode) == null ? void 0 : _a.childNodes) ?? []];
+  const elemSiblIdx = siblings.indexOf(refElement);
+  if (elemSiblIdx === -1)
+    throw new Error("Element doesn't have a parent node");
+  if (refElementAlignment === "top")
+    return [...siblings.slice(elemSiblIdx + Number(!includeRef), elemSiblIdx + siblingAmount + Number(!includeRef))];
+  else if (refElementAlignment.startsWith("center-")) {
+    const halfAmount = (refElementAlignment === "center-bottom" ? Math.ceil : Math.floor)(siblingAmount / 2);
+    const startIdx = Math.max(0, elemSiblIdx - halfAmount);
+    const topOffset = Number(refElementAlignment === "center-top" && siblingAmount % 2 === 0 && includeRef);
+    const btmOffset = Number(refElementAlignment === "center-bottom" && siblingAmount % 2 !== 0 && includeRef);
+    const startIdxWithOffset = startIdx + topOffset + btmOffset;
+    return [
+      ...siblings.filter((_, idx) => includeRef || idx !== elemSiblIdx).slice(startIdxWithOffset, startIdxWithOffset + siblingAmount)
+    ];
+  } else if (refElementAlignment === "bottom")
+    return [...siblings.slice(elemSiblIdx - siblingAmount + Number(includeRef), elemSiblIdx + Number(includeRef))];
+  return [];
+}
+var ttPolicy;
+function setInnerHtmlUnsafe(element, html) {
+  var _a, _b;
+  if (!ttPolicy && typeof ((_a = window == null ? void 0 : window.trustedTypes) == null ? void 0 : _a.createPolicy) === "function") {
+    ttPolicy = window.trustedTypes.createPolicy("_uu_set_innerhtml_unsafe", {
+      createHTML: (unsafeHtml) => unsafeHtml
+    });
+  }
+  element.innerHTML = ((_b = ttPolicy == null ? void 0 : ttPolicy.createHTML) == null ? void 0 : _b.call(ttPolicy, html)) ?? html;
+  return element;
+}
+function probeElementStyle(probeStyle, element, hideOffscreen = true, parentElement = document.body) {
+  const el = element ? typeof element === "function" ? element() : element : document.createElement("span");
+  if (hideOffscreen) {
+    el.style.position = "absolute";
+    el.style.left = "-9999px";
+    el.style.top = "-9999px";
+    el.style.zIndex = "-9999";
+  }
+  el.classList.add("_uu_probe_element");
+  parentElement.appendChild(el);
+  const style = window.getComputedStyle(el);
+  const result = probeStyle(style, el);
+  setTimeout(() => el.remove(), 1);
+  return result;
+}
+var domReady = document.readyState !== "loading";
+!domReady && document.addEventListener("DOMContentLoaded", () => domReady = true, { once: true });
+function isDomLoaded() {
+  return domReady;
+}
+function onDomLoad(cb) {
+  return new Promise((res) => {
+    if (domReady) {
+      cb == null ? void 0 : cb();
+      res();
+    } else
+      document.addEventListener("DOMContentLoaded", () => {
+        cb == null ? void 0 : cb();
+        res();
+      }, { once: true });
+  });
+}
+
+// lib/Dialog.ts
+var defaultDialogCss = `.uu-no-select {
+  user-select: none;
+}
+
+.uu-dialog-bg {
+  --uu-dialog-bg: #333333;
+  --uu-dialog-bg-highlight: #252525;
+  --uu-scroll-indicator-bg: rgba(10, 10, 10, 0.7);
+  --uu-dialog-separator-color: #797979;
+  --uu-dialog-border-radius: 10px;
+}
+
+.uu-dialog-bg {
+  display: block;
+  position: fixed;
+  width: 100%;
+  height: 100%;
+  top: 0;
+  left: 0;
+  z-index: 5;
+  background-color: rgba(0, 0, 0, 0.6);
+}
+
+.uu-dialog {
+  --uu-calc-dialog-height: calc(min(100vh - 40px, var(--uu-dialog-height-max)));
+  position: absolute;
+  display: flex;
+  flex-direction: column;
+  width: calc(min(100% - 60px, var(--uu-dialog-width-max)));
+  border-radius: var(--uu-dialog-border-radius);
+  height: auto;
+  max-height: var(--uu-calc-dialog-height);
+  left: 50%;
+  top: 50%;
+  transform: translate(-50%, -50%);
+  z-index: 6;
+  color: #fff;
+  background-color: var(--uu-dialog-bg);
+}
+
+.uu-dialog.align-top {
+  top: 0;
+  transform: translate(-50%, 40px);
+}
+
+.uu-dialog.align-bottom {
+  top: 100%;
+  transform: translate(-50%, -100%);
+}
+
+.uu-dialog-body {
+  font-size: 1.5rem;
+  padding: 20px;
+}
+
+.uu-dialog-body.small {
+  padding: 15px;
+}
+
+#uu-dialog-opts {
+  display: flex;
+  flex-direction: column;
+  position: relative;
+  padding: 30px 0px;
+  overflow-y: auto;
+}
+
+.uu-dialog-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  margin-bottom: 6px;
+  padding: 15px 20px 15px 20px;
+  background-color: var(--uu-dialog-bg);
+  border: 2px solid var(--uu-dialog-separator-color);
+  border-style: none none solid none !important;
+  border-radius: var(--uu-dialog-border-radius) var(--uu-dialog-border-radius) 0px 0px;
+}
+
+.uu-dialog-header.small {
+  padding: 10px 15px;
+  border-style: none none solid none !important;
+}
+
+.uu-dialog-header-pad {
+  content: " ";
+  min-height: 32px;
+}
+
+.uu-dialog-header-pad.small {
+  min-height: 24px;
+}
+
+.uu-dialog-titlecont {
+  display: flex;
+  align-items: center;
+}
+
+.uu-dialog-titlecont-no-title {
+  display: flex;
+  justify-content: flex-end;
+  align-items: center;
+}
+
+.uu-dialog-title {
+  position: relative;
+  display: inline-block;
+  font-size: 22px;
+}
+
+.uu-dialog-close {
+  cursor: pointer;
+}
+
+.uu-dialog-header-img,
+.uu-dialog-close
+{
+  width: 32px;
+  height: 32px;
+}
+
+.uu-dialog-header-img.small,
+.uu-dialog-close.small
+{
+  width: 24px;
+  height: 24px;
+}
+
+.uu-dialog-footer {
+  font-size: 17px;
+  text-decoration: underline;
+}
+
+.uu-dialog-footer.hidden {
+  display: none;
+}
+
+.uu-dialog-footer-cont {
+  margin-top: 6px;
+  padding: 15px 20px;
+  background: var(--uu-dialog-bg);
+  background: linear-gradient(to bottom, rgba(0, 0, 0, 0) 0%, var(--uu-dialog-bg) 30%, var(--uu-dialog-bg) 100%);
+  border: 2px solid var(--uu-dialog-separator-color);
+  border-style: solid none none none !important;
+  border-radius: 0px 0px var(--uu-dialog-border-radius) var(--uu-dialog-border-radius);
+}
+
+.uu-dialog-footer-buttons-cont button:not(:last-of-type) {
+  margin-right: 15px;
+}`;
+var currentDialogId = null;
+var openDialogs = [];
+var defaultStrings = {
+  closeDialogTooltip: "Click to close the dialog"
+};
+var Dialog = class _Dialog extends (void 0) {
+  /** Options passed to the dialog in the constructor */
+  options;
+  /** ID that gets added to child element IDs - has to be unique and conform to HTML ID naming rules! */
+  id;
+  /** Strings used in the dialog (used for translations) */
+  strings;
+  dialogOpen = false;
+  dialogMounted = false;
+  constructor(options) {
+    super();
+    const { strings, ...opts } = options;
+    this.strings = {
+      ...defaultStrings,
+      ...strings ?? {}
+    };
+    this.options = {
+      closeOnBgClick: true,
+      closeOnEscPress: true,
+      destroyOnClose: false,
+      unmountOnClose: true,
+      removeListenersOnDestroy: true,
+      small: false,
+      verticalAlign: "center",
+      ...opts
+    };
+    this.id = opts.id;
+  }
+  //#region public
+  /** Call after DOMContentLoaded to pre-render the dialog and invisibly mount it in the DOM */
+  async mount() {
+    if (this.dialogMounted)
+      return;
+    this.dialogMounted = true;
+    if (!document.querySelector("style.uu-dialog-css"))
+      addGlobalStyle(this.options.dialogCss ?? defaultDialogCss).classList.add("uu-dialog-css");
+    const bgElem = document.createElement("div");
+    bgElem.id = `uu-${this.id}-dialog-bg`;
+    bgElem.classList.add("uu-dialog-bg");
+    if (this.options.closeOnBgClick)
+      bgElem.ariaLabel = bgElem.title = this.getString("closeDialogTooltip");
+    bgElem.style.setProperty("--uu-dialog-width-max", `${this.options.width}px`);
+    bgElem.style.setProperty("--uu-dialog-height-max", `${this.options.height}px`);
+    bgElem.style.visibility = "hidden";
+    bgElem.style.display = "none";
+    bgElem.inert = true;
+    bgElem.appendChild(await this.getDialogContent());
+    document.body.appendChild(bgElem);
+    this.attachListeners(bgElem);
+    this.events.emit("render");
+    return bgElem;
+  }
+  /** Closes the dialog and clears all its contents (unmounts elements from the DOM) in preparation for a new rendering call */
+  unmount() {
+    var _a;
+    this.close();
+    this.dialogMounted = false;
+    const clearSelectors = [
+      `#uu-${this.id}-dialog-bg`,
+      `#uu-style-dialog-${this.id}`
+    ];
+    for (const sel of clearSelectors)
+      (_a = document.querySelector(sel)) == null ? void 0 : _a.remove();
+    this.events.emit("clear");
+  }
+  /** Clears the DOM of the dialog and then renders it again */
+  async remount() {
+    this.unmount();
+    await this.mount();
+  }
+  /**
+   * Opens the dialog - also mounts it if it hasn't been mounted yet  
+   * Prevents default action and immediate propagation of the passed event
+   */
+  async open(e) {
+    var _a;
+    e == null ? void 0 : e.preventDefault();
+    e == null ? void 0 : e.stopImmediatePropagation();
+    if (this.isOpen())
+      return;
+    this.dialogOpen = true;
+    if (openDialogs.includes(this.id))
+      throw new Error(`A dialog with the same ID of '${this.id}' already exists and is open!`);
+    if (!this.isMounted())
+      await this.mount();
+    const dialogBg = document.querySelector(`#uu-${this.id}-dialog-bg`);
+    if (!dialogBg)
+      return console.warn(`Couldn't find background element for dialog with ID '${this.id}'`);
+    dialogBg.style.visibility = "visible";
+    dialogBg.style.display = "block";
+    dialogBg.inert = false;
+    currentDialogId = this.id;
+    openDialogs.unshift(this.id);
+    for (const dialogId of openDialogs)
+      if (dialogId !== this.id)
+        (_a = document.querySelector(`#uu-${dialogId}-dialog-bg`)) == null ? void 0 : _a.setAttribute("inert", "true");
+    document.body.classList.remove("uu-no-select");
+    document.body.setAttribute("inert", "true");
+    this.events.emit("open");
+    return dialogBg;
+  }
+  /** Closes the dialog - prevents default action and immediate propagation of the passed event */
+  close(e) {
+    var _a;
+    e == null ? void 0 : e.preventDefault();
+    e == null ? void 0 : e.stopImmediatePropagation();
+    if (!this.isOpen())
+      return;
+    this.dialogOpen = false;
+    const dialogBg = document.querySelector(`#uu-${this.id}-dialog-bg`);
+    if (!dialogBg)
+      return console.warn(`Couldn't find background element for dialog with ID '${this.id}'`);
+    dialogBg.style.visibility = "hidden";
+    dialogBg.style.display = "none";
+    dialogBg.inert = true;
+    openDialogs.splice(openDialogs.indexOf(this.id), 1);
+    currentDialogId = openDialogs[0] ?? null;
+    if (currentDialogId)
+      (_a = document.querySelector(`#uu-${currentDialogId}-dialog-bg`)) == null ? void 0 : _a.removeAttribute("inert");
+    if (openDialogs.length === 0) {
+      document.body.classList.add("uu-no-select");
+      document.body.removeAttribute("inert");
+    }
+    this.events.emit("close");
+    if (this.options.destroyOnClose)
+      this.destroy();
+    else if (this.options.unmountOnClose)
+      this.unmount();
+  }
+  /** Returns true if the dialog is currently open */
+  isOpen() {
+    return this.dialogOpen;
+  }
+  /** Returns true if the dialog is currently mounted */
+  isMounted() {
+    return this.dialogMounted;
+  }
+  /** Clears the DOM of the dialog and removes all event listeners */
+  destroy() {
+    this.unmount();
+    this.events.emit("destroy");
+    this.options.removeListenersOnDestroy && this.unsubscribeAll();
+  }
+  //#region static
+  /** Returns the ID of the top-most dialog (the dialog that has been opened last) */
+  static getCurrentDialogId() {
+    return currentDialogId;
+  }
+  /** Returns the IDs of all currently open dialogs, top-most first */
+  static getOpenDialogs() {
+    return openDialogs;
+  }
+  //#region protected
+  getString(key) {
+    return this.strings[key] ?? defaultStrings[key];
+  }
+  /** Called once to attach all generic event listeners */
+  attachListeners(bgElem) {
+    if (this.options.closeOnBgClick) {
+      bgElem.addEventListener("click", (e) => {
+        var _a;
+        if (this.isOpen() && ((_a = e.target) == null ? void 0 : _a.id) === `uu-${this.id}-dialog-bg`)
+          this.close(e);
+      });
+    }
+    if (this.options.closeOnEscPress) {
+      document.body.addEventListener("keydown", (e) => {
+        if (e.key === "Escape" && this.isOpen() && _Dialog.getCurrentDialogId() === this.id)
+          this.close(e);
+      });
+    }
+  }
+  //#region protected
+  /**
+   * Adds generic, accessible interaction listeners to the passed element.  
+   * All listeners have the default behavior prevented and stop propagation (for keyboard events only as long as the captured key is valid).
+   * @param listenerOptions Provide a {@linkcode listenerOptions} object to configure the listeners
+   */
+  onInteraction(elem, listener, listenerOptions) {
+    const { preventDefault = true, stopPropagation = true, ...listenerOpts } = listenerOptions ?? {};
+    const interactionKeys = ["Enter", " ", "Space"];
+    const proxListener = (e) => {
+      if (e instanceof KeyboardEvent) {
+        if (interactionKeys.includes(e.key)) {
+          preventDefault && e.preventDefault();
+          stopPropagation && e.stopPropagation();
+        } else return;
+      } else if (e instanceof MouseEvent) {
+        preventDefault && e.preventDefault();
+        stopPropagation && e.stopPropagation();
+      }
+      (listenerOpts == null ? void 0 : listenerOpts.once) && e.type === "keydown" && elem.removeEventListener("click", proxListener, listenerOpts);
+      (listenerOpts == null ? void 0 : listenerOpts.once) && e.type === "click" && elem.removeEventListener("keydown", proxListener, listenerOpts);
+      listener(e);
+    };
+    elem.addEventListener("click", proxListener, listenerOpts);
+    elem.addEventListener("keydown", proxListener, listenerOpts);
+  }
+  /** Returns the dialog content element and all its children */
+  async getDialogContent() {
+    var _a, _b, _c, _d;
+    const header = (_b = (_a = this.options).renderHeader) == null ? void 0 : _b.call(_a);
+    const footer = (_d = (_c = this.options).renderFooter) == null ? void 0 : _d.call(_c);
+    const dialogWrapperEl = document.createElement("div");
+    dialogWrapperEl.id = `uu-${this.id}-dialog`;
+    dialogWrapperEl.classList.add("uu-dialog");
+    dialogWrapperEl.ariaLabel = dialogWrapperEl.title = "";
+    dialogWrapperEl.role = "dialog";
+    dialogWrapperEl.setAttribute("aria-labelledby", `uu-${this.id}-dialog-title`);
+    dialogWrapperEl.setAttribute("aria-describedby", `uu-${this.id}-dialog-body`);
+    if (this.options.verticalAlign !== "center")
+      dialogWrapperEl.classList.add(`align-${this.options.verticalAlign}`);
+    const headerWrapperEl = document.createElement("div");
+    headerWrapperEl.classList.add("uu-dialog-header");
+    this.options.small && headerWrapperEl.classList.add("small");
+    if (header) {
+      const headerTitleWrapperEl = document.createElement("div");
+      headerTitleWrapperEl.id = `uu-${this.id}-dialog-title`;
+      headerTitleWrapperEl.classList.add("uu-dialog-title-wrapper");
+      headerTitleWrapperEl.role = "heading";
+      headerTitleWrapperEl.ariaLevel = "1";
+      headerTitleWrapperEl.appendChild(header instanceof Promise ? await header : header);
+      headerWrapperEl.appendChild(headerTitleWrapperEl);
+    } else {
+      const padEl = document.createElement("div");
+      padEl.classList.add("uu-dialog-header-pad", this.options.small ? "small" : "");
+      headerWrapperEl.appendChild(padEl);
+    }
+    if (this.options.renderCloseBtn) {
+      const closeBtnEl = await this.options.renderCloseBtn();
+      closeBtnEl.classList.add("uu-dialog-close");
+      this.options.small && closeBtnEl.classList.add("small");
+      closeBtnEl.tabIndex = 0;
+      if (closeBtnEl.hasAttribute("alt"))
+        closeBtnEl.setAttribute("alt", this.getString("closeDialogTooltip"));
+      closeBtnEl.title = closeBtnEl.ariaLabel = this.getString("closeDialogTooltip");
+      this.onInteraction(closeBtnEl, () => this.close());
+      headerWrapperEl.appendChild(closeBtnEl);
+    }
+    dialogWrapperEl.appendChild(headerWrapperEl);
+    const dialogBodyElem = document.createElement("div");
+    dialogBodyElem.id = `uu-${this.id}-dialog-body`;
+    dialogBodyElem.classList.add("uu-dialog-body");
+    this.options.small && dialogBodyElem.classList.add("small");
+    const body = this.options.renderBody();
+    dialogBodyElem.appendChild(body instanceof Promise ? await body : body);
+    dialogWrapperEl.appendChild(dialogBodyElem);
+    if (footer) {
+      const footerWrapper = document.createElement("div");
+      footerWrapper.classList.add("uu-dialog-footer-cont");
+      dialogWrapperEl.appendChild(footerWrapper);
+      footerWrapper.appendChild(footer instanceof Promise ? await footer : footer);
+    }
+    return dialogWrapperEl;
+  }
+};
+
+// lib/GMStorageEngine.ts
+var GMStorageEngine = class extends (void 0) {
+  options;
+  /**
+   * Creates an instance of `GMStorageEngine`.  
+   *   
+   * - ⚠️ Requires the grants `GM.getValue`, `GM.setValue`, `GM.deleteValue`, and `GM.listValues` in your userscript metadata.
+   * - ⚠️ Don't reuse engine instances, always create a new one for each {@linkcode DataStore} instance.
+   */
+  constructor(options) {
+    super(options == null ? void 0 : options.dataStoreOptions);
+    this.options = {
+      ...options
+    };
+  }
+  /** Fetches a value from persistent storage */
+  async getValue(name, defaultValue) {
+    try {
+      if (!("GM" in globalThis))
+        throw new PlatformError("GM is not defined. Make sure to run this in a userscript environment and that the necessary grants are set.");
+      const value = await globalThis.GM.getValue(name, defaultValue);
+      return value === void 0 ? defaultValue : value;
+    } catch (err) {
+      console.error(`Error getting value for key "${name}":`, err);
+      throw err;
+    }
+  }
+  /** Sets a value in persistent storage */
+  async setValue(name, value) {
+    try {
+      if (!("GM" in globalThis))
+        throw new PlatformError("GM is not defined. Make sure to run this in a userscript environment and that the necessary grants are set.");
+      await globalThis.GM.setValue(name, value);
+    } catch (err) {
+      console.error(`Error setting value for key "${name}":`, err);
+      throw err;
+    }
+  }
+  /** Deletes a value from persistent storage */
+  async deleteValue(name) {
+    try {
+      if (!("GM" in globalThis))
+        throw new PlatformError("GM is not defined. Make sure to run this in a userscript environment and that the necessary grants are set.");
+      await globalThis.GM.deleteValue(name);
+    } catch (err) {
+      console.error(`Error deleting value for key "${name}":`, err);
+      throw err;
+    }
+  }
+  /** Deletes all values from GM storage. Use with caution! */
+  async deleteStorage() {
+    try {
+      if (!("GM" in globalThis))
+        throw new PlatformError("GM is not defined. Make sure to run this in a userscript environment and that the necessary grants are set.");
+      const keys = await globalThis.GM.listValues();
+      for (const key of keys)
+        await globalThis.GM.deleteValue(key);
+    } catch (err) {
+      console.error("Error deleting storage:", err);
+      throw err;
+    }
+  }
+};
+
+// lib/Mixins.ts
+var Mixins = class {
+  /** List of all registered mixins */
+  mixins = [];
+  /** Default configuration object for mixins */
+  defaultMixinCfg;
+  /** Whether the priorities should auto-increment if not specified */
+  autoIncPrioEnabled;
+  /** The current auto-increment priority counter */
+  autoIncPrioCounter = /* @__PURE__ */ new Map();
+  /**
+   * Creates a new Mixins instance.
+   * @param config Configuration object to customize the behavior.
+   */
+  constructor(config = {}) {
+    this.defaultMixinCfg = (void 0)({
+      priority: config.defaultPriority ?? 0,
+      stopPropagation: config.defaultStopPropagation ?? false,
+      signal: config.defaultSignal
+    });
+    this.autoIncPrioEnabled = config.autoIncrementPriority ?? false;
+  }
+  //#region public
+  /**
+   * Adds a mixin function to the given {@linkcode mixinKey}.  
+   * If no priority is specified, it will be calculated via the protected method {@linkcode calcPriority()} based on the constructor configuration, or fall back to the default priority.
+   * @param mixinKey The key to identify the mixin function.
+   * @param mixinFn The function to be called to apply the mixin. The first argument is the input value, the second argument is the context object (if any).
+   * @param config Configuration object to customize the mixin behavior, or just the priority if a number is passed.
+   * @returns Returns a cleanup function, to be called when this mixin is no longer needed.
+   */
+  add(mixinKey, mixinFn, config = (void 0)({})) {
+    const calcPrio = typeof config === "number" ? config : this.calcPriority(mixinKey, config);
+    const mixin = (void 0)({
+      ...this.defaultMixinCfg,
+      key: mixinKey,
+      fn: mixinFn,
+      ...typeof config === "object" ? config : {},
+      ...typeof calcPrio === "number" && !isNaN(calcPrio) ? { priority: calcPrio } : {}
+    });
+    this.mixins.push(mixin);
+    const rem = () => {
+      this.mixins = this.mixins.filter((m) => m !== mixin);
+    };
+    if (mixin.signal)
+      mixin.signal.addEventListener("abort", rem, { once: true });
+    return rem;
+  }
+  /** Returns a list of all added mixins with their keys and configuration objects, but not their functions */
+  list() {
+    return this.mixins.map(({ fn: _f, ...rest }) => rest);
+  }
+  /**
+   * Applies all mixins with the given key to the input value, respecting the priority and stopPropagation settings.  
+   * If additional context is set in the MixinMap, it will need to be passed as the third argument.  
+   * @returns The modified value after all mixins have been applied. The method will return a Promise if at least one of the mixins is async. If all mixins are indicated to be synchronous in TS, but at least one of them turns out to be asynchronous, the return type will be a Promise. With `await`, this will not make a difference, but `.then().catch()` could be affected.
+   */
+  resolve(mixinKey, inputValue, ...inputCtx) {
+    const mixins = this.mixins.filter((m) => m.key === mixinKey);
+    const sortedMixins = [...mixins].sort((a, b) => b.priority - a.priority);
+    let result = inputValue;
+    for (let i = 0; i < sortedMixins.length; i++) {
+      const mixin = sortedMixins[i];
+      result = mixin.fn(result, ...inputCtx);
+      if (result instanceof Promise) {
+        return (async () => {
+          result = await result;
+          if (mixin.stopPropagation)
+            return result;
+          for (let j = i + 1; j < sortedMixins.length; j++) {
+            const mixin2 = sortedMixins[j];
+            result = await mixin2.fn(result, ...inputCtx);
+            if (mixin2.stopPropagation)
+              break;
+          }
+          return result;
+        })();
+      } else if (mixin.stopPropagation)
+        break;
+    }
+    return result;
+  }
+  //#region protected
+  /** Calculates the priority for a mixin based on the given configuration and the current auto-increment state of the instance */
+  calcPriority(mixinKey, config) {
+    if (config.priority !== void 0)
+      return void 0;
+    if (!this.autoIncPrioEnabled)
+      return config.priority ?? this.defaultMixinCfg.priority;
+    if (!this.autoIncPrioCounter.has(mixinKey))
+      this.autoIncPrioCounter.set(mixinKey, this.defaultMixinCfg.priority);
+    let prio = this.autoIncPrioCounter.get(mixinKey);
+    while (this.mixins.some((m) => m.key === mixinKey && m.priority === prio))
+      prio++;
+    this.autoIncPrioCounter.set(mixinKey, prio + 1);
+    return prio;
+  }
+  /**
+   * Removes all mixins with the given key.  
+   * Note: this method is protected to avoid third-party code from removing mixins. If needed, you can extend the Mixins class and expose this method publicly.
+   */
+  removeAll(mixinKey) {
+    this.mixins.filter((m) => m.key === mixinKey);
+    this.mixins = this.mixins.filter((m) => m.key !== mixinKey);
+  }
+};
+
+// lib/SelectorObserver.ts
+var SelectorObserver = class {
+  enabled = false;
+  baseElement;
+  observer;
+  observerOptions;
+  customOptions;
+  listenerMap;
+  constructor(baseElement, options = {}) {
+    this.baseElement = baseElement;
+    this.listenerMap = /* @__PURE__ */ new Map();
+    const {
+      defaultDebounce,
+      defaultDebounceType,
+      disableOnNoListeners,
+      enableOnAddListener,
+      ...observerOptions
+    } = options;
+    this.observerOptions = {
+      childList: true,
+      subtree: true,
+      ...observerOptions
+    };
+    this.customOptions = {
+      defaultDebounce: defaultDebounce ?? 0,
+      defaultDebounceType: defaultDebounceType ?? "immediate",
+      disableOnNoListeners: disableOnNoListeners ?? false,
+      enableOnAddListener: enableOnAddListener ?? true
+    };
+    if (typeof this.customOptions.checkInterval !== "number") {
+      this.observer = new MutationObserver(() => this.checkAllSelectors());
+    } else {
+      this.checkAllSelectors();
+      setInterval(() => this.checkAllSelectors(), this.customOptions.checkInterval);
+    }
+  }
+  /** Call to check all selectors in the {@linkcode listenerMap} using {@linkcode checkSelector()} */
+  checkAllSelectors() {
+    if (!this.enabled || !isDomLoaded())
+      return;
+    for (const [selector, listeners] of this.listenerMap.entries())
+      this.checkSelector(selector, listeners);
+  }
+  /** Checks if the element(s) with the given {@linkcode selector} exist in the DOM and calls the respective {@linkcode listeners} accordingly */
+  checkSelector(selector, listeners) {
+    var _a;
+    if (!this.enabled)
+      return;
+    const baseElement = typeof this.baseElement === "string" ? document.querySelector(this.baseElement) : this.baseElement;
+    if (!baseElement)
+      return;
+    const all = listeners.some((listener) => listener.all);
+    const one = listeners.some((listener) => !listener.all);
+    const allElements = all ? baseElement.querySelectorAll(selector) : null;
+    const oneElement = one ? baseElement.querySelector(selector) : null;
+    for (const options of listeners) {
+      if (options.all) {
+        if (allElements && allElements.length > 0) {
+          options.listener(allElements);
+          if (!options.continuous)
+            this.removeListener(selector, options);
+        }
+      } else {
+        if (oneElement) {
+          options.listener(oneElement);
+          if (!options.continuous)
+            this.removeListener(selector, options);
+        }
+      }
+      if (((_a = this.listenerMap.get(selector)) == null ? void 0 : _a.length) === 0)
+        this.listenerMap.delete(selector);
+      if (this.listenerMap.size === 0 && this.customOptions.disableOnNoListeners)
+        this.disable();
+    }
+  }
+  /**
+   * Starts observing the children of the base element for changes to the given {@linkcode selector} according to the set {@linkcode options}
+   * @param selector The selector to observe
+   * @param options Options for the selector observation
+   * @param options.listener Gets called whenever the selector was found in the DOM
+   * @param [options.all] Whether to use `querySelectorAll()` instead - default is false
+   * @param [options.continuous] Whether to call the listener continuously instead of just once - default is false
+   * @param [options.debounce] Whether to debounce the listener to reduce calls to `querySelector` or `querySelectorAll` - set undefined or <=0 to disable (default)
+   * @returns Returns a function that can be called to remove this listener more easily
+   */
+  addListener(selector, options) {
+    options = {
+      all: false,
+      continuous: false,
+      debounce: 0,
+      ...options
+    };
+    if (options.debounce && options.debounce > 0 || this.customOptions.defaultDebounce && this.customOptions.defaultDebounce > 0) {
+      options.listener = (void 0)(
+        options.listener,
+        options.debounce || this.customOptions.defaultDebounce,
+        options.debounceType || this.customOptions.defaultDebounceType
+      );
+    }
+    if (this.listenerMap.has(selector))
+      this.listenerMap.get(selector).push(options);
+    else
+      this.listenerMap.set(selector, [options]);
+    if (this.enabled === false && this.customOptions.enableOnAddListener)
+      this.enable();
+    this.checkSelector(selector, [options]);
+    return () => this.removeListener(selector, options);
+  }
+  /** Disables the observation of the child elements */
+  disable() {
+    var _a;
+    if (!this.enabled)
+      return;
+    this.enabled = false;
+    (_a = this.observer) == null ? void 0 : _a.disconnect();
+  }
+  /**
+   * Enables or reenables the observation of the child elements.
+   * @param immediatelyCheckSelectors Whether to immediately check if all previously registered selectors exist (default is true)
+   * @returns Returns true when the observation was enabled, false otherwise (e.g. when the base element wasn't found)
+   */
+  enable(immediatelyCheckSelectors = true) {
+    var _a;
+    const baseElement = typeof this.baseElement === "string" ? document.querySelector(this.baseElement) : this.baseElement;
+    if (this.enabled || !baseElement)
+      return false;
+    this.enabled = true;
+    (_a = this.observer) == null ? void 0 : _a.observe(baseElement, this.observerOptions);
+    if (immediatelyCheckSelectors)
+      this.checkAllSelectors();
+    return true;
+  }
+  /** Returns whether the observation of the child elements is currently enabled */
+  isEnabled() {
+    return this.enabled;
+  }
+  /** Removes all listeners that have been registered with {@linkcode addListener()} */
+  clearListeners() {
+    this.listenerMap.clear();
+  }
+  /**
+   * Removes all listeners for the given {@linkcode selector} that have been registered with {@linkcode addListener()}
+   * @returns Returns true when all listeners for the associated selector were found and removed, false otherwise
+   */
+  removeAllListeners(selector) {
+    return this.listenerMap.delete(selector);
+  }
+  /**
+   * Removes a single listener for the given {@linkcode selector} and {@linkcode options} that has been registered with {@linkcode addListener()}
+   * @returns Returns true when the listener was found and removed, false otherwise
+   */
+  removeListener(selector, options) {
+    const listeners = this.listenerMap.get(selector);
+    if (!listeners)
+      return false;
+    const index = listeners.indexOf(options);
+    if (index > -1) {
+      listeners.splice(index, 1);
+      return true;
+    }
+    return false;
+  }
+  /** Returns all listeners that have been registered with {@linkcode addListener()} */
+  getAllListeners() {
+    return this.listenerMap;
+  }
+  /** Returns all listeners for the given {@linkcode selector} that have been registered with {@linkcode addListener()} */
+  getListeners(selector) {
+    return this.listenerMap.get(selector);
+  }
+};
+
+// lib/translation.ts
+var trans = {};
+var valTransforms = [];
+var fallbackLang;
+function translate(language, key, ...trArgs) {
+  if (typeof language !== "string")
+    language = fallbackLang ?? "";
+  const trObj = trans[language];
+  if (typeof language !== "string" || language.length === 0 || typeof trObj !== "object" || trObj === null)
+    return fallbackLang && language !== fallbackLang ? translate(fallbackLang, key, ...trArgs) : key;
+  const transformTrVal = (trKey, trValue) => {
+    const tfs = valTransforms.filter(({ regex }) => new RegExp(regex).test(String(trValue)));
+    if (tfs.length === 0)
+      return String(trValue);
+    let retStr = String(trValue);
+    for (const tf of tfs) {
+      const re = new RegExp(tf.regex);
+      const matches = [];
+      let execRes;
+      while ((execRes = re.exec(trValue)) !== null) {
+        if (matches.some((m) => m[0] === (execRes == null ? void 0 : execRes[0]) && m.index === (execRes == null ? void 0 : execRes.index)))
+          break;
+        matches.push(execRes);
+      }
+      retStr = String(tf.fn({
+        language,
+        trValue,
+        currentValue: retStr,
+        matches,
+        trKey,
+        trArgs
+      }));
+    }
+    return retStr;
+  };
+  const keyParts = key.split(".");
+  let value = trObj;
+  for (const part of keyParts) {
+    if (typeof value !== "object" || value === null) {
+      value = void 0;
+      break;
+    }
+    value = value == null ? void 0 : value[part];
+  }
+  if (typeof value === "string")
+    return transformTrVal(key, value);
+  value = trObj == null ? void 0 : trObj[key];
+  if (typeof value === "string")
+    return transformTrVal(key, value);
+  return fallbackLang && language !== fallbackLang ? translate(fallbackLang, key, ...trArgs) : key;
+}
+function trFor(language, key, ...args) {
+  const txt = translate(language, key, ...args);
+  if (txt === key)
+    return fallbackLang ? translate(fallbackLang, key, ...args) : key;
+  return txt;
+}
+function useTr(language) {
+  return (key, ...args) => translate(language, key, ...args);
+}
+function hasKey(language = fallbackLang ?? "", key) {
+  return tr.for(language, key) !== key;
+}
+function addTranslations(language, translations) {
+  trans[language] = JSON.parse(JSON.stringify(translations));
+}
+function getTranslations(language = fallbackLang ?? "") {
+  return trans[language];
+}
+var deleteTranslations = (language) => {
+  if (language in trans) {
+    delete trans[language];
+    return true;
+  }
+  return false;
+};
+function setFallbackLanguage(fallbackLanguage) {
+  fallbackLang = fallbackLanguage;
+}
+function getFallbackLanguage() {
+  return fallbackLang;
+}
+function addTransform(transform) {
+  const [regex, fn] = transform;
+  valTransforms.push({
+    fn,
+    regex
+  });
+}
+function deleteTransform(patternOrFn) {
+  const idx = valTransforms.findIndex(
+    (t) => typeof patternOrFn === "function" ? t.fn === patternOrFn : t.regex === patternOrFn
+  );
+  if (idx !== -1) {
+    valTransforms.splice(idx, 1);
+    return true;
+  }
+  return false;
+}
+var templateLiteralTransform = [
+  /\$\{([a-zA-Z0-9$_-]+)\}/gm,
+  ({ matches, trArgs, trValue }) => {
+    const patternStart = "${", patternEnd = "}", patternRegex = /\$\{.+\}/m;
+    let str = String(trValue);
+    const eachKeyInTrString = (keys) => keys.every((key) => trValue.includes(`${patternStart}${key}${patternEnd}`));
+    const namedMapping = () => {
+      if (!str.includes(patternStart) || typeof trArgs[0] === "undefined" || typeof trArgs[0] !== "object" || !eachKeyInTrString(Object.keys(trArgs[0] ?? {})))
+        return;
+      for (const match of matches) {
+        const repl = match[1] !== void 0 ? trArgs[0][match[1]] : void 0;
+        if (typeof repl !== "undefined")
+          str = str.replace(match[0], String(repl));
+      }
+    };
+    const positionalMapping = () => {
+      if (!patternRegex.test(str) || !trArgs[0])
+        return;
+      let matchNum = -1;
+      for (const match of matches) {
+        matchNum++;
+        if (typeof trArgs[matchNum] !== "undefined")
+          str = str.replace(match[0], String(trArgs[matchNum]));
+      }
+    };
+    let notStringifiable = false;
+    try {
+      String(trArgs[0]);
+    } catch {
+      notStringifiable = true;
+    }
+    const isArgsObject = trArgs[0] && typeof trArgs[0] === "object" && trArgs[0] !== null && (notStringifiable || String(trArgs[0]).startsWith("[object"));
+    if (isArgsObject && eachKeyInTrString(Object.keys(trArgs[0])))
+      namedMapping();
+    else
+      positionalMapping();
+    return str;
+  }
+];
+var percentTransform = [
+  /%(\d+)/gm,
+  ({ matches, trArgs, trValue }) => {
+    let str = String(trValue);
+    for (const match of matches) {
+      const repl = match[1] !== void 0 ? trArgs == null ? void 0 : trArgs[Number(match[1]) - 1] : void 0;
+      if (typeof repl !== "undefined")
+        str = str.replace(match[0], String(repl));
+    }
+    return str;
+  }
+];
+var tr = {
+  for: (...params) => trFor(...params),
+  use: (...params) => useTr(...params),
+  hasKey: (language = fallbackLang ?? "", key) => hasKey(language, key),
+  addTranslations,
+  getTranslations,
+  deleteTranslations,
+  setFallbackLanguage,
+  getFallbackLanguage,
+  addTransform,
+  deleteTransform,
+  transforms: {
+    templateLiteral: templateLiteralTransform,
+    percent: percentTransform
+  }
+};
+//# sourceMappingURL=UserUtils.cjs.map