bc-deeplib 1.0.5 → 1.1.0

package/dist/deeplib.js

@@ -0,0 +1,2582 @@
+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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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
+));
+
+// node_modules/.pnpm/bondage-club-mod-sdk@1.2.0/node_modules/bondage-club-mod-sdk/dist/bcmodsdk.js
+var require_bcmodsdk = __commonJS({
+  "node_modules/.pnpm/bondage-club-mod-sdk@1.2.0/node_modules/bondage-club-mod-sdk/dist/bcmodsdk.js"(exports) {
+    var bcModSdk = function() {
+      "use strict";
+      const o = "1.2.0";
+      function e(o2) {
+        alert("Mod ERROR:\n" + o2);
+        const e2 = new Error(o2);
+        throw console.error(e2), e2;
+      }
+      __name(e, "e");
+      const t = new TextEncoder();
+      function n(o2) {
+        return !!o2 && "object" == typeof o2 && !Array.isArray(o2);
+      }
+      __name(n, "n");
+      function r(o2) {
+        const e2 = /* @__PURE__ */ new Set();
+        return o2.filter((o3) => !e2.has(o3) && e2.add(o3));
+      }
+      __name(r, "r");
+      const i = /* @__PURE__ */ new Map(), a = /* @__PURE__ */ new Set();
+      function c(o2) {
+        a.has(o2) || (a.add(o2), console.warn(o2));
+      }
+      __name(c, "c");
+      function s(o2) {
+        const e2 = [], t2 = /* @__PURE__ */ new Map(), n2 = /* @__PURE__ */ new Set();
+        for (const r3 of f.values()) {
+          const i3 = r3.patching.get(o2.name);
+          if (i3) {
+            e2.push(...i3.hooks);
+            for (const [e3, a2] of i3.patches.entries()) t2.has(e3) && t2.get(e3) !== a2 && c(`ModSDK: Mod '${r3.name}' is patching function ${o2.name} with same pattern that is already applied by different mod, but with different pattern:
+Pattern:
+${e3}
+Patch1:
+${t2.get(e3) || ""}
+Patch2:
+${a2}`), t2.set(e3, a2), n2.add(r3.name);
+          }
+        }
+        e2.sort((o3, e3) => e3.priority - o3.priority);
+        const r2 = function(o3, e3) {
+          if (0 === e3.size) return o3;
+          let t3 = o3.toString().replaceAll("\r\n", "\n");
+          for (const [n3, r3] of e3.entries()) t3.includes(n3) || c(`ModSDK: Patching ${o3.name}: Patch ${n3} not applied`), t3 = t3.replaceAll(n3, r3);
+          return (0, eval)(`(${t3})`);
+        }(o2.original, t2);
+        let i2 = /* @__PURE__ */ __name(function(e3) {
+          var t3, i3;
+          const a2 = null === (i3 = (t3 = m.errorReporterHooks).hookChainExit) || void 0 === i3 ? void 0 : i3.call(t3, o2.name, n2), c2 = r2.apply(this, e3);
+          return null == a2 || a2(), c2;
+        }, "i");
+        for (let t3 = e2.length - 1; t3 >= 0; t3--) {
+          const n3 = e2[t3], r3 = i2;
+          i2 = /* @__PURE__ */ __name(function(e3) {
+            var t4, i3;
+            const a2 = null === (i3 = (t4 = m.errorReporterHooks).hookEnter) || void 0 === i3 ? void 0 : i3.call(t4, o2.name, n3.mod), c2 = n3.hook.apply(this, [e3, (o3) => {
+              if (1 !== arguments.length || !Array.isArray(e3)) throw new Error(`Mod ${n3.mod} failed to call next hook: Expected args to be array, got ${typeof o3}`);
+              return r3.call(this, o3);
+            }]);
+            return null == a2 || a2(), c2;
+          }, "i");
+        }
+        return { hooks: e2, patches: t2, patchesSources: n2, enter: i2, final: r2 };
+      }
+      __name(s, "s");
+      function l(o2, e2 = false) {
+        let r2 = i.get(o2);
+        if (r2) e2 && (r2.precomputed = s(r2));
+        else {
+          let e3 = window;
+          const a2 = o2.split(".");
+          for (let t2 = 0; t2 < a2.length - 1; t2++) if (e3 = e3[a2[t2]], !n(e3)) throw new Error(`ModSDK: Function ${o2} to be patched not found; ${a2.slice(0, t2 + 1).join(".")} is not object`);
+          const c2 = e3[a2[a2.length - 1]];
+          if ("function" != typeof c2) throw new Error(`ModSDK: Function ${o2} to be patched not found`);
+          const l2 = function(o3) {
+            let e4 = -1;
+            for (const n2 of t.encode(o3)) {
+              let o4 = 255 & (e4 ^ n2);
+              for (let e5 = 0; e5 < 8; e5++) o4 = 1 & o4 ? -306674912 ^ o4 >>> 1 : o4 >>> 1;
+              e4 = e4 >>> 8 ^ o4;
+            }
+            return ((-1 ^ e4) >>> 0).toString(16).padStart(8, "0").toUpperCase();
+          }(c2.toString().replaceAll("\r\n", "\n")), d2 = { name: o2, original: c2, originalHash: l2 };
+          r2 = Object.assign(Object.assign({}, d2), { precomputed: s(d2), router: /* @__PURE__ */ __name(() => {
+          }, "router"), context: e3, contextProperty: a2[a2.length - 1] }), r2.router = /* @__PURE__ */ function(o3) {
+            return function(...e4) {
+              return o3.precomputed.enter.apply(this, [e4]);
+            };
+          }(r2), i.set(o2, r2), e3[r2.contextProperty] = r2.router;
+        }
+        return r2;
+      }
+      __name(l, "l");
+      function d() {
+        for (const o2 of i.values()) o2.precomputed = s(o2);
+      }
+      __name(d, "d");
+      function p() {
+        const o2 = /* @__PURE__ */ new Map();
+        for (const [e2, t2] of i) o2.set(e2, { name: e2, original: t2.original, originalHash: t2.originalHash, sdkEntrypoint: t2.router, currentEntrypoint: t2.context[t2.contextProperty], hookedByMods: r(t2.precomputed.hooks.map((o3) => o3.mod)), patchedByMods: Array.from(t2.precomputed.patchesSources) });
+        return o2;
+      }
+      __name(p, "p");
+      const f = /* @__PURE__ */ new Map();
+      function u(o2) {
+        f.get(o2.name) !== o2 && e(`Failed to unload mod '${o2.name}': Not registered`), f.delete(o2.name), o2.loaded = false, d();
+      }
+      __name(u, "u");
+      function g(o2, t2) {
+        o2 && "object" == typeof o2 || e("Failed to register mod: Expected info object, got " + typeof o2), "string" == typeof o2.name && o2.name || e("Failed to register mod: Expected name to be non-empty string, got " + typeof o2.name);
+        let r2 = `'${o2.name}'`;
+        "string" == typeof o2.fullName && o2.fullName || e(`Failed to register mod ${r2}: Expected fullName to be non-empty string, got ${typeof o2.fullName}`), r2 = `'${o2.fullName} (${o2.name})'`, "string" != typeof o2.version && e(`Failed to register mod ${r2}: Expected version to be string, got ${typeof o2.version}`), o2.repository || (o2.repository = void 0), void 0 !== o2.repository && "string" != typeof o2.repository && e(`Failed to register mod ${r2}: Expected repository to be undefined or string, got ${typeof o2.version}`), null == t2 && (t2 = {}), t2 && "object" == typeof t2 || e(`Failed to register mod ${r2}: Expected options to be undefined or object, got ${typeof t2}`);
+        const i2 = true === t2.allowReplace, a2 = f.get(o2.name);
+        a2 && (a2.allowReplace && i2 || e(`Refusing to load mod ${r2}: it is already loaded and doesn't allow being replaced.
+Was the mod loaded multiple times?`), u(a2));
+        const c2 = /* @__PURE__ */ __name((o3) => {
+          let e2 = g2.patching.get(o3.name);
+          return e2 || (e2 = { hooks: [], patches: /* @__PURE__ */ new Map() }, g2.patching.set(o3.name, e2)), e2;
+        }, "c"), s2 = /* @__PURE__ */ __name((o3, t3) => (...n2) => {
+          var i3, a3;
+          const c3 = null === (a3 = (i3 = m.errorReporterHooks).apiEndpointEnter) || void 0 === a3 ? void 0 : a3.call(i3, o3, g2.name);
+          g2.loaded || e(`Mod ${r2} attempted to call SDK function after being unloaded`);
+          const s3 = t3(...n2);
+          return null == c3 || c3(), s3;
+        }, "s"), p2 = { unload: s2("unload", () => u(g2)), hookFunction: s2("hookFunction", (o3, t3, n2) => {
+          "string" == typeof o3 && o3 || e(`Mod ${r2} failed to patch a function: Expected function name string, got ${typeof o3}`);
+          const i3 = l(o3), a3 = c2(i3);
+          "number" != typeof t3 && e(`Mod ${r2} failed to hook function '${o3}': Expected priority number, got ${typeof t3}`), "function" != typeof n2 && e(`Mod ${r2} failed to hook function '${o3}': Expected hook function, got ${typeof n2}`);
+          const s3 = { mod: g2.name, priority: t3, hook: n2 };
+          return a3.hooks.push(s3), d(), () => {
+            const o4 = a3.hooks.indexOf(s3);
+            o4 >= 0 && (a3.hooks.splice(o4, 1), d());
+          };
+        }), patchFunction: s2("patchFunction", (o3, t3) => {
+          "string" == typeof o3 && o3 || e(`Mod ${r2} failed to patch a function: Expected function name string, got ${typeof o3}`);
+          const i3 = l(o3), a3 = c2(i3);
+          n(t3) || e(`Mod ${r2} failed to patch function '${o3}': Expected patches object, got ${typeof t3}`);
+          for (const [n2, i4] of Object.entries(t3)) "string" == typeof i4 ? a3.patches.set(n2, i4) : null === i4 ? a3.patches.delete(n2) : e(`Mod ${r2} failed to patch function '${o3}': Invalid format of patch '${n2}'`);
+          d();
+        }), removePatches: s2("removePatches", (o3) => {
+          "string" == typeof o3 && o3 || e(`Mod ${r2} failed to patch a function: Expected function name string, got ${typeof o3}`);
+          const t3 = l(o3);
+          c2(t3).patches.clear(), d();
+        }), callOriginal: s2("callOriginal", (o3, t3, n2) => {
+          "string" == typeof o3 && o3 || e(`Mod ${r2} failed to call a function: Expected function name string, got ${typeof o3}`);
+          const i3 = l(o3);
+          return Array.isArray(t3) || e(`Mod ${r2} failed to call a function: Expected args array, got ${typeof t3}`), i3.original.apply(null != n2 ? n2 : globalThis, t3);
+        }), getOriginalHash: s2("getOriginalHash", (o3) => {
+          "string" == typeof o3 && o3 || e(`Mod ${r2} failed to get hash: Expected function name string, got ${typeof o3}`);
+          return l(o3).originalHash;
+        }) }, g2 = { name: o2.name, fullName: o2.fullName, version: o2.version, repository: o2.repository, allowReplace: i2, api: p2, loaded: true, patching: /* @__PURE__ */ new Map() };
+        return f.set(o2.name, g2), Object.freeze(p2);
+      }
+      __name(g, "g");
+      function h() {
+        const o2 = [];
+        for (const e2 of f.values()) o2.push({ name: e2.name, fullName: e2.fullName, version: e2.version, repository: e2.repository });
+        return o2;
+      }
+      __name(h, "h");
+      let m;
+      const y = void 0 === window.bcModSdk ? window.bcModSdk = function() {
+        const e2 = { version: o, apiVersion: 1, registerMod: g, getModsInfo: h, getPatchingInfo: p, errorReporterHooks: Object.seal({ apiEndpointEnter: null, hookEnter: null, hookChainExit: null }) };
+        return m = e2, Object.freeze(e2);
+      }() : (n(window.bcModSdk) || e("Failed to init Mod SDK: Name already in use"), 1 !== window.bcModSdk.apiVersion && e(`Failed to init Mod SDK: Different version already loaded ('1.2.0' vs '${window.bcModSdk.version}')`), window.bcModSdk.version !== o && alert(`Mod SDK warning: Loading different but compatible versions ('1.2.0' vs '${window.bcModSdk.version}')
+One of mods you are using is using an old version of SDK. It will work for now but please inform author to update`), window.bcModSdk);
+      return "undefined" != typeof exports && (Object.defineProperty(exports, "__esModule", { value: true }), exports.default = y), y;
+    }();
+  }
+});
+
+// src/base/base_module.ts
+var BaseModule = class {
+  static {
+    __name(this, "BaseModule");
+  }
+  get settingsScreen() {
+    return null;
+  }
+  get settingsStorage() {
+    return this.constructor.name;
+  }
+  get settings() {
+    const modName = ModSdkManager.ModInfo.name;
+    if (!this.settingsStorage) return {};
+    if (!modStorage.playerStorage) {
+      Player[modName] = {};
+      this.registerDefaultSettings();
+    } else if (!modStorage.playerStorage[this.settingsStorage]) this.registerDefaultSettings();
+    return modStorage.playerStorage[this.settingsStorage];
+  }
+  set settings(value) {
+    const modName = ModSdkManager.ModInfo.name;
+    const storage = new ModStorage(modName);
+    if (!this.settingsStorage) return;
+    if (!storage.playerStorage) {
+      Player[modName] = {};
+      this.registerDefaultSettings();
+    } else if (!storage.playerStorage[this.settingsStorage]) this.registerDefaultSettings();
+    storage.playerStorage[this.settingsStorage] = value;
+  }
+  init() {
+    this.registerDefaultSettings();
+  }
+  registerDefaultSettings() {
+    const storage = this.settingsStorage;
+    const defaults = this.defaultSettings;
+    if (!storage || !defaults) return;
+    Player[ModSdkManager.ModInfo.name][storage] = Object.assign(defaults, Player[ModSdkManager.ModInfo.name][storage] ?? {});
+  }
+  get defaultSettings() {
+    return null;
+  }
+  load() {
+  }
+  run() {
+  }
+  unload() {
+  }
+};
+
+// src/base/base_subscreen.ts
+function getCurrentSubscreen() {
+  return GUI.instance && GUI.instance.currentSubscreen;
+}
+__name(getCurrentSubscreen, "getCurrentSubscreen");
+function setSubscreen(subscreen) {
+  if (!GUI.instance) {
+    throw new Error("Attempt to set subscreen before init");
+  }
+  GUI.instance.currentSubscreen = subscreen;
+  return GUI.instance.currentSubscreen;
+}
+__name(setSubscreen, "setSubscreen");
+var BaseSubscreen = class _BaseSubscreen {
+  static {
+    __name(this, "BaseSubscreen");
+  }
+  static currentElements = [];
+  static currentPage = 1;
+  options;
+  module;
+  constructor(subscreenOptions, module) {
+    if (module) this.module = module;
+    this.options = subscreenOptions || {};
+  }
+  get name() {
+    return "UNKNOWN";
+  }
+  get icon() {
+    return "";
+  }
+  get subscreenName() {
+    return this.constructor.name;
+  }
+  setSubscreen(screen) {
+    return setSubscreen(screen);
+  }
+  get settings() {
+    return this.module.settings;
+  }
+  set settings(value) {
+    this.module.settings = value;
+  }
+  get pageStructure() {
+    return [[]];
+  }
+  get currentPage() {
+    return this.pageStructure[Math.min(_BaseSubscreen.currentPage - 1, this.pageStructure.length - 1)];
+  }
+  changePage(page, setLabel) {
+    const totalPages = this.pageStructure.length;
+    if (page > totalPages) page = 1;
+    if (page < 1) page = totalPages;
+    _BaseSubscreen.currentPage = page;
+    this.managePageElementsVisibility();
+    setLabel(`${_BaseSubscreen.currentPage} of ${this.pageStructure.length}`);
+  }
+  managePageElementsVisibility() {
+    this.pageStructure.forEach((item, ix) => {
+      if (ix != _BaseSubscreen.currentPage - 1) {
+        item.forEach((setting) => {
+          domUtil.hide(`${setting.id}-container`);
+        });
+      } else {
+        item.forEach((setting) => {
+          domUtil.unhide(`${setting.id}-container`);
+        });
+      }
+    });
+  }
+  load() {
+    for (const module of modules()) {
+      if (!module.settingsScreen) continue;
+      if (!module.settings || !Object.keys(module.settings).length) module.registerDefaultSettings();
+    }
+    _BaseSubscreen.currentPage = 1;
+    layoutElement.createSubscreenDiv();
+    const settingsElement = layoutElement.createSettingsDiv();
+    layoutElement.appendToSubscreenDiv(settingsElement);
+    const menu = ElementMenu.Create("deeplib-nav-menu", []);
+    layoutElement.appendToSubscreenDiv(menu);
+    if (this.pageStructure.length > 1) {
+      const backNext = advancedElement.createBackNext({
+        id: "deeplib-page-back-next",
+        next: /* @__PURE__ */ __name(({ setLabel }) => this.changePage(_BaseSubscreen.currentPage + 1, setLabel), "next"),
+        initialNextTooltip: getText("settings.button.next_button_hint"),
+        back: /* @__PURE__ */ __name(({ setLabel }) => this.changePage(_BaseSubscreen.currentPage - 1, setLabel), "back"),
+        initialPrevTooltip: getText("settings.button.prev_button_hint"),
+        initialLabel: `${_BaseSubscreen.currentPage} of ${this.pageStructure.length}`
+      });
+      ElementMenu.PrependItem(menu, backNext);
+    }
+    const subscreenTitle = advancedElement.createLabel({
+      id: "deeplib-subscreen-title",
+      label: getText(`${this.name}.title`).replace("$ModVersion", ModSdkManager.ModInfo.version)
+    });
+    layoutElement.appendToSubscreenDiv(subscreenTitle);
+    if (this.name !== "mainmenu") {
+      const exitButton = advancedElement.createButton({
+        id: "deeplib-exit",
+        size: [90, 90],
+        image: `${PUBLIC_URL}/dl_images/exit.svg`,
+        onClick: /* @__PURE__ */ __name(() => {
+          this.exit();
+        }, "onClick"),
+        tooltip: getText("settings.button.back_button_hint")
+      });
+      ElementMenu.AppendButton(menu, exitButton);
+    }
+    const tooltip = advancedElement.createTooltip();
+    layoutElement.appendToSubscreenDiv(tooltip);
+    this.pageStructure.forEach(
+      (s) => s.forEach((item) => {
+        let element;
+        switch (item.type) {
+          case "text":
+          case "number":
+          case "color":
+            element = advancedElement.createInput(item);
+            break;
+          case "checkbox":
+            element = advancedElement.createCheckbox(item);
+            break;
+          case "button":
+            element = advancedElement.createButton(item);
+            break;
+          case "label":
+            element = advancedElement.createLabel(item);
+            break;
+          case "custom":
+            element = advancedElement.createCustom(item);
+            break;
+        }
+        layoutElement.appendToSettingsDiv(element);
+      })
+    );
+    this.managePageElementsVisibility();
+    CharacterAppearanceForceUpCharacter = Player.MemberNumber ?? -1;
+  }
+  run() {
+    if (this.options.drawCharacter) DrawCharacter(Player, 50, 50, 0.9, false);
+  }
+  click() {
+  }
+  exit() {
+    CharacterAppearanceForceUpCharacter = -1;
+    CharacterLoadCanvas(Player);
+    setSubscreen("mainmenu");
+    modStorage.save();
+  }
+  resize(onLoad = false) {
+    const offset = this.options.drawCharacter ? 0 : 380;
+    const subscreen = layoutElement.getSubscreenDiv();
+    const settingsDiv = layoutElement.getSettingsDiv();
+    ElementSetPosition(subscreen || "", 0, 0);
+    ElementSetSize(subscreen || "", 2e3, 1e3);
+    ElementSetFontSize(subscreen || "", "auto");
+    if (this.name === "mainmenu") {
+      ElementSetPosition(settingsDiv || "", 530 - offset, 170);
+      ElementSetSize(settingsDiv || "", 600 + offset, 660);
+    } else {
+      ElementSetPosition(settingsDiv || "", 530 - offset, 170);
+      ElementSetSize(settingsDiv || "", 1e3 + offset, 660);
+    }
+    ElementSetPosition("deeplib-subscreen-title", 530 - offset, 75);
+    ElementSetSize("deeplib-subscreen-title", 800, 60);
+    ElementSetPosition("deeplib-nav-menu", 1905, 75, "top-right");
+    ElementSetSize("deeplib-nav-menu", null, 90);
+    ElementSetPosition(advancedElement.getTooltip() || "", 250, 850);
+    ElementSetSize(advancedElement.getTooltip() || "", 1500, 70);
+    _BaseSubscreen.currentElements.forEach((item) => {
+      const options = item[1];
+      domUtil.autoSetPosition(options.id, options.position);
+      domUtil.autoSetSize(options.id, options.size);
+    });
+    if (settingsDiv) {
+      if (domUtil.hasOverflow(settingsDiv)?.vertical) {
+        settingsDiv.classList.add("deeplib-overflow-box");
+      } else {
+        settingsDiv.classList.remove("deeplib-overflow-box");
+      }
+    }
+  }
+  unload() {
+    _BaseSubscreen.currentElements = [];
+    layoutElement.removeSubscreenDiv();
+  }
+};
+
+// src/styles/index.scss
+var styles_default = `.deeplib-subscreen,
+.deeplib-modal {
+  --deeplib-background-color: var(--tmd-main, white);
+  --deeplib-element-color: var(--tmd-element, white);
+  --deeplib-element-hover-color: var(--tmd-element-hover, cyan);
+  --deeplib-blocked-color: var(--tmd-blocked, red);
+  --deeplib-text-color: var(--tmd-text, black);
+  --deeplib-icon-color: var(--tmd-accent, white);
+  --deeplib-icon-hover-color: var(--tmd-accent-hover, cyan);
+  --deeplib-border-color: var(--tmd-accent, black);
+  --deeplib-border-width: min(0.2vh, 0.1vw);
+  --deeplib-border-width: min(0.2dvh, 0.1dvw);
+  --deeplib-border-radius: min(1vh, 0.5vw);
+  --deeplib-border-radius: min(1dvh, 0.5dvw);
+}
+
+.deeplib-button {
+  color: var(--deeplib-text-color);
+  width: 100%;
+  height: 100%;
+}
+
+.deeplib-button.button-styling,
+.deeplib-button.button-styling::before {
+  border-radius: min(1dvh, 0.5dvw);
+}
+
+.deeplib-button img {
+  position: absolute;
+  top: 0%;
+  left: 0%;
+  width: 100%;
+  height: 100%;
+  background-position: left;
+  background-color: var(--deeplib-icon-color);
+  background-blend-mode: multiply;
+  background-size: contain;
+  mask-position: left;
+  mask-size: contain;
+  background-repeat: no-repeat;
+  mask-repeat: no-repeat;
+  color: transparent;
+  background-image: var(--image);
+  mask-image: var(--image);
+  pointer-events: none;
+}
+
+.deeplib-button:hover img {
+  background-color: var(--deeplib-icon-hover-color);
+}
+
+.deeplib-button .button-label {
+  background-color: transparent !important;
+  color: var(--deeplib-text-color);
+  font-size: min(3.6dvh, 1.8dvw);
+}
+
+.deeplib-button .button-tooltip {
+  border-radius: min(1dvh, 0.5dvw);
+}
+
+#deeplib-page-label {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+
+#deeplib-subscreen-title {
+  text-align: left;
+  color: var(--deeplib-text-color);
+}
+
+.deeplib-text {
+  color: var(--deeplib-text-color);
+}
+
+.deeplib-subscreen {
+  padding: 0;
+  margin: 0;
+  pointer-events: none;
+}
+
+.deeplib-subscreen * {
+  box-sizing: border-box;
+  pointer-events: all;
+}
+
+.deeplib-settings {
+  display: grid;
+  grid-auto-rows: min-content;
+  padding: min(1dvh, 0.5dvw);
+  gap: 0.3em;
+  overflow-y: scroll;
+}
+
+.deeplib-misc {
+  display: flex;
+  align-items: center;
+  flex-direction: column-reverse;
+  gap: min(1vh, 0.5vw);
+}
+
+.deeplib-tooltip {
+  background-color: var(--deeplib-element-color);
+  color: var(--deeplib-text-color);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  border-radius: min(1dvh, 0.5dvw);
+  padding: min(1vh, 0.5vw);
+  font-size: 0.8em;
+  border: min(0.2vh, 0.1vw) solid var(--deeplib-border-color);
+}
+
+.deeplib-overflow-box {
+  border: var(--deeplib-border-color) solid var(--deeplib-border-width);
+}
+
+.deeplib-prev-next {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  flex-direction: row;
+  gap: min(2dvh, 1dvw);
+  background-color: var(--deeplib-element-color);
+  color: var(--deeplib-text-color);
+  border-radius: min(1dvh, 0.5dvw);
+  border: min(0.2vh, 0.1vw) solid var(--deeplib-border-color);
+}
+.deeplib-prev-next .deeplib-prev-next-button {
+  height: 100%;
+  aspect-ratio: 1;
+}
+.deeplib-prev-next .deeplib-prev-next-button:hover {
+  background-color: var(--deeplib-element-hover-color);
+  border-radius: var(--deeplib-border-radius);
+}
+.deeplib-prev-next .deeplib-prev-next-label {
+  white-space: nowrap;
+}
+
+#deeplib-nav-menu {
+  display: flex;
+  flex-direction: row;
+  gap: min(2dvh, 1dvw);
+}
+
+.deeplib-checkbox-container {
+  display: flex;
+  flex-direction: row;
+  align-items: center;
+  gap: 0.3em;
+}
+
+.deeplib-checkbox-container input.deeplib-input {
+  width: min(5vh, 2.5vw);
+  height: min(5vh, 2.5vw);
+  border-radius: min(1dvh, 0.5dvw);
+}
+
+.deeplib-checkbox-container input.deeplib-input[type=checkbox]:checked::before {
+  width: 80%;
+  height: 80%;
+}
+
+.deeplib-input-container {
+  display: flex;
+  flex-direction: row;
+  align-items: center;
+  gap: 0.3em;
+}
+
+.deeplib-input-container:has(label.deeplib-text) {
+  margin-top: min(1vh, 0.5vw);
+}
+
+.deeplib-input-container input.deeplib-input {
+  font-size: 0.6em;
+  padding: 5px 0;
+  background-color: transparent;
+  outline: none;
+  padding-left: min(1vh, 0.5vw);
+  padding-right: min(1vh, 0.5vw);
+  min-height: min(5dvh, 2.5dvw);
+  border-radius: min(1dvh, 0.5dvw);
+}
+
+.deeplib-input-container input.deeplib-input[type=color] {
+  padding: 0px;
+  width: min(5vh, 2.5vw);
+  height: min(5vh, 2.5vw);
+  border-radius: 0px;
+}
+
+.deeplib-input-container input.deeplib-input[type=color]:disabled {
+  border: var(--deeplib-blocked-color) solid var(--deeplib-border-width);
+  cursor: not-allowed;
+}
+
+input::-webkit-outer-spin-button,
+input::-webkit-inner-spin-button {
+  -webkit-appearance: none;
+  margin: 0;
+}
+
+input[type=number] {
+  appearance: textfield;
+  -moz-appearance: textfield;
+}
+
+.deeplib-highlight-text {
+  font-weight: bold;
+  color: rgb(203, 185, 23);
+}
+
+#TextAreaChatLog[data-colortheme=dark] div.ChatMessage.deeplib-message,
+#TextAreaChatLog[data-colortheme=dark2] div.ChatMessage.deeplib-message {
+  background-color: var(--deeplib-element-color);
+  border: min(0.2dvh, 0.1dvw) solid var(--deeplib-border-color);
+  color: var(--deeplib-text-color);
+}
+
+#TextAreaChatLog div.ChatMessage.deeplib-message {
+  background-color: #eee;
+  border: min(0.2dvh, 0.1dvw) solid #440171;
+  color: #111;
+  padding-left: min(0.6dvh, 0.3dvw);
+  display: block;
+  white-space: normal;
+}
+
+#TextAreaChatLog[data-colortheme=dark] div.ChatMessage.deeplib-message a,
+#TextAreaChatLog[data-colortheme=dark2] div.ChatMessage.deeplib-message a {
+  color: var(--deeplib-text-color);
+}
+
+#TextAreaChatLog div.ChatMessage.deeplib-message a {
+  cursor: pointer;
+  font-weight: bold;
+  color: #111;
+}
+
+.deeplib-modal {
+  position: fixed;
+  top: 10%;
+  left: 50%;
+  transform: translateX(-50%);
+  z-index: 1001;
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+  align-items: center;
+  gap: 0.5em;
+  width: max(50dvw, 25dvh);
+  font-size: min(4dvh, 2dvw);
+  padding: min(2dvh, 1dvw);
+  background-color: var(--deeplib-element-color);
+  border-radius: min(1.2dvh, 0.6dvw);
+  border: min(0.2dvh, 0.1dvw) solid var(--deeplib-border-color);
+  color: var(--deeplib-text-color);
+}
+.deeplib-modal .deeplib-modal-input {
+  width: 100%;
+  font-size: min(2.6dvh, 1.8dvw);
+  border-radius: min(1dvh, 0.5dvw);
+  padding: min(1dvh, 0.5dvw);
+}
+.deeplib-modal input.deeplib-modal-input {
+  max-width: max(50dvh, 25dvw);
+}
+.deeplib-modal .deeplib-modal-button-container {
+  display: flex;
+  flex-direction: row;
+  justify-content: flex-end;
+  gap: 0.5em;
+  width: 100%;
+}
+.deeplib-modal .deeplib-modal-button-container .deeplib-button {
+  font-size: 0.8em;
+  display: flex;
+  width: auto;
+  padding: min(0.4vh, 0.2vw) min(2vh, 1vw);
+}
+.deeplib-modal .deeplib-modal-button-container .deeplib-button .button-label {
+  display: contents;
+}
+
+.deeplib-modal-blocker {
+  z-index: 1000;
+  position: fixed;
+  top: 0;
+  left: 0;
+  width: 100dvw;
+  height: 100dvh;
+  background-color: rgba(0, 0, 0, 0.5);
+}
+/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sourceRoot":"/media/Deo/NVME/Stuff/Code/BC/BC-DeepLib/src/styles","sources":["vars.scss","buttons.scss","elements.scss","inputs.scss","messages.scss","modal.scss"],"names":[],"mappings":"AAAA;AAAA;EAEE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;ACbF;EACE;EACA;EACA;;;AAGF;AAAA;EAEE;;;AAGF;EACE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EAEA;EACA;EACA;;;AAGF;EACE;;;AAGF;EACE;EACA;EACA;;;AAGF;EACE;;;AC3CF;EACE;EACA;EACA;;;AAGF;EACE;EACA;;;AAGF;EACE;;;AAGF;EACE;EACA;EACA;;;AAGF;EACE;EACA;;;AAGF;EACE;EACA;EACA;EACA;EACA;;;AAGF;EACE;EACA;EACA;EACA;;;AAGF;EACE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;AAGF;EACE;;;AAGF;EACE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;AAEA;EAME;EACA;;AANA;EACE;EACA;;AAOJ;EACE;;;AAIJ;EACE;EACA;EACA;;;ACtFF;EACE;EACA;EACA;EACA;;;AAGF;EACE;EACA;EACA;;;AAGF;EACE;EACA;;;AAGF;EACE;EACA;EACA;EACA;;;AAGF;EACE;;;AAGF;EACE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;AAIF;EACE;EACA;EACA;EACA;;;AAGF;EACE;EACA;;;AAGF;AAAA;EAEE;EACA;;;AAGF;EACE;EACA;;;AC7DF;EACE;EACA;;;AAGF;AAAA;EAEE;EACA;EACA;;;AAGF;EACE;EACA;EACA;EACA;EACA;EACA;;;AAGF;AAAA;EAEE;;;AAGF;EACE;EACA;EACA;;;AC7BF;EACE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;AAEA;EACE;EACA;EACA;EACA;;AAGF;EACE;;AAGF;EACE;EACA;EACA;EACA;EACA;;AAEA;EACE;EACA;EACA;EACA;;AAEA;EACE;;;AAMR;EACE;EACA;EACA;EACA;EACA;EACA;EACA","sourcesContent":[".deeplib-subscreen,\n.deeplib-modal {\n  --deeplib-background-color: var(--tmd-main, white);\n  --deeplib-element-color: var(--tmd-element, white);\n  --deeplib-element-hover-color: var(--tmd-element-hover, cyan);\n  --deeplib-blocked-color: var(--tmd-blocked, red);\n  --deeplib-text-color: var(--tmd-text, black);\n  --deeplib-icon-color: var(--tmd-accent, white);\n  --deeplib-icon-hover-color: var(--tmd-accent-hover, cyan);\n  --deeplib-border-color: var(--tmd-accent, black);\n  --deeplib-border-width: min(0.2vh, 0.1vw);\n  --deeplib-border-width: min(0.2dvh, 0.1dvw);\n  --deeplib-border-radius: min(1vh, 0.5vw);\n  --deeplib-border-radius: min(1dvh, 0.5dvw);\n}\n",".deeplib-button {\n  color: var(--deeplib-text-color);\n  width: 100%;\n  height: 100%;\n}\n\n.deeplib-button.button-styling,\n.deeplib-button.button-styling::before {\n  border-radius: min(1.0dvh, 0.5dvw);\n}\n\n.deeplib-button img {\n  position: absolute;\n  top: 0%;\n  left: 0%;\n  width: 100%;\n  height: 100%;\n  background-position: left;\n  background-color: var(--deeplib-icon-color);\n  background-blend-mode: multiply;\n  background-size: contain;\n  mask-position: left;\n  mask-size: contain;\n  background-repeat: no-repeat;\n  mask-repeat: no-repeat;\n  color: transparent;\n\n  background-image: var(--image);\n  mask-image: var(--image);\n  pointer-events: none;\n}\n\n.deeplib-button:hover img {\n  background-color: var(--deeplib-icon-hover-color);\n}\n\n.deeplib-button .button-label {\n  background-color: transparent !important;\n  color: var(--deeplib-text-color);\n  font-size: min(3.6dvh, 1.8dvw);\n}\n\n.deeplib-button .button-tooltip {\n  border-radius: min(1.0dvh, 0.5dvw);\n}\n","#deeplib-page-label {\n  display: flex;\n  align-items: center;\n  justify-content: center;\n}\n\n#deeplib-subscreen-title {\n  text-align: left;\n  color: var(--deeplib-text-color);\n}\n\n.deeplib-text {\n  color: var(--deeplib-text-color);\n}\n\n.deeplib-subscreen {\n  padding: 0;\n  margin: 0;\n  pointer-events: none;\n}\n\n.deeplib-subscreen * {\n  box-sizing: border-box;\n  pointer-events: all;\n}\n\n.deeplib-settings {\n  display: grid;\n  grid-auto-rows: min-content;\n  padding: min(1.0dvh, 0.5dvw);\n  gap: 0.3em;\n  overflow-y: scroll;\n}\n\n.deeplib-misc {\n  display: flex;\n  align-items: center;\n  flex-direction: column-reverse;\n  gap: min(1vh, 0.5vw);\n}\n\n.deeplib-tooltip {\n  background-color: var(--deeplib-element-color);\n  color: var(--deeplib-text-color);\n  display: flex;\n  align-items: center;\n  justify-content: center;\n  border-radius: min(1.0dvh, 0.5dvw);\n  padding: min(1vh, 0.5vw);\n  font-size: 0.8em;\n  border: min(0.2vh, 0.1vw) solid var(--deeplib-border-color);\n}\n\n.deeplib-overflow-box {\n  border: var(--deeplib-border-color) solid var(--deeplib-border-width);\n}\n\n.deeplib-prev-next {\n  display: flex;\n  align-items: center;\n  justify-content: space-between;\n  flex-direction: row;\n  gap: min(2dvh, 1dvw);\n  background-color: var(--deeplib-element-color);\n  color: var(--deeplib-text-color);\n  border-radius: min(1.0dvh, 0.5dvw);\n  border: min(0.2vh, 0.1vw) solid var(--deeplib-border-color);\n\n  .deeplib-prev-next-button {\n    &:hover {\n      background-color: var(--deeplib-element-hover-color);\n      border-radius: var(--deeplib-border-radius);\n    }\n    \n    height: 100%;\n    aspect-ratio: 1;\n  }\n\n  .deeplib-prev-next-label {\n    white-space: nowrap;\n  }\n}\n\n#deeplib-nav-menu {\n  display: flex;\n  flex-direction: row;\n  gap: min(2dvh, 1dvw);\n}",".deeplib-checkbox-container {\n  display: flex;\n  flex-direction: row;\n  align-items: center;\n  gap: 0.3em;\n}\n\n.deeplib-checkbox-container input.deeplib-input {\n  width: min(5vh, 2.5vw);\n  height: min(5vh, 2.5vw);\n  border-radius: min(1.0dvh, 0.5dvw);\n}\n\n.deeplib-checkbox-container input.deeplib-input[type=\"checkbox\"]:checked::before {\n  width: 80%;\n  height: 80%;\n}\n\n.deeplib-input-container {\n  display: flex;\n  flex-direction: row;\n  align-items: center;\n  gap: 0.3em;\n}\n\n.deeplib-input-container:has(label.deeplib-text) {\n  margin-top: min(1vh, 0.5vw);\n}\n\n.deeplib-input-container input.deeplib-input {\n  font-size: 0.6em;\n  padding: 5px 0;\n  background-color: transparent;\n  outline: none;\n  padding-left: min(1vh, 0.5vw);\n  padding-right: min(1vh, 0.5vw);\n  min-height: min(5dvh, 2.5dvw);\n  border-radius: min(1.0dvh, 0.5dvw);\n}\n\n\n.deeplib-input-container input.deeplib-input[type=\"color\"] {\n  padding: 0px;\n  width: min(5vh, 2.5vw);\n  height: min(5vh, 2.5vw);\n  border-radius: 0px;\n}\n\n.deeplib-input-container input.deeplib-input[type=\"color\"]:disabled {\n  border: var(--deeplib-blocked-color) solid var(--deeplib-border-width);\n  cursor: not-allowed;\n}\n\ninput::-webkit-outer-spin-button,\ninput::-webkit-inner-spin-button {\n  -webkit-appearance: none;\n  margin: 0;\n}\n\ninput[type=number] {\n  appearance: textfield;\n  -moz-appearance: textfield;\n}\n",".deeplib-highlight-text {\n  font-weight: bold;\n  color: rgb(203, 185, 23);\n}\n\n#TextAreaChatLog[data-colortheme='dark'] div.ChatMessage.deeplib-message,\n#TextAreaChatLog[data-colortheme='dark2'] div.ChatMessage.deeplib-message {\n  background-color: var(--deeplib-element-color);\n  border: min(0.2dvh, 0.1dvw) solid var(--deeplib-border-color);\n  color: var(--deeplib-text-color);\n}\n\n#TextAreaChatLog div.ChatMessage.deeplib-message {\n  background-color: #eee;\n  border: min(0.2dvh, 0.1dvw) solid #440171;\n  color: #111;\n  padding-left: min(0.6dvh, 0.3dvw);\n  display: block;\n  white-space: normal;\n}\n\n#TextAreaChatLog[data-colortheme='dark'] div.ChatMessage.deeplib-message a,\n#TextAreaChatLog[data-colortheme='dark2'] div.ChatMessage.deeplib-message a {\n  color: var(--deeplib-text-color);\n}\n\n#TextAreaChatLog div.ChatMessage.deeplib-message a {\n  cursor: pointer;\n  font-weight: bold;\n  color: #111;\n}\n",".deeplib-modal {\n  position: fixed;\n  top: 10%;\n  left: 50%;\n  transform: translateX(-50%);\n  z-index: 1001;\n  display: flex;\n  flex-direction: column;\n  justify-content: center;\n  align-items: center;\n  gap: 0.5em;\n  width: max(50dvw, 25dvh);\n  font-size: min(4dvh, 2dvw);\n  padding: min(2dvh, 1dvw);\n  background-color: var(--deeplib-element-color);\n  border-radius: min(1.2dvh, 0.6dvw);\n  border: min(0.2dvh, 0.1dvw) solid var(--deeplib-border-color);\n  color: var(--deeplib-text-color);\n\n  .deeplib-modal-input {\n    width: 100%;\n    font-size: min(2.6dvh, 1.8dvw);\n    border-radius: min(1.0dvh, 0.5dvw);\n    padding: min(1dvh, 0.5dvw);\n  }\n\n  input.deeplib-modal-input {\n    max-width: max(50dvh, 25dvw);\n  }\n\n  .deeplib-modal-button-container {\n    display: flex;\n    flex-direction: row;\n    justify-content: flex-end;\n    gap: 0.5em;\n    width: 100%;\n\n    .deeplib-button {\n      font-size: 0.8em;\n      display: flex;\n      width: auto;\n      padding: min(0.4vh, 0.2vw) min(2vh, 1vw);\n\n      .button-label {\n        display: contents;\n      }\n    }\n  }\n}\n\n.deeplib-modal-blocker {\n  z-index: 1000;\n  position: fixed;\n  top: 0;\n  left: 0;\n  width: 100dvw;\n  height: 100dvh;\n  background-color: rgba(0, 0, 0, 0.5);\n}\n"]} */`;
+
+// src/base/initialization.ts
+var modStorage;
+function initMod(options) {
+  const sdk = new ModSdkManager(options.modInfo.info, options.modInfo.options);
+  const MOD_NAME = ModSdkManager.ModInfo.name;
+  modStorage = new ModStorage(ModSdkManager.ModInfo.name);
+  Style.injectInline("deeplib-style", styles_default);
+  deepLibLogger.debug(`Init wait for ${MOD_NAME}`);
+  if (CurrentScreen == null || CurrentScreen === "Login") {
+    options.beforeLogin?.();
+    const removeHook = sdk.hookFunction("LoginResponse", 0, (args, next) => {
+      deepLibLogger.debug(`Init for ${MOD_NAME}! LoginResponse caught: `, args);
+      next(args);
+      const response = args[0];
+      if (response === "InvalidNamePassword") return next(args);
+      if (response && typeof response.Name === "string" && typeof response.AccountName === "string") {
+        init(options);
+        removeHook();
+      }
+    });
+  } else {
+    deepLibLogger.debug(`Already logged in, initing ${MOD_NAME}`);
+    init(options);
+  }
+  return { sdk };
+}
+__name(initMod, "initMod");
+async function init(options) {
+  const MOD_NAME = ModSdkManager.ModInfo.name;
+  const MOD_VERSION = ModSdkManager.ModInfo.version;
+  if (window[MOD_NAME + "Loaded"]) return;
+  modStorage.load();
+  if (options.pathToTranslationsFolder) {
+    await Localization.init({
+      pathToTranslationsFolder: options.pathToTranslationsFolder
+    });
+  }
+  if (options.modules && !initModules(options.modules)) {
+    unloadMod();
+    return;
+  }
+  if (options.migrators) {
+    for (const m of options.migrators) {
+      VersionModule.registerMigrator(m);
+    }
+  }
+  await options.initFunction?.();
+  if (options.mainMenuOptions)
+    MainMenu.setOptions(options.mainMenuOptions);
+  VersionModule.checkVersionUpdate();
+  for (const m of modules()) {
+    if (m.defaultSettings && hasGetter(m, "defaultSettings") && m.settings && hasSetter(m, "settings")) {
+      if (Object.entries(m.defaultSettings).length === 0) continue;
+      m.settings = deepMergeMatchingProperties(m.defaultSettings, m.settings);
+    }
+  }
+  window[MOD_NAME + "Loaded"] = true;
+  deepLibLogger.log(`Loaded ${MOD_NAME}! Version: ${MOD_VERSION}`);
+}
+__name(init, "init");
+function initModules(modulesToRegister) {
+  const MOD_NAME = ModSdkManager.ModInfo.name;
+  for (const module of modulesToRegister) {
+    registerModule(module);
+  }
+  for (const module of modules()) {
+    module.init();
+  }
+  for (const module of modules()) {
+    module.load();
+  }
+  for (const module of modules()) {
+    module.run();
+  }
+  deepLibLogger.debug(`Modules Loaded for ${MOD_NAME}.`);
+  return true;
+}
+__name(initModules, "initModules");
+function unloadMod() {
+  const MOD_NAME = ModSdkManager.ModInfo.name;
+  unloadModules();
+  delete window[MOD_NAME + "Loaded"];
+  deepLibLogger.debug(`Unloaded ${MOD_NAME}.`);
+  return true;
+}
+__name(unloadMod, "unloadMod");
+function unloadModules() {
+  for (const module of modules()) {
+    module.unload();
+  }
+}
+__name(unloadModules, "unloadModules");
+
+// src/base/modules.ts
+var modulesMap = /* @__PURE__ */ new Map();
+function modules() {
+  return [...modulesMap.values()];
+}
+__name(modules, "modules");
+function registerModule(module) {
+  modulesMap.set(module.constructor.name, module);
+  return module;
+}
+__name(registerModule, "registerModule");
+function getModule(moduleType) {
+  return modulesMap.get(moduleType);
+}
+__name(getModule, "getModule");
+
+// src/migrators/base_migrator.ts
+var BaseMigrator2 = class {
+  static {
+    __name(this, "BaseMigrator");
+  }
+};
+
+// src/modules/gui.ts
+var GUI = class _GUI extends BaseModule {
+  static {
+    __name(this, "GUI");
+  }
+  static instance = null;
+  _subscreens;
+  _mainMenu;
+  _currentSubscreen = null;
+  _modButtonOptions;
+  get subscreens() {
+    return this._subscreens;
+  }
+  get mainMenu() {
+    return this._mainMenu;
+  }
+  get currentSubscreen() {
+    return this._currentSubscreen;
+  }
+  set currentSubscreen(subscreen) {
+    if (this._currentSubscreen) {
+      this._currentSubscreen.unload();
+    }
+    if (typeof subscreen === "string") {
+      const scr = this._subscreens?.find((s) => s.name === subscreen);
+      if (!scr) throw `Failed to find screen name ${subscreen}`;
+      this._currentSubscreen = scr;
+    } else {
+      this._currentSubscreen = subscreen;
+    }
+    PreferenceMessage = "";
+    PreferencePageCurrent = 1;
+    if (this._currentSubscreen) {
+      this._currentSubscreen.load();
+      this._currentSubscreen.resize(true);
+    }
+  }
+  constructor(modButtonOptions) {
+    super();
+    if (_GUI.instance) {
+      throw new Error("Duplicate initialization");
+    }
+    for (const module of modules()) {
+      if (!module.settingsScreen) continue;
+    }
+    this._mainMenu = new MainMenu(this);
+    this._subscreens = [this._mainMenu];
+    this._modButtonOptions = modButtonOptions;
+    _GUI.instance = this;
+  }
+  get defaultSettings() {
+    return null;
+  }
+  load() {
+    for (const module of modules()) {
+      if (!module.settingsScreen) continue;
+      this._subscreens.push(new module.settingsScreen({}, module));
+    }
+    this._mainMenu.subscreens = this._subscreens;
+    PreferenceRegisterExtensionSetting({
+      Identifier: this._modButtonOptions.Identifier,
+      ButtonText: this._modButtonOptions.ButtonText,
+      Image: this._modButtonOptions.Image,
+      load: this._modButtonOptions.load || (() => {
+        setSubscreen(new MainMenu(this));
+      }),
+      run: this._modButtonOptions.run || (() => {
+        if (this._currentSubscreen) {
+          MainCanvas.textAlign = "left";
+          this._currentSubscreen.run();
+          MainCanvas.textAlign = "center";
+          const newCanvasPosition = [MainCanvas.canvas.offsetLeft, MainCanvas.canvas.offsetTop, MainCanvas.canvas.clientWidth, MainCanvas.canvas.clientHeight];
+          if (!CommonArraysEqual(newCanvasPosition, DrawCanvasPosition)) {
+            DrawCanvasPosition = newCanvasPosition;
+            this._currentSubscreen.resize(false);
+          }
+        }
+      }),
+      click: this._modButtonOptions.click || (() => {
+        if (this._currentSubscreen) {
+          this._currentSubscreen.click();
+        }
+      }),
+      exit: this._modButtonOptions.exit || (() => {
+        if (this._currentSubscreen) {
+          this._currentSubscreen.exit();
+        }
+      }),
+      unload: this._modButtonOptions.unload || (() => {
+        if (this._currentSubscreen) {
+          this._currentSubscreen.unload();
+        }
+      })
+    });
+  }
+};
+
+// src/modules/version.ts
+var VersionModule = class _VersionModule extends BaseModule {
+  static {
+    __name(this, "VersionModule");
+  }
+  static isItNewVersion = false;
+  static Version;
+  static NewVersionMessage = "";
+  static Migrators = [];
+  load() {
+    _VersionModule.Version = ModSdkManager.ModInfo.version;
+    ModSdkManager.prototype.hookFunction(
+      "ChatRoomSync",
+      HookPriority.Observe,
+      (args, next) => {
+        next(args);
+        if (modStorage.playerStorage.GlobalModule.doShowNewVersionMessage && _VersionModule.isItNewVersion) {
+          _VersionModule.sendNewVersionMessage();
+        }
+      },
+      "VersionModule"
+    );
+  }
+  static checkVersionUpdate() {
+    const PreviousVersion = _VersionModule.loadVersion();
+    const CurrentVersion = _VersionModule.Version;
+    if (_VersionModule.isNewVersion(PreviousVersion, CurrentVersion)) {
+      _VersionModule.isItNewVersion = true;
+      _VersionModule.checkVersionMigration();
+      _VersionModule.saveVersion();
+    }
+    modStorage.save();
+  }
+  static checkVersionMigration() {
+    const PreviousVersion = _VersionModule.loadVersion();
+    for (const migrator of _VersionModule.Migrators) {
+      if (_VersionModule.isNewVersion(PreviousVersion, migrator.MigrationVersion)) {
+        migrator.Migrate();
+        deepLibLogger.info(`Migrating ${ModSdkManager.ModInfo.name} from ${PreviousVersion} to ${migrator.MigrationVersion} with ${migrator.constructor.name}`);
+      }
+    }
+  }
+  static registerMigrator(migrator) {
+    _VersionModule.Migrators.push(migrator);
+    _VersionModule.Migrators.sort((a, b) => a.MigrationVersion.localeCompare(b.MigrationVersion));
+  }
+  static setNewVersionMessage(newVersionMessage) {
+    _VersionModule.NewVersionMessage = newVersionMessage;
+  }
+  static sendNewVersionMessage() {
+    sendLocalMessage("deeplib-new-version", _VersionModule.NewVersionMessage);
+  }
+  static isNewVersion(current, candidate) {
+    if (current !== void 0) {
+      const CURRENT_ = current.split("."), CANDIDATE_ = candidate.split(".");
+      for (let i = 0; i < 3; i++) {
+        if (CURRENT_[i] === CANDIDATE_[i]) {
+          continue;
+        }
+        return CANDIDATE_[i] > CURRENT_[i];
+      }
+    }
+    if (current === void 0 || current === "" || !current) {
+      return true;
+    }
+    return false;
+  }
+  static saveVersion() {
+    if (modStorage.playerStorage) {
+      Player[ModSdkManager.ModInfo.name].Version = _VersionModule.Version;
+    }
+  }
+  static loadVersion() {
+    return modStorage.playerStorage?.Version;
+  }
+};
+
+// src/screens/debug.ts
+var GuiDebug = class extends BaseSubscreen {
+  static {
+    __name(this, "GuiDebug");
+  }
+  get name() {
+    return "debug";
+  }
+  get pageStructure() {
+    return [
+      [
+        {
+          type: "button",
+          id: "test-deeplib-big-button",
+          size: [405, 80],
+          label: "Big Button",
+          tooltip: "This is a big button",
+          image: "Icons/Exit.png",
+          onClick() {
+            deepLibLogger.info("Big Button Clicked");
+          }
+        },
+        {
+          type: "button",
+          id: "test-deeplib-small-button",
+          size: [90, 90],
+          tooltip: "This is a small button",
+          image: "Icons/Exit.png",
+          onClick() {
+            deepLibLogger.info("Small Button Clicked");
+          }
+        },
+        {
+          type: "checkbox",
+          id: "test-deeplib-checkbox",
+          label: "Checkbox",
+          description: "This is a checkbox",
+          setElementValue() {
+            return true;
+          },
+          setSettingValue(val) {
+            deepLibLogger.info("Checkbox value:", val);
+          }
+        },
+        {
+          type: "text",
+          id: "test-deeplib-text-input",
+          label: "Input",
+          description: "This is a text input",
+          setElementValue() {
+            return "Input Value";
+          },
+          setSettingValue(val) {
+            deepLibLogger.info("Input value:", val);
+          }
+        },
+        {
+          type: "number",
+          id: "test-deeplib-number-input",
+          label: "Input",
+          description: "This is a number input",
+          setElementValue() {
+            return "123";
+          },
+          setSettingValue(val) {
+            deepLibLogger.info("Input value:", val);
+          }
+        },
+        {
+          type: "label",
+          id: "test-deeplib-label",
+          label: "Label",
+          description: "This is a label"
+        }
+      ],
+      [
+        {
+          type: "button",
+          id: "test-deeplib-big-button2",
+          size: [405, 80],
+          label: "Big Button",
+          tooltip: "This is a big button",
+          image: "Icons/Prev.png",
+          onClick() {
+            deepLibLogger.info("Big Button Clicked");
+          }
+        },
+        {
+          type: "button",
+          id: "test-deeplib-small-button2",
+          size: [90, 90],
+          tooltip: "This is a small button",
+          image: "Icons/Next.png",
+          onClick() {
+            deepLibLogger.info("Small Button Clicked");
+          }
+        },
+        {
+          type: "checkbox",
+          id: "test-deeplib-checkbox2",
+          label: "Checkbox",
+          description: "This is a checkbox",
+          setElementValue() {
+            return true;
+          },
+          setSettingValue(val) {
+            deepLibLogger.info("Checkbox value:", val);
+          }
+        },
+        {
+          type: "text",
+          id: "test-deeplib-text-input2",
+          label: "Input",
+          description: "This is a text input",
+          setElementValue() {
+            return "Input Value";
+          },
+          setSettingValue(val) {
+            deepLibLogger.info("Input value:", val);
+          }
+        },
+        {
+          type: "number",
+          id: "test-deeplib-number-input2",
+          label: "Input",
+          description: "This is a number input",
+          setElementValue() {
+            return "123";
+          },
+          setSettingValue(val) {
+            deepLibLogger.info("Input value:", val);
+          }
+        },
+        {
+          type: "label",
+          id: "test-deeplib-label2",
+          label: "Label",
+          description: "This is a label"
+        }
+      ]
+    ];
+  }
+};
+
+// src/utilities/common.ts
+function deepMerge(target, source) {
+  if (target === void 0) return source;
+  if (source === void 0) return target;
+  if (typeof target !== "object" || typeof source !== "object") {
+    return source;
+  }
+  for (const key of Object.keys(source)) {
+    if (Array.isArray(source[key]) && Array.isArray(target[key])) {
+      target[key] = [...target[key], ...source[key]];
+    } else if (typeof source[key] === "object" && source[key] !== null) {
+      target[key] = deepMerge(target[key] || {}, source[key]);
+    } else {
+      target[key] = source[key];
+    }
+  }
+  return target;
+}
+__name(deepMerge, "deepMerge");
+function shuffleArray(array) {
+  const temp = JSON.parse(JSON.stringify(array));
+  const ret = [];
+  while (temp.length > 0) {
+    const d = Math.floor(Math.random() * temp.length);
+    ret.push(temp[d]);
+    temp.splice(d, 1);
+  }
+  return ret;
+}
+__name(shuffleArray, "shuffleArray");
+function exportToGlobal(name, value) {
+  const keys = name.split(".");
+  let current = globalThis;
+  for (let i = 0; i < keys.length - 1; i++) {
+    if (!current[keys[i]]) {
+      current[keys[i]] = {};
+    }
+    current = current[keys[i]];
+  }
+  current[keys[keys.length - 1]] = value;
+}
+__name(exportToGlobal, "exportToGlobal");
+function deepMergeMatchingProperties(mergeTo, mergeFrom) {
+  const mergedObject = { ...mergeTo };
+  for (const key in mergeFrom) {
+    if (mergeFrom[key] !== null && typeof mergeFrom[key] === "object") {
+      mergedObject[key] = deepMergeMatchingProperties(mergedObject[key] || {}, mergeFrom[key]);
+    } else if (key in mergedObject) {
+      mergedObject[key] = mergeFrom[key];
+    }
+  }
+  return mergedObject;
+}
+__name(deepMergeMatchingProperties, "deepMergeMatchingProperties");
+function hasGetter(obj, prop) {
+  while (obj && obj !== Object.prototype) {
+    const descriptor = Object.getOwnPropertyDescriptor(obj, prop);
+    if (descriptor?.get) return true;
+    obj = Object.getPrototypeOf(obj);
+  }
+  return false;
+}
+__name(hasGetter, "hasGetter");
+function hasSetter(obj, prop) {
+  while (obj && obj !== Object.prototype) {
+    const descriptor = Object.getOwnPropertyDescriptor(obj, prop);
+    if (descriptor?.set) return true;
+    obj = Object.getPrototypeOf(obj);
+  }
+  return false;
+}
+__name(hasSetter, "hasSetter");
+
+// src/utilities/elements/advanced_elements.ts
+var advancedElement = {
+  createButton: elementCreateButton,
+  createCheckbox: elementCreateCheckbox,
+  createInput: elementCreateInput,
+  createLabel: elementCreateLabel,
+  createCustom: elementCreateCustom,
+  createTooltip: elementCreateTooltip,
+  getTooltip: elementGetTooltip,
+  setTooltip: elementSetTooltip,
+  createBackNext: elementPrevNext
+};
+function elementCreateButton(options) {
+  const elem = document.getElementById(options.id);
+  if (elem) return elem;
+  options.type = "button";
+  const disabled = typeof options?.disabled === "function" ? options?.disabled() : options?.disabled;
+  const button = ElementButton.Create(
+    options.htmlOptions?.id ?? options.id,
+    options.htmlOptions?.onClick ?? options?.onClick ?? (() => {
+    }),
+    deepMerge({
+      tooltip: options.tooltip,
+      label: options.label,
+      labelPosition: "center"
+    }, options.htmlOptions?.options),
+    deepMerge({
+      button: {
+        classList: ["deeplib-button"],
+        attributes: {
+          disabled
+        },
+        children: [
+          options.image ? {
+            tag: "img",
+            attributes: {
+              id: `${options.id}-image`,
+              alt: "",
+              decoding: "async",
+              loading: "lazy",
+              src: "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7"
+              // 1x1 transparent image to get rid of broken image
+            },
+            style: {
+              "--image": `url("${options.image}")`
+            }
+          } : void 0
+        ]
+      }
+    }, options.htmlOptions?.htmlOptions ?? {})
+  );
+  BaseSubscreen.currentElements.push([button, options]);
+  return button;
+}
+__name(elementCreateButton, "elementCreateButton");
+function elementCreateCheckbox(options) {
+  const elem = document.getElementById(options.id);
+  if (elem) return elem;
+  options.type = "checkbox";
+  const disabled = typeof options?.disabled === "function" ? options?.disabled() : options?.disabled;
+  const retElem = ElementCreate({
+    tag: "div",
+    classList: ["deeplib-checkbox-container"],
+    attributes: {
+      id: `${options.id}-container`
+    },
+    children: [
+      deepMerge({
+        tag: "input",
+        classList: ["checkbox", "deeplib-input"],
+        attributes: {
+          type: "checkbox",
+          id: options.id,
+          disabled,
+          checked: options?.setElementValue?.() || void 0
+        }
+      }, options.htmlOptions),
+      {
+        tag: "label",
+        classList: ["deeplib-text"],
+        attributes: {
+          for: options.id
+        },
+        children: [options.label]
+      }
+    ],
+    eventListeners: {
+      change: /* @__PURE__ */ __name(() => {
+        options?.setSettingValue?.(document.getElementById(options.id)?.checked);
+      }, "change")
+    }
+  });
+  if (options.description) {
+    retElem.addEventListener("mouseover", () => {
+      elementSetTooltip(options.description || "");
+    });
+    retElem.addEventListener("mouseout", () => {
+      elementSetTooltip("");
+    });
+  }
+  BaseSubscreen.currentElements.push([retElem, options]);
+  return retElem;
+}
+__name(elementCreateCheckbox, "elementCreateCheckbox");
+function elementCreateCustom(options) {
+  const elem = document.getElementById(options.id);
+  if (elem) return elem;
+  options.type = "custom";
+  const retElem = ElementCreate(options.htmlOptions);
+  BaseSubscreen.currentElements.push([retElem, options]);
+  return retElem;
+}
+__name(elementCreateCustom, "elementCreateCustom");
+function elementCreateInput(options) {
+  const elem = document.getElementById(options.id);
+  if (elem) return elem;
+  const disabled = typeof options?.disabled === "function" ? options?.disabled() : options?.disabled;
+  const retElem = ElementCreate({
+    tag: "div",
+    classList: ["deeplib-input-container"],
+    attributes: {
+      id: `${options.id}-container`
+    },
+    children: [
+      deepMerge({
+        tag: "input",
+        classList: ["deeplib-input"],
+        attributes: {
+          type: options.type,
+          id: options.id,
+          placeholder: " ",
+          disabled,
+          value: options?.setElementValue?.() || void 0
+        }
+      }, options.htmlOptions),
+      options.label ? {
+        tag: "label",
+        classList: ["deeplib-text"],
+        attributes: {
+          for: options.id
+        },
+        children: [options.label]
+      } : void 0
+    ],
+    eventListeners: {
+      input: /* @__PURE__ */ __name(() => {
+        options?.setSettingValue?.(document.getElementById(options.id)?.value);
+      }, "input")
+    }
+  });
+  if (options.description) {
+    retElem.addEventListener("mouseover", () => {
+      elementSetTooltip(options.description || "");
+    });
+    retElem.addEventListener("mouseout", () => {
+      elementSetTooltip("");
+    });
+  }
+  BaseSubscreen.currentElements.push([retElem, options]);
+  return retElem;
+}
+__name(elementCreateInput, "elementCreateInput");
+function elementCreateLabel(options) {
+  const elem = document.getElementById(options.id);
+  if (elem) return elem;
+  options.type = "label";
+  const retElem = ElementCreate(deepMerge({
+    tag: "span",
+    classList: ["deeplib-label", "deeplib-text"],
+    attributes: {
+      id: options.id
+    },
+    children: [
+      options.label
+    ]
+  }, options.htmlOptions));
+  if (options.description) {
+    retElem.addEventListener("mouseover", () => {
+      elementSetTooltip(options.description || "");
+    });
+    retElem.addEventListener("mouseout", () => {
+      elementSetTooltip("");
+    });
+  }
+  BaseSubscreen.currentElements.push([retElem, options]);
+  return retElem;
+}
+__name(elementCreateLabel, "elementCreateLabel");
+function elementCreateTooltip() {
+  const element = ElementCreate({
+    tag: "div",
+    classList: ["deeplib-tooltip"],
+    attributes: {
+      id: "deeplib-tooltip"
+    },
+    style: {
+      display: "none"
+    }
+  });
+  return element;
+}
+__name(elementCreateTooltip, "elementCreateTooltip");
+function elementGetTooltip() {
+  return document.getElementById("deeplib-tooltip") ?? void 0;
+}
+__name(elementGetTooltip, "elementGetTooltip");
+function elementSetTooltip(text) {
+  const element = document.getElementById("deeplib-tooltip");
+  if (!element) return false;
+  element.innerHTML = text;
+  if (text === "") element.style.display = "none";
+  else element.style.display = "";
+  return true;
+}
+__name(elementSetTooltip, "elementSetTooltip");
+function elementPrevNext(options) {
+  const elem = document.getElementById(options.id);
+  if (elem) return elem;
+  const setLabel = /* @__PURE__ */ __name((label) => {
+    const elem2 = document.getElementById(`${options.id}-label`);
+    if (!elem2) return false;
+    elem2.textContent = label;
+  }, "setLabel");
+  const setPrevTooltip = /* @__PURE__ */ __name((tooltip) => {
+    const elem2 = document.getElementById(`deeplib-prev-next-${options.id}-prev-button-tooltip`);
+    if (!elem2) return false;
+    elem2.textContent = tooltip;
+  }, "setPrevTooltip");
+  const setNextTooltip = /* @__PURE__ */ __name((tooltip) => {
+    const elem2 = document.getElementById(`deeplib-prev-next-${options.id}-next-button-tooltip`);
+    if (!elem2) return false;
+    elem2.textContent = tooltip;
+  }, "setNextTooltip");
+  const retElem = ElementCreate({
+    tag: "div",
+    classList: ["deeplib-prev-next"],
+    attributes: {
+      id: options.id
+    },
+    children: [
+      advancedElement.createButton({
+        id: `deeplib-prev-next-${options.id}-prev-button`,
+        image: `${PUBLIC_URL}/dl_images/arrow_left.svg`,
+        onClick: /* @__PURE__ */ __name(() => {
+          options.back({
+            setLabel,
+            setBackTooltip: setPrevTooltip,
+            setNextTooltip
+          });
+        }, "onClick"),
+        tooltip: options.initialPrevTooltip,
+        htmlOptions: {
+          htmlOptions: {
+            button: {
+              classList: ["deeplib-prev-next-button"]
+            }
+          },
+          options: {
+            noStyling: true
+          }
+        }
+      }),
+      advancedElement.createLabel({
+        id: `${options.id}-label`,
+        label: options.initialLabel,
+        htmlOptions: {
+          classList: ["deeplib-prev-next-label"]
+        }
+      }),
+      advancedElement.createButton({
+        id: `deeplib-prev-next-${options.id}-next-button`,
+        image: `${PUBLIC_URL}/dl_images/arrow_right.svg`,
+        onClick: /* @__PURE__ */ __name(() => {
+          options.next({
+            setLabel,
+            setBackTooltip: setPrevTooltip,
+            setNextTooltip
+          });
+        }, "onClick"),
+        tooltip: options.initialNextTooltip,
+        htmlOptions: {
+          htmlOptions: {
+            button: {
+              classList: ["deeplib-prev-next-button"]
+            }
+          },
+          options: {
+            noStyling: true
+          }
+        }
+      })
+    ]
+  });
+  return retElem;
+}
+__name(elementPrevNext, "elementPrevNext");
+var Modal = class _Modal {
+  constructor(opts) {
+    this.opts = opts;
+    opts ??= {};
+    opts.closeOnBackdrop ??= true;
+    const promptId = `modal-prompt-${Date.now()}`;
+    this.dialog = ElementCreate({
+      tag: "dialog",
+      classList: ["deeplib-modal"],
+      attributes: {
+        role: "dialog",
+        "aria-modal": "true",
+        "aria-labelledby": promptId
+      },
+      style: {
+        fontFamily: CommonGetFontName()
+      },
+      children: [
+        opts.prompt,
+        {
+          tag: "div",
+          classList: ["deeplib-modal-prompt"],
+          attributes: {
+            id: promptId
+          },
+          children: [
+            opts.input ? this.renderInput(opts.input) : void 0
+          ]
+        },
+        this.renderButtons()
+      ]
+    });
+    this.blocker = this.createBlocker();
+    this.renderButtons();
+    document.body.append(this.createBlocker(), this.dialog);
+    this.setupFocusTrap();
+    if (opts.timeoutMs) {
+      this.timeoutId = window.setTimeout(() => this.close("timeout"), opts.timeoutMs);
+    }
+  }
+  static {
+    __name(this, "Modal");
+  }
+  dialog;
+  blocker;
+  inputEl;
+  timeoutId;
+  static queue = [];
+  static processing = false;
+  show() {
+    return _Modal.enqueue(this);
+  }
+  static async alert(msg, timeoutMs) {
+    await new _Modal({ prompt: msg, buttons: [{ action: "close", text: "OK" }], timeoutMs }).show();
+  }
+  static async confirm(msg) {
+    const [action] = await new _Modal({ prompt: msg, buttons: [{ text: "Cancel", action: "cancel" }, { text: "OK", action: "ok" }] }).show();
+    return action === "ok";
+  }
+  static async prompt(msg, defaultValue = "") {
+    const [action, value] = await new _Modal({ prompt: msg, timeoutMs: 0, input: { type: "input", defaultValue }, buttons: [{ text: "Cancel", action: "cancel" }, { text: "Submit", action: "submit" }] }).show();
+    return action === "submit" ? value : null;
+  }
+  renderInput(cfg) {
+    const el = document.createElement(cfg.type);
+    el.classList.add("deeplib-modal-input");
+    if (cfg.placeholder) el.placeholder = cfg.placeholder;
+    if (cfg.readOnly) el.readOnly = true;
+    if (cfg.defaultValue) el.value = cfg.defaultValue;
+    if (cfg.type === "textarea") el.rows = 5;
+    el.addEventListener("input", () => {
+      const err = cfg.validate?.(el.value);
+      el.setCustomValidity(err || "");
+    });
+    this.inputEl = el;
+    return el;
+  }
+  renderButtons() {
+    const container = document.createElement("div");
+    container.classList.add("deeplib-modal-button-container");
+    const btns = this.opts.buttons ? [...this.opts.buttons] : [];
+    btns.forEach((b) => {
+      const btn = advancedElement.createButton({
+        label: b.text,
+        id: `deeplib-modal-${b.action}`,
+        disabled: b.disabled,
+        onClick: /* @__PURE__ */ __name(() => this.close(b.action), "onClick")
+      });
+      container.append(btn);
+    });
+    return container;
+  }
+  createBlocker() {
+    const blocker = document.createElement("div");
+    blocker.classList.add("deeplib-modal-blocker");
+    blocker.title = "Click to close";
+    if (this.opts.closeOnBackdrop !== false)
+      blocker.addEventListener("click", () => this.close("close"));
+    return blocker;
+  }
+  setupFocusTrap() {
+    const focusable = 'button, [href], input, textarea, select, [tabindex]:not([tabindex="-1"])';
+    const elements = Array.from(this.dialog.querySelectorAll(focusable));
+    const first = elements[0];
+    const last = elements[elements.length - 1];
+    this.dialog.addEventListener("keydown", (e) => {
+      if (e.key === "Tab") {
+        if (elements.length === 0) {
+          e.preventDefault();
+          return;
+        }
+        if (e.shiftKey) {
+          if (document.activeElement === first) {
+            last.focus();
+            e.preventDefault();
+          }
+        } else {
+          if (document.activeElement === last) {
+            first.focus();
+            e.preventDefault();
+          }
+        }
+      } else if (e.key === "Escape") {
+        e.stopPropagation();
+        this.close("close");
+      }
+    });
+    window.requestAnimationFrame(() => {
+      (this.inputEl || first)?.focus();
+    });
+  }
+  close(action) {
+    if (this.timeoutId) clearTimeout(this.timeoutId);
+    this.dialog.close();
+    this.dialog.remove();
+    this.blocker.remove();
+    document.body.querySelector(".deeplib-modal-blocker")?.remove();
+    const value = this.inputEl?.value ?? "";
+    this.resolve([action, value]);
+    _Modal.dequeue();
+  }
+  /**
+   * An internal function where we will save promise function.
+   */
+  resolve = /* @__PURE__ */ __name(() => {
+  }, "resolve");
+  /** A function that adds a modal to the queue and returns a promise */
+  static enqueue(modal) {
+    _Modal.queue.push(modal);
+    if (!_Modal.processing) _Modal.dequeue();
+    return new Promise((resolve) => modal.resolve = resolve);
+  }
+  /** A function that processes the queue, removing the first modal */
+  static dequeue() {
+    const modal = _Modal.queue.shift();
+    if (modal) {
+      _Modal.processing = true;
+      modal.dialog.show();
+    } else {
+      _Modal.processing = false;
+    }
+  }
+};
+window.Modal = Modal;
+
+// src/screens/main_menu.ts
+var MainMenu = class _MainMenu extends BaseSubscreen {
+  static {
+    __name(this, "MainMenu");
+  }
+  subscreens = [];
+  static options = {};
+  get name() {
+    return "mainmenu";
+  }
+  constructor(module) {
+    super({ drawCharacter: true }, module);
+    this.subscreens = module.subscreens;
+  }
+  load() {
+    if (!GUI.instance?.currentSubscreen) {
+      this.setSubscreen(this);
+      return;
+    }
+    super.load();
+    const exitButton = advancedElement.createButton({
+      id: "exit",
+      size: [90, 90],
+      image: `${PUBLIC_URL}/dl_images/exit.svg`,
+      onClick: /* @__PURE__ */ __name(() => {
+        this.exit();
+      }, "onClick"),
+      tooltip: getText("settings.button.back_button_hint")
+    });
+    const menu = document.getElementById("deeplib-nav-menu");
+    if (menu) {
+      ElementMenu.AppendButton(menu, exitButton);
+    }
+    for (const screen of this.subscreens) {
+      if (screen.name == "mainmenu") continue;
+      const button = advancedElement.createButton({
+        id: `${screen.name}-button`,
+        image: screen.icon,
+        label: getText(`mainmenu.button.${screen.name}`),
+        onClick: /* @__PURE__ */ __name(() => {
+          this.setSubscreen(screen);
+        }, "onClick"),
+        size: [null, 90]
+      });
+      layoutElement.appendToSettingsDiv(button);
+    }
+    const miscDiv = layoutElement.createMiscDiv();
+    layoutElement.appendToSubscreenDiv(miscDiv);
+    if (_MainMenu.options.wikiLink) {
+      const wikiButton = advancedElement.createButton({
+        id: "deeplib-wiki-button",
+        image: `${PUBLIC_URL}/dl_images/notebook.svg`,
+        label: getText("mainmenu.button.wiki"),
+        onClick: /* @__PURE__ */ __name(() => {
+          window.open(_MainMenu.options.wikiLink, "_blank");
+        }, "onClick"),
+        size: [null, 80]
+      });
+      layoutElement.appendToMiscDiv(wikiButton);
+    }
+    if (_MainMenu.options.repoLink) {
+      const repoButton = advancedElement.createButton({
+        id: "deeplib-repo-button",
+        image: `${PUBLIC_URL}/dl_images/git.svg`,
+        label: getText("mainmenu.button.repo"),
+        onClick: /* @__PURE__ */ __name(() => {
+          window.open(_MainMenu.options.repoLink, "_blank");
+        }, "onClick"),
+        size: [null, 80]
+      });
+      layoutElement.appendToMiscDiv(repoButton);
+    }
+    if (_MainMenu.options.resetSubscreen) {
+      const resetButton = advancedElement.createButton({
+        id: "deeplib-reset-button",
+        image: `${PUBLIC_URL}/dl_images/trash_bin.svg`,
+        label: getText("mainmenu.button.reset"),
+        onClick: /* @__PURE__ */ __name(() => {
+          this.setSubscreen(_MainMenu.options.resetSubscreen);
+        }, "onClick"),
+        size: [null, 80]
+      });
+      layoutElement.appendToMiscDiv(resetButton);
+    }
+    if (_MainMenu.options.importExportSubscreen) {
+      const importExportButton = advancedElement.createButton({
+        id: "deeplib-import-export-button",
+        image: `${PUBLIC_URL}/dl_images/transfer.svg`,
+        label: getText("mainmenu.button.import_export"),
+        onClick: /* @__PURE__ */ __name(() => {
+          this.setSubscreen(_MainMenu.options.importExportSubscreen);
+        }, "onClick"),
+        size: [null, 80]
+      });
+      layoutElement.appendToMiscDiv(importExportButton);
+    }
+    if (IS_DEBUG) {
+      const debugButton = advancedElement.createButton({
+        id: "deeplib-debug-button",
+        image: `${PUBLIC_URL}/dl_images/bug.svg`,
+        onClick: /* @__PURE__ */ __name(() => {
+          this.setSubscreen(new GuiDebug());
+        }, "onClick"),
+        size: [90, 90]
+      });
+      if (menu) {
+        ElementMenu.PrependItem(menu, debugButton);
+      }
+    }
+  }
+  run() {
+    super.run();
+  }
+  click() {
+  }
+  exit() {
+    CharacterAppearanceForceUpCharacter = -1;
+    CharacterLoadCanvas(Player);
+    this.setSubscreen(null);
+    PreferenceSubscreenExtensionsClear();
+  }
+  resize() {
+    super.resize();
+    ElementSetPosition("deeplib-misc", 1905, 930, "bottom-right");
+    ElementSetSize("deeplib-misc", 405, null);
+  }
+  static setOptions(mainMenuOptions) {
+    _MainMenu.options = mainMenuOptions;
+  }
+};
+
+// src/screens/import_export.ts
+var GuiImportExport = class extends BaseSubscreen {
+  static {
+    __name(this, "GuiImportExport");
+  }
+  importExportOptions;
+  get name() {
+    return "import-export";
+  }
+  constructor(importExportOptions) {
+    super({ drawCharacter: true });
+    this.importExportOptions = importExportOptions;
+  }
+  load() {
+    super.load();
+    const importFromFileButton = advancedElement.createButton({
+      id: "deeplib-import-file-button",
+      size: [600, 90],
+      image: `${PUBLIC_URL}/dl_images/file_import.svg`,
+      onClick: /* @__PURE__ */ __name(() => {
+        this.dataImport("file");
+      }, "onClick"),
+      label: getText("import-export.button.import_file")
+    });
+    layoutElement.appendToSettingsDiv(importFromFileButton);
+    const exportToFileButton = advancedElement.createButton({
+      id: "deeplib-export-file-button",
+      size: [600, 90],
+      image: `${PUBLIC_URL}/dl_images/file_export.svg`,
+      onClick: /* @__PURE__ */ __name(() => {
+        this.dataExport("file");
+      }, "onClick"),
+      label: getText("import-export.button.export_file")
+    });
+    layoutElement.appendToSettingsDiv(exportToFileButton);
+    const importFromClipboardButton = advancedElement.createButton({
+      id: "deeplib-import-clipboard-button",
+      size: [600, 90],
+      image: `${PUBLIC_URL}/dl_images/clipboard_import.svg`,
+      onClick: /* @__PURE__ */ __name(() => {
+        this.dataImport("clipboard");
+      }, "onClick"),
+      label: getText("import-export.button.import_clipboard")
+    });
+    layoutElement.appendToSettingsDiv(importFromClipboardButton);
+    const exportToClipboardButton = advancedElement.createButton({
+      id: "deeplib-export-clipboard-button",
+      size: [600, 90],
+      image: `${PUBLIC_URL}/dl_images/clipboard_export.svg`,
+      onClick: /* @__PURE__ */ __name(() => {
+        this.dataExport("clipboard");
+      }, "onClick"),
+      label: getText("import-export.button.export_clipboard")
+    });
+    layoutElement.appendToSettingsDiv(exportToClipboardButton);
+  }
+  resize() {
+    super.resize();
+  }
+  async dataExport(transferMethod) {
+    try {
+      const data = LZString.compressToBase64(JSON.stringify(modStorage.playerStorage));
+      if (transferMethod === "clipboard") {
+        await this.exportToClipboard(data);
+      } else if (transferMethod === "file") {
+        await this.exportToFile(data, "themed_settings");
+      }
+      this.importExportOptions.onExport?.();
+      ToastManager.success("Data exported successfully.");
+    } catch (error) {
+      ToastManager.error("Data export failed.");
+      deepLibLogger.error(`Data export failed for ${ModSdkManager.ModInfo.name}.`, error);
+    }
+  }
+  async dataImport(transferMethod) {
+    try {
+      let importedData = "";
+      if (transferMethod === "clipboard") {
+        importedData = await this.importFromClipboard() ?? null;
+      } else if (transferMethod === "file") {
+        importedData = await this.importFromFile() ?? null;
+      }
+      if (!importedData) {
+        throw new Error("No data imported.");
+      }
+      const data = JSON.parse(LZString.decompressFromBase64(importedData) ?? "");
+      if (!data) {
+        throw new Error("Invalid data.");
+      }
+      modStorage.playerStorage = data;
+      this.importExportOptions.onImport?.();
+      ToastManager.success("Data imported successfully.");
+    } catch (error) {
+      ToastManager.error("Data import failed.");
+      deepLibLogger.error(`Data import failed for ${ModSdkManager.ModInfo.name}.`, error);
+    }
+  }
+  async exportToFile(data, defaultFileName) {
+    const CUSTOM_EXTENSION = this.importExportOptions.customFileExtension.startsWith(".") ? this.importExportOptions.customFileExtension : "." + this.importExportOptions.customFileExtension;
+    const suggestedName = defaultFileName.endsWith(CUSTOM_EXTENSION) ? defaultFileName : defaultFileName + CUSTOM_EXTENSION;
+    if ("showSaveFilePicker" in window) {
+      try {
+        const handle = await window.showSaveFilePicker({
+          suggestedName,
+          types: [
+            {
+              description: "Custom Data Files",
+              accept: { "text/plain": [CUSTOM_EXTENSION] }
+            }
+          ]
+        });
+        const writable = await handle.createWritable();
+        await writable.write(data);
+        await writable.close();
+      } catch (error) {
+        throw new Error("File save cancelled or failed: " + error.message);
+      }
+    } else {
+      const fileName = await Modal.prompt("Enter file name", suggestedName);
+      if (fileName === null) {
+        return;
+      } else if (fileName === "") {
+        throw new Error("File name cannot be empty.");
+      }
+      const blob = new Blob([data], { type: "text/plain" });
+      const link = ElementCreate({
+        tag: "a",
+        attributes: {
+          href: URL.createObjectURL(blob),
+          download: fileName.endsWith(CUSTOM_EXTENSION) ? fileName : fileName + CUSTOM_EXTENSION
+        }
+      });
+      link.click();
+      URL.revokeObjectURL(link.href);
+    }
+  }
+  async importFromFile() {
+    const CUSTOM_EXTENSION = this.importExportOptions.customFileExtension.startsWith(".") ? this.importExportOptions.customFileExtension : "." + this.importExportOptions.customFileExtension;
+    async function importFromFileInternal(file) {
+      if (!file.name.endsWith(CUSTOM_EXTENSION)) {
+        throw new Error(`Invalid file type. Expected a ${CUSTOM_EXTENSION} file.`);
+      }
+      return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = () => resolve(reader.result);
+        reader.onerror = () => reject(new Error("Failed to read file."));
+        reader.readAsText(file);
+      });
+    }
+    __name(importFromFileInternal, "importFromFileInternal");
+    if ("showOpenFilePicker" in window) {
+      try {
+        const [fileHandle] = await window.showOpenFilePicker({
+          types: [
+            {
+              description: "Custom Data Files",
+              accept: { "text/plain": [CUSTOM_EXTENSION] }
+            }
+          ],
+          multiple: false
+        });
+        const file = await fileHandle.getFile();
+        return await importFromFileInternal(file);
+      } catch (error) {
+        throw new Error("File selection cancelled or failed: " + error.message);
+      }
+    } else {
+      return new Promise((resolve, reject) => {
+        const input = document.createElement("input");
+        input.type = "file";
+        input.accept = CUSTOM_EXTENSION;
+        input.onchange = async (event) => {
+          const file = event.target.files?.[0];
+          if (file) {
+            try {
+              const data = await importFromFileInternal(file);
+              resolve(data);
+            } catch (error) {
+              reject(error);
+            }
+          } else {
+            reject(new Error("No file selected."));
+          }
+        };
+        input.click();
+      });
+    }
+  }
+  async exportToClipboard(data) {
+    return navigator.clipboard.writeText(data).catch((error) => {
+      throw new Error("Failed to copy data to clipboard." + error);
+    });
+  }
+  async importFromClipboard() {
+    return Modal.prompt("Enter data to import").catch((error) => {
+      throw new Error("Failed to read data from clipboard." + error);
+    });
+  }
+};
+
+// src/utilities/data.ts
+var ModStorage = class _ModStorage {
+  static {
+    __name(this, "ModStorage");
+  }
+  static _instance = null;
+  modName;
+  constructor(modName) {
+    if (!_ModStorage._instance) {
+      _ModStorage._instance = this;
+      this.modName = modName;
+    }
+    this.modName ??= modName;
+    return _ModStorage._instance;
+  }
+  get playerStorage() {
+    return Player[this.modName];
+  }
+  set playerStorage(value) {
+    Player[this.modName] = value;
+  }
+  get extensionStorage() {
+    return Player.ExtensionSettings[this.modName];
+  }
+  set extensionStorage(value) {
+    Player.ExtensionSettings[this.modName] = value;
+  }
+  setLocalStorage(key, value) {
+    localStorage.setItem(`${this.modName}_${key}`, _ModStorage.dataCompress(value));
+  }
+  getLocalStorage(key) {
+    const data = localStorage.getItem(`${this.modName}_${key}`);
+    if (!data) return null;
+    return _ModStorage.dataDecompress(data);
+  }
+  load() {
+    if (this.extensionStorage) {
+      const parsed = _ModStorage.dataDecompress(this.extensionStorage || "");
+      if (parsed === null || !Object.hasOwn(parsed, "Version")) {
+        this.playerStorage = {};
+      } else {
+        this.playerStorage = parsed;
+      }
+      ;
+    } else {
+      this.playerStorage = {};
+    }
+  }
+  save() {
+    if (!this.extensionStorage) this.extensionStorage = "";
+    this.extensionStorage = _ModStorage.dataCompress(this.playerStorage);
+    ServerPlayerExtensionSettingsSync(this.modName);
+  }
+  static dataDecompress(string) {
+    const d = LZString.decompressFromBase64(string);
+    let data = null;
+    try {
+      const decoded = JSON.parse(d);
+      data = decoded;
+    } catch (error) {
+      deepLibLogger.error(error);
+    }
+    return data;
+  }
+  static dataCompress(object) {
+    return LZString.compressToBase64(JSON.stringify(object));
+  }
+};
+
+// src/utilities/elements/element_helpers.ts
+var domUtil = {
+  autoSetPosition,
+  autoSetSize,
+  hide,
+  unhide,
+  hasOverflow
+};
+function autoSetPosition(_, position) {
+  let xPos = void 0;
+  let yPos = void 0;
+  if (Array.isArray(position)) {
+    xPos = position[0];
+    yPos = position[1];
+  } else if (typeof position === "function") {
+    const result = position();
+    xPos = result[0];
+    yPos = result[1];
+  }
+  if (xPos !== void 0 && yPos !== void 0) ElementSetPosition(_, xPos, yPos);
+}
+__name(autoSetPosition, "autoSetPosition");
+function autoSetSize(_, size) {
+  let width = void 0;
+  let height = void 0;
+  if (Array.isArray(size)) {
+    width = size[0];
+    height = size[1];
+  } else if (typeof size === "function") {
+    const result = size();
+    width = result[0];
+    height = result[1];
+  }
+  if (width !== void 0 && height !== void 0) ElementSetSize(_, width, height);
+}
+__name(autoSetSize, "autoSetSize");
+function hide(_) {
+  const element = ElementWrap(_);
+  if (!element) return;
+  element.style.display = "none";
+}
+__name(hide, "hide");
+function unhide(_) {
+  const element = ElementWrap(_);
+  if (!element) return;
+  element.style.display = "";
+}
+__name(unhide, "unhide");
+function hasOverflow(el) {
+  const element = ElementWrap(el);
+  if (!element) return null;
+  const vertical = element.scrollHeight > element.clientHeight;
+  const horizontal = element.scrollWidth > element.clientWidth;
+  return {
+    any: vertical || horizontal,
+    vertical,
+    horizontal
+  };
+}
+__name(hasOverflow, "hasOverflow");
+
+// src/utilities/elements/layout_elements.ts
+var layoutElement = {
+  createSubscreenDiv: elementCreateSubscreenDiv,
+  getSubscreenDiv: elementGetSubscreenDiv,
+  appendToSubscreenDiv: elementAppendToSubscreenDiv,
+  removeSubscreenDiv: elementRemoveSubscreenDiv,
+  createSettingsDiv: elementCreateSettingsDiv,
+  getSettingsDiv: elementGetSettingsDiv,
+  appendToSettingsDiv: elementAppendToSettingsDiv,
+  removeSettingsDiv: elementRemoveSettingsDiv,
+  createMiscDiv: elementCreateMiscDiv,
+  getMiscDiv: elementGetMiscDiv,
+  appendToMiscDiv: elementAppendToMiscDiv,
+  removeMiscDiv: elementRemoveMiscDiv
+};
+function elementCreateSubscreenDiv() {
+  const subscreenDiv = elementGetSubscreenDiv();
+  if (subscreenDiv) {
+    console.error("Subscreen already exists");
+    return subscreenDiv;
+  }
+  const div = document.createElement("div");
+  div.id = "deeplib-subscreen";
+  div.classList.add("deeplib-subscreen", "HideOnPopup");
+  return document.body.appendChild(div);
+}
+__name(elementCreateSubscreenDiv, "elementCreateSubscreenDiv");
+function elementGetSubscreenDiv() {
+  return document.getElementById("deeplib-subscreen") ?? void 0;
+}
+__name(elementGetSubscreenDiv, "elementGetSubscreenDiv");
+function elementRemoveSubscreenDiv() {
+  return elementGetSubscreenDiv()?.remove();
+}
+__name(elementRemoveSubscreenDiv, "elementRemoveSubscreenDiv");
+function elementAppendToSubscreenDiv(...element) {
+  return elementGetSubscreenDiv()?.append(...element);
+}
+__name(elementAppendToSubscreenDiv, "elementAppendToSubscreenDiv");
+function elementCreateSettingsDiv() {
+  const settingsDiv = elementGetSettingsDiv();
+  if (settingsDiv) {
+    console.error("Settings screen already exists");
+    return settingsDiv;
+  }
+  const div = document.createElement("div");
+  div.id = "deeplib-settings";
+  div.classList.add("deeplib-settings");
+  return div;
+}
+__name(elementCreateSettingsDiv, "elementCreateSettingsDiv");
+function elementGetSettingsDiv() {
+  return document.getElementById("deeplib-settings") ?? void 0;
+}
+__name(elementGetSettingsDiv, "elementGetSettingsDiv");
+function elementAppendToSettingsDiv(...element) {
+  return elementGetSettingsDiv()?.append(...element);
+}
+__name(elementAppendToSettingsDiv, "elementAppendToSettingsDiv");
+function elementRemoveSettingsDiv() {
+  return elementGetSettingsDiv()?.remove();
+}
+__name(elementRemoveSettingsDiv, "elementRemoveSettingsDiv");
+function elementCreateMiscDiv() {
+  const miscDiv = elementGetMiscDiv();
+  if (miscDiv) {
+    console.error("Settings screen already exists");
+    return miscDiv;
+  }
+  const div = document.createElement("div");
+  div.id = "deeplib-misc";
+  div.classList.add("deeplib-misc");
+  return div;
+}
+__name(elementCreateMiscDiv, "elementCreateMiscDiv");
+function elementGetMiscDiv() {
+  return document.getElementById("deeplib-misc");
+}
+__name(elementGetMiscDiv, "elementGetMiscDiv");
+function elementAppendToMiscDiv(...element) {
+  return elementGetMiscDiv()?.append(...element);
+}
+__name(elementAppendToMiscDiv, "elementAppendToMiscDiv");
+function elementRemoveMiscDiv() {
+  return elementGetMiscDiv()?.remove();
+}
+__name(elementRemoveMiscDiv, "elementRemoveMiscDiv");
+
+// src/utilities/logger.ts
+var Logger = class _Logger extends Array {
+  static {
+    __name(this, "Logger");
+  }
+  ModName = "DeepLib";
+  constructor(modName) {
+    super();
+    if (modName) {
+      this.ModName = modName;
+    }
+  }
+  _Log(level, ...args) {
+    const logEntry = {
+      logLevel: level,
+      args: [...args],
+      // trace: arguments.callee.caller.toString().split('\n'), 
+      date: new Date(Date.now())
+      // `[${this.ModName}] ${formattedArgs}` 
+    };
+    const userAgent = navigator.userAgent.toLowerCase();
+    if (userAgent.includes("chrome") || userAgent.includes("firefox")) {
+      const color = _Logger.colorizeLog(level);
+      args.forEach((arg) => {
+        if (typeof arg === "string") {
+          arg = `
+%c${arg}`;
+        }
+      });
+      console.log(`%c${this.ModName}:`, color, ...args);
+    } else {
+      console.log(`${this.ModName}:`, ...args);
+    }
+    this.push(logEntry);
+  }
+  info(...args) {
+    this._Log("info", ...args);
+  }
+  log(...args) {
+    this._Log("log", ...args);
+  }
+  warn(...args) {
+    this._Log("warn", ...args);
+  }
+  error(...args) {
+    this._Log("error", ...args);
+  }
+  debug(...args) {
+    this._Log("debug", ...args);
+  }
+  static colorizeLog(logLevel) {
+    const colors = {
+      info: "color: #32CCCC",
+      log: "color: #CCCC32",
+      warn: "color: #eec355",
+      error: "color: #750b0b",
+      debug: "color: #9E4BCF"
+    };
+    return colors[logLevel];
+  }
+};
+var deepLibLogger = new Logger();
+
+// src/utilities/messages.ts
+function sendLocalMessage(id, message, timeoutInSeconds) {
+  const element = ElementCreate({
+    tag: "div",
+    classList: ["ChatMessage", "deeplib-message", "ChatMessageNonDialogue"],
+    attributes: {
+      id: id ?? `DEEPLIB_LOCAL_MESSAGE_${Date.now()}`,
+      "data-time": ChatRoomCurrentTime(),
+      "data-sender": Player.MemberNumber?.toString()
+    },
+    children: [
+      {
+        tag: "span",
+        classList: ["deeplib-text"],
+        innerHTML: message.replaceAll("\n	", "")
+      },
+      {
+        tag: "br"
+      },
+      {
+        tag: "a",
+        classList: ["deeplib-text"],
+        attributes: {
+          href: "#"
+        },
+        innerHTML: "<b>Close (Click)</b>",
+        eventListeners: {
+          click: /* @__PURE__ */ __name(() => {
+            element.remove();
+          }, "click")
+        }
+      }
+    ]
+  });
+  ChatRoomAppendChat(element);
+  if (!timeoutInSeconds) return;
+  setTimeout(() => element.remove(), timeoutInSeconds * 1e3);
+}
+__name(sendLocalMessage, "sendLocalMessage");
+function sendActionMessage(msg, target = void 0, dictionary = []) {
+  if (!msg) return;
+  ServerSend("ChatRoomChat", {
+    Content: "DEEPLIB_CUSTOM_ACTION",
+    Type: "Action",
+    Target: target ?? void 0,
+    Dictionary: [
+      { Tag: 'MISSING TEXT IN "Interface.csv": DEEPLIB_CUSTOM_ACTION', Text: msg },
+      ...dictionary
+    ]
+  });
+}
+__name(sendActionMessage, "sendActionMessage");
+
+// src/utilities/sdk.ts
+var import_bondage_club_mod_sdk = __toESM(require_bcmodsdk(), 1);
+var rawSdk = import_bondage_club_mod_sdk.default;
+var bcModSdkRef = rawSdk.default ?? rawSdk;
+var HookPriority = {
+  Observe: 0,
+  AddBehavior: 1,
+  ModifyBehavior: 5,
+  OverrideBehavior: 10,
+  Top: 100
+};
+var ModSdkManager = class _ModSdkManager {
+  static {
+    __name(this, "ModSdkManager");
+  }
+  static SDK;
+  static patchedFunctions = /* @__PURE__ */ new Map();
+  static ModInfo;
+  constructor(info, options) {
+    _ModSdkManager.SDK = bcModSdkRef.registerMod(info, options);
+    _ModSdkManager.ModInfo = info;
+  }
+  initPatchableFunction(target) {
+    let result = _ModSdkManager.patchedFunctions.get(target);
+    if (!result) {
+      result = {
+        name: target,
+        hooks: []
+      };
+      _ModSdkManager.patchedFunctions.set(target, result);
+    }
+    return result;
+  }
+  hookFunction(target, priority, hook, module = null) {
+    const data = this.initPatchableFunction(target);
+    if (data.hooks.some((h) => h.hook === hook)) {
+      return () => null;
+    }
+    const removeCallback = _ModSdkManager.SDK?.hookFunction(target, priority, hook);
+    data.hooks.push({
+      hook,
+      priority,
+      module,
+      removeCallback
+    });
+    data.hooks.sort((a, b) => b.priority - a.priority);
+    return removeCallback;
+  }
+  patchFunction(target, patches) {
+    _ModSdkManager.SDK?.patchFunction(target, patches);
+  }
+  unpatchFunction(target) {
+    _ModSdkManager.SDK?.removePatches(target);
+  }
+  removeHookByModule(target, module) {
+    const data = this.initPatchableFunction(target);
+    for (let i = data.hooks.length - 1; i >= 0; i--) {
+      if (data.hooks[i].module === module) {
+        data.hooks[i].removeCallback();
+        data.hooks.splice(i, 1);
+      }
+    }
+    return true;
+  }
+  removeAllHooksByModule(module) {
+    for (const data of _ModSdkManager.patchedFunctions.values()) {
+      for (let i = data.hooks.length - 1; i >= 0; i--) {
+        if (data.hooks[i].module === module) {
+          data.hooks[i].removeCallback();
+          data.hooks.splice(i, 1);
+        }
+      }
+    }
+    return true;
+  }
+};
+
+// src/utilities/style.ts
+var Style = {
+  injectInline(styleId, styleSource) {
+    const isStyleLoaded = document.getElementById(styleId);
+    if (isStyleLoaded) return;
+    const styleElement = document.createElement("style");
+    styleElement.id = styleId;
+    styleElement.appendChild(document.createTextNode(styleSource));
+    document.head.appendChild(styleElement);
+  },
+  injectEmbed(styleId, styleLink) {
+    const isStyleLoaded = document.getElementById(styleId);
+    if (isStyleLoaded) return;
+    const styleElement = document.createElement("link");
+    styleElement.id = styleId;
+    styleElement.rel = "stylesheet";
+    styleElement.href = styleLink;
+    document.head.appendChild(styleElement);
+  },
+  eject(id) {
+    const style = document.getElementById(id);
+    if (!style) return;
+    style.remove();
+  },
+  reload(styleId, styleSource) {
+    Style.eject(styleId);
+    Style.injectInline(styleId, styleSource);
+  },
+  async fetch(link) {
+    return fetch(link).then((res) => res.text());
+  }
+};
+
+// src/utilities/translation.ts
+var Localization = class _Localization {
+  static {
+    __name(this, "Localization");
+  }
+  static LibTranslation = {};
+  static ModTranslation = {};
+  static PathToModTranslation;
+  static PathToLibTranslation = `${PUBLIC_URL}/dl_translations/`;
+  static initialized = false;
+  static async init(initOptions) {
+    if (_Localization.initialized) return;
+    _Localization.initialized = true;
+    _Localization.PathToModTranslation = initOptions.pathToTranslationsFolder.endsWith("/") ? initOptions.pathToTranslationsFolder : initOptions.pathToTranslationsFolder + "/";
+    const lang = TranslationLanguage.toLowerCase();
+    const libTranslation = await _Localization.fetchLanguageFile(_Localization.PathToLibTranslation, lang);
+    if (lang === "en") {
+      _Localization.LibTranslation = libTranslation;
+    } else {
+      const fallbackTranslation = await _Localization.fetchLanguageFile(_Localization.PathToLibTranslation, "en");
+      _Localization.LibTranslation = { ...fallbackTranslation, ...libTranslation };
+    }
+    const modTranslation = await _Localization.fetchLanguageFile(_Localization.PathToModTranslation, lang);
+    if (lang === "en") {
+      _Localization.ModTranslation = modTranslation;
+    } else {
+      const fallbackTranslation = await _Localization.fetchLanguageFile(_Localization.PathToModTranslation, "en");
+      _Localization.ModTranslation = { ...fallbackTranslation, ...modTranslation };
+    }
+  }
+  static getTextMod(srcTag) {
+    return _Localization.ModTranslation?.[srcTag] || void 0;
+  }
+  static getTextLib(srcTag) {
+    return _Localization.LibTranslation?.[srcTag] || void 0;
+  }
+  static async fetchLanguageFile(baseUrl, lang) {
+    const response = await fetch(`${baseUrl}${lang}.lang`);
+    if (lang !== "en" && !response.ok) {
+      return this.fetchLanguageFile(baseUrl, "en");
+    }
+    const langFileContent = await response.text();
+    return this.parseLanguageFile(langFileContent);
+  }
+  static parseLanguageFile(content) {
+    const translations = {};
+    const lines = content.split("\n");
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+      const [key, ...rest] = trimmed.split("=");
+      translations[key.trim()] = rest.join("=").trim();
+    }
+    return translations;
+  }
+};
+var getText = /* @__PURE__ */ __name((srcTag) => {
+  return Localization.getTextMod(srcTag) || Localization.getTextLib(srcTag) || srcTag;
+}, "getText");
+export {
+  BaseMigrator2 as BaseMigrator,
+  BaseModule,
+  BaseSubscreen,
+  GUI,
+  GuiDebug,
+  GuiImportExport,
+  HookPriority,
+  Localization,
+  Logger,
+  MainMenu,
+  ModSdkManager,
+  ModStorage,
+  Modal,
+  Style,
+  VersionModule,
+  advancedElement,
+  deepLibLogger,
+  deepMerge,
+  deepMergeMatchingProperties,
+  domUtil,
+  exportToGlobal,
+  getCurrentSubscreen,
+  getModule,
+  getText,
+  hasGetter,
+  hasSetter,
+  init,
+  initMod,
+  layoutElement,
+  modStorage,
+  modules,
+  modulesMap,
+  registerModule,
+  sendActionMessage,
+  sendLocalMessage,
+  setSubscreen,
+  shuffleArray,
+  unloadMod
+};
+//# sourceMappingURL=deeplib.js.map