bc-deeplib 2.4.2 → 3.0.0

package/dist/index.js

@@ -0,0 +1,2626 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/base/base_module.ts
+var BaseModule = class {
+  static {
+    __name(this, "BaseModule");
+  }
+  /**
+   * An optional UI screen for configuring this module's settings.
+   * Subclasses can override this getter to provide a `Subscreen` instance.
+   * Modules with screens are automatically registered to the main menu.
+   */
+  get settingsScreen() {
+    return null;
+  }
+  /**
+   * The storage key under which this module's settings will be saved.
+   * Defaults to the class name.
+   *
+   * Subclasses can override this if they require a custom storage key.
+   */
+  get settingsStorage() {
+    return this.constructor.name;
+  }
+  /**
+   * Retrieves the current settings for this module.
+   * If no settings exist yet, registers default settings first.
+   */
+  get settings() {
+    const modName = ModSdkManager.ModInfo.name;
+    if (!this.settingsStorage) return null;
+    if (!modStorage.playerStorage) {
+      Player[modName] = {};
+      this.registerDefaultSettings(modStorage.playerStorage);
+    } else if (!modStorage.playerStorage[this.settingsStorage]) {
+      this.registerDefaultSettings(modStorage.playerStorage);
+    }
+    return modStorage.playerStorage[this.settingsStorage];
+  }
+  /**
+   * Persists new settings for this module.
+   * Automatically initializes storage and defaults if they don't exist.
+   */
+  set settings(value) {
+    const modName = ModSdkManager.ModInfo.name;
+    const storage = new ModStorage(modName);
+    if (!this.settingsStorage) return;
+    if (!storage.playerStorage) {
+      Player[modName] = {};
+      this.registerDefaultSettings(modStorage.playerStorage);
+    } else if (!storage.playerStorage[this.settingsStorage]) {
+      this.registerDefaultSettings(modStorage.playerStorage);
+    }
+    storage.playerStorage[this.settingsStorage] = value;
+  }
+  /**
+   * Initializes the module.
+   * Default implementation registers default settings immediately.
+   * Subclasses can override to perform additional setup.
+   */
+  init() {
+  }
+  /**
+   * Registers default settings for this module in persistent storage.
+   * Only runs if a storage key and default settings are defined.
+   * 
+   * If some settings already exist, they will be merged with defaults.
+   * Existing values will NOT be overwritten.
+   */
+  registerDefaultSettings(target) {
+    const storage = this.settingsStorage;
+    const defaults = this.defaultSettings;
+    if (!storage || !defaults) return;
+    if (Object.entries(this.defaultSettings).length === 0) return;
+    target[storage] = deepMerge(this.defaultSettings, target[storage], { concatArrays: false, matchingOnly: true });
+  }
+  /**
+   * Provides default settings for this module.
+   * Subclasses should override this getter to return their defaults.
+   */
+  get defaultSettings() {
+    return null;
+  }
+  /**
+   * Called when the module is loaded into the system.
+   * Subclasses should override to perform data loading or initialization.
+   */
+  load() {
+  }
+  /**
+   * By default doesn't get called each frame, only once when the module is loaded.
+   * Subclasses can override to implement runtime logic.
+   */
+  run() {
+  }
+  /**
+   * Called when the module is being removed.
+   * Subclasses can override to perform cleanup or save final state.
+   */
+  unload() {
+  }
+};
+
+// src/base/base_subscreen.ts
+async function setSubscreen(subscreen) {
+  if (!GUI.instance) {
+    throw new Error("Attempt to set subscreen before init");
+  }
+  const screenName = typeof subscreen === "string" ? subscreen : subscreen?.options.name;
+  const screenId = `${BaseSubscreen.id}_${screenName}`;
+  await CommonSetScreen(...["DeepLibMod", `${screenId}`]);
+}
+__name(setSubscreen, "setSubscreen");
+var BaseSubscreen = class _BaseSubscreen {
+  static {
+    __name(this, "BaseSubscreen");
+  }
+  /** Global registry of currently rendered elements and their definitions. */
+  static currentElements = [];
+  /** Tracks the currently visible page number (1-based index). */
+  static currentPage = 1;
+  /** Runtime options for this subscreen. */
+  options;
+  /** Reference to the module this subscreen belongs to. */
+  module;
+  /** Identifier for internal use to avoid screen name collisions. */
+  static id = CommonGenerateUniqueID();
+  /** Optional configuration flags for a BaseSubscreen instance. */
+  static subscreenOptions = {
+    drawCharacter: true,
+    name: "UNKNOWN",
+    icon: "",
+    background: "Sheet",
+    doShowExitButton: true,
+    doShowTitle: true,
+    settingsWidth: 1e3,
+    forceUpCharacter: false
+  };
+  /** The menu at the top of the subscreen */
+  static menu = null;
+  constructor(module) {
+    if (module) this.module = module;
+    const ctor = this.constructor;
+    this.options = {
+      ..._BaseSubscreen.subscreenOptions,
+      ...ctor.subscreenOptions
+    };
+    const screenName = this.options.name;
+    const screenId = `${_BaseSubscreen.id}_${screenName}`;
+    exportToGlobal(`${screenId}Load`, this.load.bind(this));
+    exportToGlobal(`${screenId}Run`, this.run.bind(this));
+    exportToGlobal(`${screenId}Click`, this.click.bind(this));
+    exportToGlobal(`${screenId}Exit`, this.exit.bind(this));
+    exportToGlobal(`${screenId}Unload`, this.unload.bind(this));
+    exportToGlobal(`${screenId}Resize`, this.resize.bind(this));
+    exportToGlobal(`${screenId}Background`, this.options.background);
+    CommonCSVCache[ScreenFileGetTranslation("DeepLibMod", screenId)] = [];
+  }
+  /** Changes the currently active subscreen. */
+  async setSubscreen(screen) {
+    return await setSubscreen(screen);
+  }
+  /** Gets this subscreen's settings object from its parent module. */
+  get settings() {
+    return this.module.settings;
+  }
+  /** Updates this subscreen's settings in its parent module. */
+  set settings(value) {
+    this.module.settings = value;
+  }
+  /**
+   * Defines the paginated layout of the subscreen's settings UI.
+   * Each element in the outer array is a page; each page contains `SettingElement`s.
+   *
+   * Subclasses should override to define their actual UI structure.
+   */
+  get pageStructure() {
+    return [[]];
+  }
+  /** Gets the currently visible page's settings elements. */
+  get currentPage() {
+    return this.pageStructure[Math.min(_BaseSubscreen.currentPage - 1, this.pageStructure.length - 1)];
+  }
+  getPageLabel() {
+    return CommonStringPartitionReplace(getText("settings.page.label"), {
+      $currentPage$: `${_BaseSubscreen.currentPage}`,
+      $totalPages$: `${this.pageStructure.length}`
+    }).join("");
+  }
+  /**
+   * Changes the visible page in a multi-page subscreen.
+   * Automatically wraps around when going past the first or last page.
+   */
+  changePage(page, setLabel) {
+    const totalPages = this.pageStructure.length;
+    if (page > totalPages) page = 1;
+    if (page < 1) page = totalPages;
+    _BaseSubscreen.currentPage = page;
+    this.managePageElementsVisibility();
+    setLabel(this.getPageLabel());
+  }
+  /**
+   * Updates the DOM to show only elements belonging to the current page.
+   * All elements on other pages are hidden.
+   */
+  managePageElementsVisibility() {
+    this.pageStructure.forEach((item, ix) => {
+      item.forEach((setting) => {
+        const element = ElementWrap(`${setting.id}-container`) ?? ElementWrap(`${setting.id}`);
+        if (ix !== _BaseSubscreen.currentPage - 1) {
+          if (element) domUtil.hide(element);
+        } else {
+          if (element) domUtil.unhide(element);
+        }
+      });
+    });
+  }
+  /**
+   * Called when this subscreen is first displayed.
+   * Builds the layout, initializes navigation, and renders all settings elements.
+   *
+   * Handles:
+   *  - Ensuring each module with a settings screen has its defaults loaded
+   *  - Creating navigation menus and back/next page controls
+   *  - Building and appending UI elements based on `pageStructure`
+   *  - Setting up exit button and tooltip
+   *  - Resetting to page 1
+   */
+  load() {
+    for (const module of modules()) {
+      if (!module.settingsScreen) continue;
+      if (!module.settings || !Object.keys(module.settings).length) module.registerDefaultSettings(modStorage.playerStorage);
+    }
+    _BaseSubscreen.currentPage = 1;
+    layout.getSubscreen();
+    const settingsElement = layout.getSettingsDiv();
+    layout.appendToSubscreen(settingsElement);
+    _BaseSubscreen.menu = ElementMenu.Create("deeplib-nav-menu", []);
+    layout.appendToSubscreen(_BaseSubscreen.menu);
+    if (this.pageStructure.length > 1) {
+      const backNext = advElement.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: this.getPageLabel()
+      });
+      _BaseSubscreen.menu.prepend(backNext);
+    }
+    if (this.options.help) {
+      const onClick = this.options.help.onClick;
+      let action = /* @__PURE__ */ __name(() => {
+      }, "action");
+      if (typeof onClick === "string" || onClick instanceof URL) {
+        action = /* @__PURE__ */ __name(() => window.open(onClick, "_blank"), "action");
+      } else if (typeof onClick === "function") {
+        action = onClick;
+      } else if (onClick instanceof _BaseSubscreen) {
+        action = /* @__PURE__ */ __name(async () => await this.setSubscreen(onClick), "action");
+      }
+      this.options.help.tooltip ??= getText("settings.button.help_button_hint");
+      this.options.help.icon ??= `${PUBLIC_URL}/dl_images/bookmark.svg`;
+      const helpButton = advElement.createButton({
+        id: "deeplib-help",
+        size: [90, 90],
+        onClick: action,
+        options: {
+          image: this.options.help.icon,
+          tooltip: this.options.help.tooltip
+        }
+      });
+      _BaseSubscreen.menu.append(helpButton);
+    }
+    if (this.options.doShowTitle) {
+      const subscreenTitle = advElement.createLabel({
+        id: "deeplib-subscreen-title",
+        label: getText(`${this.options.name}.title`).replace("$ModVersion", ModSdkManager.ModInfo.version)
+      });
+      layout.appendToSubscreen(subscreenTitle);
+    }
+    if (this.options.doShowExitButton) {
+      const exitButton = advElement.createButton({
+        id: "deeplib-exit",
+        size: [90, 90],
+        onClick: /* @__PURE__ */ __name(() => {
+          this.exit();
+        }, "onClick"),
+        options: {
+          image: `${PUBLIC_URL}/dl_images/exit.svg`,
+          tooltip: getText("settings.button.back_button_hint")
+        }
+      });
+      _BaseSubscreen.menu.append(exitButton);
+    }
+    const tooltip = advElement.createTooltip();
+    layout.appendToSubscreen(tooltip);
+    this.pageStructure.forEach(
+      (s) => s.forEach((item) => {
+        let element;
+        switch (item.type) {
+          case "text":
+          case "number":
+          case "color":
+            element = advElement.createInput(item);
+            break;
+          case "checkbox":
+            element = advElement.createCheckbox(item);
+            break;
+          case "button":
+            element = advElement.createButton(item);
+            break;
+          case "label":
+            element = advElement.createLabel(item);
+            break;
+          case "custom":
+            element = advElement.createCustom(item);
+            break;
+          case "dropdown":
+            element = advElement.createDropdown(item);
+            break;
+        }
+        layout.appendToSettingsDiv(element);
+      })
+    );
+    this.managePageElementsVisibility();
+    if (this.options.drawCharacter && this.options.forceUpCharacter) {
+      CharacterAppearanceForceUpCharacter = Player.MemberNumber;
+    } else {
+      CharacterAppearanceForceUpCharacter = -1;
+    }
+  }
+  /**
+   * Called each frame while this subscreen is active.
+   * Default behavior draws the player's character if `drawCharacter` is enabled.
+   */
+  run() {
+    if (this.options.drawCharacter) DrawCharacter(Player, 50, 50, 0.9, false);
+  }
+  /**
+   * Handles mouse clicks *on canvas* while the subscreen is active.
+   * Default implementation is empty — subclasses may override.
+   */
+  click() {
+  }
+  /**
+   * Exits this subscreen, returning to the main menu.
+   * Also saves persistent storage changes.
+   * Called after the `unload`.
+   */
+  exit() {
+    CharacterAppearanceForceUpCharacter = -1;
+    CharacterLoadCanvas(Player);
+    const returnScreen = typeof this.options.returnScreen === "function" ? this.options.returnScreen() : this.options.returnScreen;
+    if (returnScreen instanceof _BaseSubscreen || !returnScreen) {
+      setSubscreen(returnScreen ?? "mainmenu").then(() => {
+        modStorage.save();
+      });
+    } else if (Array.isArray(returnScreen)) {
+      CommonSetScreen(...returnScreen).then(() => {
+        modStorage.save();
+      });
+    }
+  }
+  /**
+   * Called when the window is resized.
+   * Also checks for overflow in the settings div and applies styling accordingly.
+   */
+  resize(_onLoad = false) {
+    const offset = this.options.drawCharacter ? 0 : 380;
+    const subscreen = layout.getSubscreen();
+    const settingsDiv = layout.getSettingsDiv();
+    ElementSetPosition(subscreen, 0, 0);
+    ElementSetSize(subscreen, 2e3, 1e3);
+    ElementSetFontSize(subscreen, "auto");
+    ElementSetPosition(settingsDiv, 530 - offset, 170);
+    ElementSetSize(settingsDiv, this.options.settingsWidth ?? 1e3 + offset, 660);
+    if (this.options.doShowTitle) {
+      ElementSetPosition("deeplib-subscreen-title", 530 - offset, 75);
+      ElementSetSize("deeplib-subscreen-title", 800, 90);
+    }
+    ElementSetPosition("deeplib-nav-menu", 1905, 75, "top-right");
+    ElementSetSize("deeplib-nav-menu", null, 90);
+    ElementSetPosition(advElement.getTooltip() || "", 250, 850);
+    ElementSetSize(advElement.getTooltip() || "", 1500, 70);
+    _BaseSubscreen.currentElements.forEach((item) => {
+      const element = item[0];
+      const options = item[1];
+      domUtil.autoSetPosition(options.id ?? element.id, options.position);
+      domUtil.autoSetSize(options.id ?? element.id, options.size);
+    });
+    if (settingsDiv) {
+      if (domUtil.hasOverflow(settingsDiv)?.vertical) {
+        settingsDiv.classList.add("deeplib-overflow-box");
+      } else {
+        settingsDiv.classList.remove("deeplib-overflow-box");
+      }
+    }
+  }
+  /**
+   * Called when this subscreen is being removed.
+   * Resets the static element registry and removes the subscreen from the layout.
+   * Called before `exit`.
+   */
+  unload() {
+    _BaseSubscreen.currentElements = [];
+    layout.removeSubscreen();
+  }
+};
+
+// 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-accent-color: var(--tmd-accent, #FFFF88);
+  --deeplib-blocked-color: var(--tmd-blocked, red);
+  --deeplib-text-color: var(--tmd-text, black);
+  --deeplib-icon-color: var(--tmd-accent, black);
+  --deeplib-icon-hover-color: var(--tmd-accent-hover, black);
+  --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);
+  display: contents;
+}
+.deeplib-button .button-tooltip {
+  border-radius: min(1dvh, 0.5dvw);
+}
+
+#deeplib-page-label {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  pointer-events: none;
+}
+
+#deeplib-subscreen-title {
+  text-align: left;
+  color: var(--deeplib-text-color);
+  user-select: none;
+  pointer-events: none;
+  display: flex;
+  align-items: center;
+}
+
+.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;
+}
+
+.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);
+  z-index: 1;
+}
+
+.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:hover {
+  background-color: var(--deeplib-element-hover-color);
+  border-radius: var(--deeplib-border-radius);
+}
+.deeplib-prev-next .deeplib-prev-next-button {
+  height: 100%;
+  aspect-ratio: 1;
+}
+.deeplib-prev-next .deeplib-prev-next-label {
+  white-space: nowrap;
+  user-select: none;
+}
+
+#deeplib-nav-menu {
+  display: flex;
+  flex-direction: row;
+  gap: min(2dvh, 1dvw);
+  z-index: 1;
+}
+#deeplib-nav-menu > .deeplib-button {
+  flex: 1 0 auto;
+}
+
+#deeplib-storage-meter {
+  position: absolute;
+  top: 0px;
+  left: 0px;
+  width: 100%;
+  height: 100%;
+  overflow: hidden;
+  background-color: var(--deeplib-element-color);
+  border: var(--deeplib-border-width) solid var(--deeplib-border-color);
+  border-radius: var(--deeplib-border-radius);
+  z-index: -1;
+}
+#deeplib-storage-meter #deeplib-storage-bar {
+  height: 100%;
+  width: 0%;
+  background: var(--deeplib-accent-color);
+}
+
+.deeplib-checkbox-container {
+  display: flex;
+  flex-direction: row;
+  align-items: center;
+  gap: 0.3em;
+  width: fit-content;
+}
+.deeplib-checkbox-container span {
+  user-select: none;
+}
+.deeplib-checkbox-container .deeplib-input {
+  width: min(5vh, 2.5vw);
+  height: min(5vh, 2.5vw);
+  width: min(5dvh, 2.5dvw);
+  height: min(5dvh, 2.5dvw);
+  border-radius: min(1vh, 0.5vw);
+  border-radius: min(1dvh, 0.5dvw);
+}
+.deeplib-checkbox-container .deeplib-input[type=checkbox]:checked::before {
+  width: 80%;
+  height: 80%;
+}
+
+.deeplib-input-container {
+  display: flex;
+  flex-direction: row;
+  align-items: center;
+  gap: 0.3em;
+  width: fit-content;
+}
+.deeplib-input-container span {
+  user-select: none;
+}
+.deeplib-input-container:has(.deeplib-text) {
+  margin-top: min(1vh, 0.5vw);
+  margin-top: min(1dvh, 0.5dvw);
+}
+.deeplib-input-container .deeplib-input {
+  font-size: 0.6em;
+  padding: min(1vh, 0.5vw);
+  padding: min(1dvh, 0.5dvw);
+  background-color: transparent;
+  outline: none;
+  min-height: min(5vh, 2.5vw);
+  min-height: min(5dvh, 2.5dvw);
+  border-radius: min(1vh, 0.5vw);
+  border-radius: min(1dvh, 0.5dvw);
+}
+.deeplib-input-container .deeplib-input[type=color] {
+  padding: 0px;
+  width: min(5vh, 2.5vw);
+  height: min(5vh, 2.5vw);
+  width: min(5dvh, 2.5dvw);
+  height: min(5dvh, 2.5dvw);
+  border-radius: 0px;
+}
+.deeplib-input-container .deeplib-input[type=color]:disabled {
+  border: var(--deeplib-blocked-color) solid var(--deeplib-border-width);
+  cursor: not-allowed;
+}
+
+.deeplib-dropdown-container {
+  display: flex;
+  flex-direction: row;
+  align-items: center;
+  gap: min(2vh, 1vw);
+  gap: min(2dvh, 1dvw);
+  color: var(--deeplib-text-color);
+  width: fit-content;
+}
+.deeplib-dropdown-container select {
+  padding: 0 min(1vh, 0.5vw);
+  padding: 0 min(1dvh, 0.5dvw);
+  border-radius: min(1vh, 0.5vw);
+  border-radius: min(1dvh, 0.5dvw);
+}
+.deeplib-dropdown-container span {
+  user-select: none;
+}
+
+.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 .deeplib-modal-prompt-container {
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+  align-items: center;
+}
+
+.deeplib-modal-blocker {
+  z-index: 1000;
+  position: fixed;
+  top: 0;
+  left: 0;
+  width: 100dvw;
+  height: 100dvh;
+  background-color: rgba(0, 0, 0, 0.5);
+}
+
+#deeplib-modal-import_export .deeplib-modal-checkbox-container {
+  margin-top: 0.5em;
+  display: flex;
+  flex-direction: column;
+  gap: var(--half-gap);
+}
+/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sourceRoot":"/mnt/shindows/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;EACA;;;ACdF;EACE;EACA;EACA;;AAEA;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;EACA;;AAGF;EACE;;;AC3CJ;EACE;EACA;EACA;EACA;;;AAGF;EACE;EACA;EACA;EACA;EACA;EACA;;;AAGF;EACE;;;AAGF;EACE;EACA;EACA;;;AAGF;EACE;EACA;;;AAGF;EACE;EACA;EACA;EACA;;;AAGF;EACE;EACA;EACA;EACA;;;AAGF;EACE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;AAGF;EACE;;;AAGF;EACE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;AAGE;EACE;EACA;;AAHJ;EAME;EACA;;AAGF;EACE;EACA;;;AAIJ;EACE;EACA;EACA;EACA;;AAEA;EACE;;;AAIJ;EACE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;AAEA;EACE;EACA;EACA;;;ACnHJ;EACE;EACA;EACA;EACA;EACA;;AAEA;EACE;;AAGF;EACE;EACA;EACA;EACA;EACA;EACA;;AAEA;EACE;EACA;;;AAKN;EACE;EACA;EACA;EACA;EACA;;AAEA;EACE;;AAGF;EACE;EACA;;AAGF;EACE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;AAEA;EACE;EACA;EACA;EACA;EACA;EACA;;AAEA;EACE;EACA;;;AAOR;EACE;EACA;EACA;EACA;EACA;EACA;EACA;;AAEA;EACE;EACA;EACA;EACA;;AAGF;EACE;;;ACvFJ;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;;AAKN;EACE;EACA;EACA;EACA;;;AAIJ;EACE;EACA;EACA;EACA;EACA;EACA;EACA;;;AAIA;EACE;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-accent-color: var(--tmd-accent, #FFFF88);\n  --deeplib-blocked-color: var(--tmd-blocked, red);\n  --deeplib-text-color: var(--tmd-text, black);\n  --deeplib-icon-color: var(--tmd-accent, black);\n  --deeplib-icon-hover-color: var(--tmd-accent-hover, black);\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  &.button-styling,\n  &.button-styling::before {\n    border-radius: min(1.0dvh, 0.5dvw);\n  }\n\n  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  &:hover img {\n    background-color: var(--deeplib-icon-hover-color);\n  }\n\n  .button-label {\n    background-color: transparent !important;\n    color: var(--deeplib-text-color);\n    font-size: min(3.6dvh, 1.8dvw);\n    display: contents;\n  }\n\n  .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  pointer-events: none;\n}\n\n#deeplib-subscreen-title {\n  text-align: left;\n  color: var(--deeplib-text-color);\n  user-select: none;\n  pointer-events: none;\n  display: flex;\n  align-items: center;\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}\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  z-index: 1;\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    user-select: none;\n  }\n}\n\n#deeplib-nav-menu {\n  display: flex;\n  flex-direction: row;\n  gap: min(2dvh, 1dvw);\n  z-index: 1;\n\n  &>.deeplib-button {\n    flex: 1 0 auto;\n  }\n}\n\n#deeplib-storage-meter {\n  position: absolute;\n  top: 0px;\n  left: 0px;\n  width: 100%;\n  height: 100%;\n  overflow: hidden;\n  background-color: var(--deeplib-element-color);\n  border: var(--deeplib-border-width) solid var(--deeplib-border-color);\n  border-radius: var(--deeplib-border-radius);\n  z-index: -1;\n\n  #deeplib-storage-bar {\n    height: 100%;\n    width: 0%;\n    background: var(--deeplib-accent-color);\n  }\n}",".deeplib-checkbox-container {\n  display: flex;\n  flex-direction: row;\n  align-items: center;\n  gap: 0.3em;\n  width: fit-content;\n\n  span {\n    user-select: none;\n  }\n\n  .deeplib-input {\n    width: min(5vh, 2.5vw);\n    height: min(5vh, 2.5vw);\n    width: min(5dvh, 2.5dvw);\n    height: min(5dvh, 2.5dvw);\n    border-radius: min(1.0vh, 0.5vw);\n    border-radius: min(1.0dvh, 0.5dvw);\n\n    &[type=\"checkbox\"]:checked::before {\n      width: 80%;\n      height: 80%;\n    }\n  }\n}\n\n.deeplib-input-container {\n  display: flex;\n  flex-direction: row;\n  align-items: center;\n  gap: 0.3em;\n  width: fit-content;\n\n  span {\n    user-select: none;\n  }\n\n  &:has(.deeplib-text) {\n    margin-top: min(1vh, 0.5vw);\n    margin-top: min(1dvh, 0.5dvw);\n  }\n\n  .deeplib-input {\n    font-size: 0.6em;\n    padding: min(1vh, 0.5vw);\n    padding: min(1dvh, 0.5dvw);\n    background-color: transparent;\n    outline: none;\n    min-height: min(5vh, 2.5vw);\n    min-height: min(5dvh, 2.5dvw);\n    border-radius: min(1.0vh, 0.5vw);\n    border-radius: min(1.0dvh, 0.5dvw);\n\n    &[type=\"color\"] {\n      padding: 0px;\n      width: min(5vh, 2.5vw);\n      height: min(5vh, 2.5vw);\n      width: min(5dvh, 2.5dvw);\n      height: min(5dvh, 2.5dvw);\n      border-radius: 0px;\n\n      &:disabled {\n        border: var(--deeplib-blocked-color) solid var(--deeplib-border-width);\n        cursor: not-allowed;\n      }\n    }\n  }\n}\n\n\n.deeplib-dropdown-container {\n  display: flex;\n  flex-direction: row;\n  align-items: center;\n  gap: min(2vh, 1vw);\n  gap: min(2dvh, 1dvw);\n  color: var(--deeplib-text-color);\n  width: fit-content;\n\n  select {\n    padding: 0 min(1vh, 0.5vw);\n    padding: 0 min(1dvh, 0.5dvw);\n    border-radius: min(1vh, 0.5vw);\n    border-radius: min(1dvh, 0.5dvw);\n  }\n\n  span {\n    user-select: none;\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  .deeplib-modal-prompt-container {\n    display: flex;\n    flex-direction: column;\n    justify-content: center;\n    align-items: center;\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\n#deeplib-modal-import_export {\n  .deeplib-modal-checkbox-container {\n    margin-top: 0.5em;\n    display: flex;\n    flex-direction: column;\n    gap: var(--half-gap);\n  }\n}"]} */`;
+
+// src/screens/debug.ts
+var GuiDebug = class extends BaseSubscreen {
+  static {
+    __name(this, "GuiDebug");
+  }
+  static subscreenOptions = {
+    name: "debug"
+  };
+  get pageStructure() {
+    return [
+      [
+        {
+          type: "button",
+          id: "test-deeplib-big-button",
+          options: {
+            label: "Big Button",
+            tooltip: "This is a big button",
+            image: "Icons/Exit.png"
+          },
+          size: [405, 80],
+          onClick() {
+            deepLibLogger.info("Big Button Clicked");
+          }
+        },
+        {
+          type: "button",
+          id: "test-deeplib-small-button",
+          options: {
+            tooltip: "This is a small button",
+            image: "Icons/Exit.png"
+          },
+          size: [90, 90],
+          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",
+          options: {
+            label: "Big Button",
+            tooltip: "This is a big button",
+            image: "Icons/Exit.png"
+          },
+          size: [405, 80],
+          onClick() {
+            deepLibLogger.info("Big Button Clicked");
+          }
+        },
+        {
+          type: "button",
+          id: "test-deeplib-small-button2",
+          options: {
+            tooltip: "This is a small button",
+            image: "Icons/Next.png"
+          },
+          size: [90, 90],
+          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"
+        },
+        {
+          type: "dropdown",
+          id: "test-deeplib-dropdown",
+          label: "Dropdown",
+          description: "This is a dropdown",
+          optionsList: ["Option 1", "Option 2", "Option 3"],
+          setElementValue() {
+            return "Option 2";
+          },
+          setSettingValue(val) {
+            deepLibLogger.info("Dropdown value:", val);
+          },
+          options: {
+            width: 200
+          }
+        }
+      ]
+    ];
+  }
+};
+
+// src/utilities/common.ts
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype && !Array.isArray(value);
+}
+__name(isPlainObject, "isPlainObject");
+function deepMerge(target, source, options = { concatArrays: true, matchingOnly: false }) {
+  if (target === void 0) return source;
+  if (source === void 0) return target;
+  if (Array.isArray(target) && Array.isArray(source) && options.concatArrays) {
+    return [...target, ...source];
+  }
+  if (isPlainObject(target) && isPlainObject(source)) {
+    const result = { ...target };
+    const keys = options.matchingOnly ? Object.keys(source).filter((k) => k in target) : Object.keys(source);
+    for (const key of keys) {
+      if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
+      result[key] = key in target ? deepMerge(target[key], source[key], options) : source[key];
+    }
+    return result;
+  }
+  return source;
+}
+__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 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");
+var byteToKB = /* @__PURE__ */ __name((nByte) => Math.round(nByte / 100) / 10, "byteToKB");
+
+// src/utilities/elements/elements.ts
+var advElement = {
+  createButton: elementCreateButton,
+  createCheckbox: elementCreateCheckbox,
+  createInput: elementCreateInput,
+  createLabel: elementCreateLabel,
+  createCustom: elementCreateCustom,
+  createDropdown: elementCreateDropdown,
+  createTooltip: elementCreateTooltip,
+  getTooltip: elementGetTooltip,
+  setTooltip: elementSetTooltip,
+  createBackNext: elementPrevNext
+};
+function elementCreateButton(options) {
+  options.id ??= ElementGenerateID();
+  const elem = document.getElementById(options.id);
+  if (elem) return elem;
+  options.type = "button";
+  let image = void 0;
+  if (options.options?.image) {
+    image = options.options.image;
+    options.options.image = void 0;
+  }
+  const disabled = typeof options?.disabled === "function" ? options?.disabled() : options?.disabled;
+  const button = ElementButton.Create(
+    options.id,
+    options?.onClick ?? (() => {
+    }),
+    deepMerge({
+      labelPosition: "center"
+    }, options.options),
+    deepMerge({
+      button: {
+        classList: ["deeplib-button"],
+        attributes: {
+          disabled
+        },
+        children: [
+          image ? deepMerge({
+            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("${image}")`
+            }
+          }, options.htmlOptions?.img) : void 0
+        ]
+      }
+    }, options.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(deepMerge({
+    tag: "label",
+    classList: ["deeplib-checkbox-container"],
+    attributes: {
+      id: `${options.id}-container`,
+      for: options.id
+    },
+    children: [
+      deepMerge({
+        tag: "input",
+        classList: ["checkbox", "deeplib-input"],
+        attributes: {
+          type: "checkbox",
+          id: options.id,
+          disabled,
+          checked: options?.setElementValue?.() || void 0
+        },
+        eventListeners: {
+          change: /* @__PURE__ */ __name(function() {
+            options?.setSettingValue?.(this.checked);
+          }, "change")
+        }
+      }, options.htmlOptions?.checkbox),
+      deepMerge({
+        tag: "span",
+        classList: ["deeplib-text"],
+        attributes: {
+          id: `${options.id}-label`
+        },
+        children: [options.label]
+      }, options.htmlOptions?.label)
+    ]
+  }, options.htmlOptions?.container));
+  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) {
+  options.id ??= ElementGenerateID();
+  options.htmlOptions.attributes ??= {};
+  options.htmlOptions.attributes.id ??= options.id;
+  const elem = document.getElementById(options.htmlOptions.attributes.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(deepMerge({
+    tag: "label",
+    classList: ["deeplib-input-container"],
+    attributes: {
+      id: `${options.id}-container`,
+      for: options.id
+    },
+    children: [
+      deepMerge({
+        tag: "input",
+        classList: ["deeplib-input"],
+        attributes: {
+          type: options.type,
+          id: options.id,
+          placeholder: " ",
+          disabled,
+          value: options?.setElementValue?.() || void 0
+        },
+        eventListeners: {
+          input: /* @__PURE__ */ __name(function() {
+            options?.setSettingValue?.(this.value);
+          }, "input")
+        }
+      }, options.htmlOptions?.input),
+      options.label ? deepMerge({
+        tag: "span",
+        classList: ["deeplib-text"],
+        attributes: {
+          id: `${options.id}-label`
+        },
+        children: [options.label]
+      }, options.htmlOptions?.label) : void 0
+    ]
+  }, options.htmlOptions?.container));
+  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: "label",
+    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 elementCreateDropdown(options) {
+  options.id ??= ElementGenerateID();
+  const elem = document.getElementById(`${options.id}-container`);
+  if (elem) return elem;
+  options.type = "dropdown";
+  const retElem = ElementCreate(deepMerge({
+    tag: "label",
+    classList: ["deeplib-dropdown-container"],
+    attributes: {
+      id: `${options.id}-container`,
+      for: options.id
+    },
+    children: [
+      options.label ? deepMerge({
+        tag: "span",
+        classList: ["deeplib-text"],
+        attributes: {
+          id: `${options.id}-label`
+        },
+        children: [options.label]
+      }, options.htmlOptions?.label) : void 0,
+      ElementCreateDropdown(
+        options.id,
+        options.optionsList,
+        function() {
+          return options.setSettingValue?.(this.value);
+        },
+        options.options,
+        options.htmlOptions?.select
+      )
+    ],
+    eventListeners: {
+      mouseover: /* @__PURE__ */ __name(function() {
+        elementSetTooltip(options.description ?? "");
+      }, "mouseover"),
+      mouseout: /* @__PURE__ */ __name(function() {
+        elementSetTooltip("");
+      }, "mouseout")
+    }
+  }, options.htmlOptions?.container));
+  BaseSubscreen.currentElements.push([retElem, options]);
+  return retElem;
+}
+__name(elementCreateDropdown, "elementCreateDropdown");
+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: [
+      advElement.createButton({
+        id: `deeplib-prev-next-${options.id}-prev-button`,
+        onClick: /* @__PURE__ */ __name(() => {
+          options.back({
+            setLabel,
+            setBackTooltip: setPrevTooltip,
+            setNextTooltip
+          });
+        }, "onClick"),
+        htmlOptions: {
+          button: {
+            classList: ["deeplib-prev-next-button"]
+          }
+        },
+        options: {
+          noStyling: true,
+          image: `${PUBLIC_URL}/dl_images/arrow_left.svg`,
+          tooltip: options.initialPrevTooltip
+        }
+      }),
+      advElement.createLabel({
+        id: `${options.id}-label`,
+        label: options.initialLabel,
+        htmlOptions: {
+          classList: ["deeplib-prev-next-label"]
+        }
+      }),
+      advElement.createButton({
+        id: `deeplib-prev-next-${options.id}-next-button`,
+        onClick: /* @__PURE__ */ __name(() => {
+          options.next({
+            setLabel,
+            setBackTooltip: setPrevTooltip,
+            setNextTooltip
+          });
+        }, "onClick"),
+        htmlOptions: {
+          button: {
+            classList: ["deeplib-prev-next-button"]
+          }
+        },
+        options: {
+          noStyling: true,
+          image: `${PUBLIC_URL}/dl_images/arrow_right.svg`,
+          tooltip: options.initialNextTooltip
+        }
+      })
+    ]
+  });
+  return retElem;
+}
+__name(elementPrevNext, "elementPrevNext");
+
+// src/screens/main_menu.ts
+var MainMenu = class _MainMenu extends BaseSubscreen {
+  static {
+    __name(this, "MainMenu");
+  }
+  subscreens = [];
+  static options = {};
+  static subscreenOptions = {
+    name: "mainmenu",
+    doShowExitButton: false,
+    settingsWidth: 600
+  };
+  constructor(module) {
+    super(module);
+    this.subscreens = module.subscreens;
+  }
+  load() {
+    if (!GUI.instance || CurrentModule !== "DeepLibMod") {
+      this.setSubscreen(this);
+      return;
+    }
+    super.load();
+    const exitButton = advElement.createButton({
+      id: "exit",
+      size: [90, 90],
+      onClick: /* @__PURE__ */ __name(() => {
+        this.exit();
+      }, "onClick"),
+      options: {
+        image: `${PUBLIC_URL}/dl_images/exit.svg`,
+        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.options.name === "mainmenu") continue;
+      const button = advElement.createButton({
+        id: `${screen.options.name}-button`,
+        onClick: /* @__PURE__ */ __name(() => {
+          this.setSubscreen(screen);
+        }, "onClick"),
+        size: [null, 90],
+        options: {
+          image: screen.options.icon,
+          label: getText(`mainmenu.button.${screen.options.name}`)
+        }
+      });
+      layout.appendToSettingsDiv(button);
+    }
+    const miscDiv = layout.getMiscDiv();
+    layout.appendToSubscreen(miscDiv);
+    if (_MainMenu.options.wikiLink) {
+      const wikiButton = advElement.createButton({
+        id: "deeplib-wiki-button",
+        onClick: /* @__PURE__ */ __name(() => {
+          window.open(_MainMenu.options.wikiLink, "_blank");
+        }, "onClick"),
+        size: [null, 80],
+        options: {
+          image: `${PUBLIC_URL}/dl_images/notebook.svg`,
+          label: getText("mainmenu.button.wiki")
+        }
+      });
+      layout.appendToMiscDiv(wikiButton);
+    }
+    if (_MainMenu.options.repoLink) {
+      const repoButton = advElement.createButton({
+        id: "deeplib-repo-button",
+        onClick: /* @__PURE__ */ __name(() => {
+          window.open(_MainMenu.options.repoLink, "_blank");
+        }, "onClick"),
+        size: [null, 80],
+        options: {
+          image: `${PUBLIC_URL}/dl_images/git.svg`,
+          label: getText("mainmenu.button.repo")
+        }
+      });
+      layout.appendToMiscDiv(repoButton);
+    }
+    if (_MainMenu.options.resetSubscreen) {
+      const resetButton = advElement.createButton({
+        id: "deeplib-reset-button",
+        onClick: /* @__PURE__ */ __name(() => {
+          this.setSubscreen(_MainMenu.options.resetSubscreen);
+        }, "onClick"),
+        size: [null, 80],
+        options: {
+          image: `${PUBLIC_URL}/dl_images/trash_bin.svg`,
+          label: getText("mainmenu.button.reset")
+        }
+      });
+      layout.appendToMiscDiv(resetButton);
+    }
+    if (_MainMenu.options.importExportSubscreen) {
+      const importExportButton = advElement.createButton({
+        id: "deeplib-import-export-button",
+        onClick: /* @__PURE__ */ __name(() => {
+          this.setSubscreen(_MainMenu.options.importExportSubscreen);
+        }, "onClick"),
+        size: [null, 80],
+        options: {
+          image: `${PUBLIC_URL}/dl_images/transfer.svg`,
+          label: getText("mainmenu.button.import_export")
+        }
+      });
+      layout.appendToMiscDiv(importExportButton);
+    }
+    if (_MainMenu.options.storageFullnessIndicator) {
+      const maxStorageCapacityKB = 180;
+      const currentStorageCapacityKB = byteToKB(ModStorage.measureSize(modStorage.extensionStorage));
+      const fullness = (currentStorageCapacityKB / maxStorageCapacityKB * 100).toFixed(1);
+      const storageFullnessWrapper = advElement.createButton({
+        id: CommonGenerateUniqueID(),
+        size: [null, 80],
+        options: {
+          tooltipPosition: "left",
+          noStyling: true,
+          tooltip: CommonStringPartitionReplace(getText("mainmenu.meter.storage_hint"), {
+            $percentage$: `${fullness}`
+          }).join(""),
+          label: CommonStringPartitionReplace(getText("mainmenu.meter.storage_label"), {
+            $currentCapacity$: `${currentStorageCapacityKB}`,
+            $maxCapacity$: `${maxStorageCapacityKB}`
+          }).join("")
+        },
+        htmlOptions: {
+          button: {
+            children: [
+              {
+                tag: "div",
+                attributes: { id: "deeplib-storage-meter" },
+                children: [
+                  {
+                    tag: "div",
+                    attributes: { id: "deeplib-storage-bar" },
+                    style: { width: `${fullness}%` }
+                  }
+                ]
+              }
+            ]
+          }
+        }
+      });
+      layout.appendToMiscDiv(storageFullnessWrapper);
+    }
+    if (IS_DEBUG) {
+      const debugButton = advElement.createButton({
+        id: "deeplib-debug-button",
+        onClick: /* @__PURE__ */ __name(() => {
+          this.setSubscreen(new GuiDebug());
+        }, "onClick"),
+        size: [90, 90],
+        options: {
+          image: `${PUBLIC_URL}/dl_images/bug.svg`
+        }
+      });
+      if (menu) {
+        ElementMenu.PrependItem(menu, debugButton);
+      }
+    }
+  }
+  run() {
+    super.run();
+  }
+  click() {
+  }
+  exit() {
+    CharacterAppearanceForceUpCharacter = -1;
+    CharacterLoadCanvas(Player);
+    const returnScreen = typeof this.options.returnScreen === "function" ? this.options.returnScreen() : this.options.returnScreen;
+    if (!returnScreen) {
+      PreferenceOpenSubscreen("Extensions").then(() => {
+        PreferenceSubscreenExtensionsClear();
+      });
+    } else if (returnScreen instanceof BaseSubscreen) {
+      setSubscreen(returnScreen).then(() => {
+      });
+    } else if (Array.isArray(returnScreen)) {
+      CommonSetScreen(...returnScreen);
+    }
+  }
+  resize() {
+    super.resize();
+    ElementSetPosition("deeplib-misc", 1905, 930, "bottom-right");
+    ElementSetSize("deeplib-misc", 405, null);
+  }
+  static setOptions(mainMenuOptions) {
+    _MainMenu.options = mainMenuOptions;
+  }
+};
+
+// 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 DefaultLanguage = "en";
+  /** Flag to prevent re-initialization */
+  static initialized = false;
+  /** Initialize the localization system by loading translation files. */
+  static async init(initOptions) {
+    if (_Localization.initialized) return;
+    _Localization.initialized = true;
+    _Localization.PathToModTranslation = (() => {
+      if (!initOptions?.pathToTranslationsFolder) return void 0;
+      return initOptions.pathToTranslationsFolder.endsWith("/") ? initOptions.pathToTranslationsFolder : `${initOptions.pathToTranslationsFolder}/`;
+    })();
+    _Localization.DefaultLanguage = initOptions?.defaultLanguage || _Localization.DefaultLanguage;
+    const lang = initOptions?.fixedLanguage ? _Localization.DefaultLanguage : TranslationLanguage.toLowerCase();
+    const libTranslation = await _Localization.fetchLanguageFile(_Localization.PathToLibTranslation, lang);
+    if (lang === _Localization.DefaultLanguage) {
+      _Localization.LibTranslation = libTranslation;
+    } else {
+      const fallbackTranslation = await _Localization.fetchLanguageFile(_Localization.PathToLibTranslation, _Localization.DefaultLanguage);
+      _Localization.LibTranslation = { ...fallbackTranslation, ...libTranslation };
+    }
+    if (!_Localization.PathToModTranslation) return;
+    const modTranslation = await _Localization.fetchLanguageFile(_Localization.PathToModTranslation, lang);
+    if (lang === _Localization.DefaultLanguage) {
+      _Localization.ModTranslation = modTranslation;
+    } else {
+      const fallbackTranslation = await _Localization.fetchLanguageFile(_Localization.PathToModTranslation, _Localization.DefaultLanguage);
+      _Localization.ModTranslation = { ...fallbackTranslation, ...modTranslation };
+    }
+  }
+  /** Get a translated string from mod translations by source tag. */
+  static getTextMod(srcTag) {
+    return _Localization.ModTranslation?.[srcTag] || void 0;
+  }
+  /** Get a translated string from library translations by source tag. */
+  static getTextLib(srcTag) {
+    return _Localization.LibTranslation?.[srcTag] || void 0;
+  }
+  /**
+   * Fetch and parse a language file from the given base URL and language code.
+   * Falls back to default language if the requested language file is unavailable.
+   */
+  static async fetchLanguageFile(baseUrl, lang) {
+    const response = await fetch(`${baseUrl}${lang}.lang`);
+    if (lang !== _Localization.DefaultLanguage && !response.ok) {
+      return this.fetchLanguageFile(baseUrl, _Localization.DefaultLanguage);
+    }
+    if (!response.ok) {
+      return {};
+    }
+    const langFileContent = await response.text();
+    return this.parseLanguageFile(langFileContent);
+  }
+  /**
+   * Parse the raw content of a language file into a TranslationDict.
+   * Ignores empty lines and comments starting with '#'.
+   */
+  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");
+
+// src/utilities/elements/modal.ts
+var Modal = class _Modal {
+  constructor(opts) {
+    this.opts = opts;
+    opts ??= {};
+    opts.closeOnBackdrop ??= true;
+    const promptId = `modal-prompt-${Date.now()}`;
+    const prompt = (CommonIsArray(opts.prompt) ? opts.prompt : [opts.prompt]).filter((i) => i !== null) ?? [""];
+    this.dialog = ElementCreate({
+      tag: "dialog",
+      classList: ["deeplib-modal"],
+      attributes: {
+        id: this.opts.modalId ?? `modal-${Date.now()}`,
+        role: "dialog",
+        "aria-modal": "true",
+        "aria-labelledby": promptId
+      },
+      style: {
+        fontFamily: CommonGetFontName()
+      },
+      children: [
+        {
+          tag: "div",
+          classList: ["deeplib-modal-prompt-container"],
+          children: [
+            ...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 modal queue. */
+  static queue = [];
+  /** Flag to indicate if a modal is currently being shown. */
+  static processing = false;
+  /**
+   * Displays the modal and resolves with the chosen action and input value.
+   */
+  show() {
+    return _Modal.enqueue(this);
+  }
+  /**
+   * Shows a simple alert modal with a single "OK" button.
+   */
+  static async alert(msg, opts = {}) {
+    await new _Modal({
+      prompt: msg,
+      buttons: [{ action: "close", text: getText("modal.button.ok") }],
+      timeoutMs: opts.timeoutMs,
+      escapeAction: "close",
+      modalId: opts.modalId
+    }).show();
+  }
+  /**
+   * Shows a confirmation modal with "Cancel" and "OK" buttons.
+   * Returns true if "OK" is clicked.
+   */
+  static async confirm(msg, opts = {}) {
+    const [action] = await new _Modal({
+      prompt: msg,
+      buttons: [{ text: getText("modal.button.decline"), action: "decline" }, { text: getText("modal.button.confirm"), action: "confirm" }],
+      escapeAction: "decline",
+      enterAction: "confirm",
+      modalId: opts.modalId
+    }).show();
+    return action === "confirm";
+  }
+  /**
+   * Shows a prompt modal with an input field and "Submit"/"Cancel" buttons.
+   * Returns the input value if submitted, otherwise null.
+   */
+  static async prompt(msg, opts = {}) {
+    const [action, value] = await new _Modal({
+      prompt: msg,
+      timeoutMs: 0,
+      input: { type: "input", defaultValue: opts.defaultValue },
+      buttons: [{ text: getText("modal.button.cancel"), action: "cancel" }, { text: getText("modal.button.submit"), action: "submit" }],
+      escapeAction: "cancel",
+      enterAction: "submit",
+      modalId: opts.modalId
+    }).show();
+    return action === "submit" ? value : null;
+  }
+  /** Creates the input element for the modal, applying configuration and validation. */
+  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;
+  }
+  /** Creates modal action buttons from configuration. */
+  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 = advElement.createButton({
+        id: `deeplib-modal-${b.action}`,
+        onClick: /* @__PURE__ */ __name(() => this.close(b.action), "onClick"),
+        options: {
+          disabled: b.disabled,
+          label: b.text
+        }
+      });
+      container.append(btn);
+    });
+    return container;
+  }
+  /** Creates the modal backdrop blocker with optional click-to-close behavior. */
+  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;
+  }
+  /** Implements a focus trap to keep keyboard navigation inside the modal. */
+  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(this.opts.escapeAction ?? "close");
+      } else if (e.key === "Enter") {
+        if (elements.some((el) => el === document.activeElement) && document.activeElement !== this.inputEl) return;
+        e.preventDefault();
+        e.stopPropagation();
+        this.close(this.opts.enterAction ?? "submit");
+      }
+    });
+    window.requestAnimationFrame(() => {
+      (this.inputEl || first)?.focus();
+    });
+  }
+  /** Closes the modal, cleans up DOM, resolves promise, and shows next queued modal. */
+  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;
+    }
+  }
+};
+
+// src/base/initialization.ts
+var modStorage;
+var sdk;
+var logger;
+function initMod(options) {
+  const url = "https://cdn.jsdelivr.net/npm/bondage-club-mod-sdk@1.2.0/+esm";
+  import(`${url}`).then(() => {
+    sdk = new ModSdkManager(options.modInfo.info, options.modInfo.options);
+    const MOD_NAME = ModSdkManager.ModInfo.name;
+    modStorage = new ModStorage(ModSdkManager.ModInfo.name);
+    logger = new Logger(MOD_NAME);
+    Style.injectInline("deeplib-style", styles_default);
+    logger.debug("Init wait");
+    if (!CurrentScreen || CurrentScreen === "Login") {
+      options.beforeLogin?.();
+      const removeHook = sdk.hookFunction("LoginResponse", 0, (args, next) => {
+        logger.debug("Init! 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 {
+      logger.debug(`Already logged in, initing ${MOD_NAME}`);
+      init(options);
+    }
+  });
+}
+__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();
+  await Localization.init(options.translationOptions);
+  if (options.modules && !initModules(options.modules)) {
+    unloadMod();
+    return;
+  }
+  await options.initFunction?.();
+  if (options.mainMenuOptions)
+    MainMenu.setOptions(options.mainMenuOptions);
+  window[MOD_NAME + "Loaded"] = true;
+  logger.log(`Loaded! Version: ${MOD_VERSION}`);
+}
+__name(init, "init");
+function initModules(modulesToRegister) {
+  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();
+  }
+  for (const module of modules()) {
+    module.registerDefaultSettings(modStorage.playerStorage);
+  }
+  logger.debug("Modules Loaded.");
+  return true;
+}
+__name(initModules, "initModules");
+function unloadMod() {
+  const MOD_NAME = ModSdkManager.ModInfo.name;
+  unloadModules();
+  delete window[MOD_NAME + "Loaded"];
+  logger.debug("Unloaded.");
+  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");
+  }
+  /** The singleton instance of the GUI controller. */
+  static instance = null;
+  /** All subscreens managed by this GUI, including the main menu and module settings screens. */
+  _subscreens;
+  /** The mod's main menu screen. */
+  _mainMenu;
+  /** Options defining how the mod's settings button is displayed and behaves. */
+  _modButtonOptions;
+  /** Returns all registered subscreens. */
+  get subscreens() {
+    return this._subscreens;
+  }
+  /** Returns the main menu subscreen instance. */
+  get mainMenu() {
+    return this._mainMenu;
+  }
+  /** 
+   * Creates the GUI instance and initializes the main menu. 
+   * 
+   * @throws If another `GUI` instance already exists.
+   */
+  constructor(guiOptions = null) {
+    super();
+    if (_GUI.instance) {
+      throw new Error("Duplicate initialization");
+    }
+    for (const module of modules()) {
+      if (!module.settingsScreen) continue;
+    }
+    this._mainMenu = guiOptions?.mainMenu ? new guiOptions.mainMenu(this) : new MainMenu(this);
+    this._subscreens = [this._mainMenu];
+    this._modButtonOptions = guiOptions;
+    _GUI.instance = this;
+  }
+  /**
+   * Loads the GUI and registers the mod's settings button in the extensions menu.
+   *
+   * - Creates subscreens for each module's settings screen.
+   * - Registers lifecycle callbacks for subscreens events.
+   * - Sets up the main menu and its subscreens.
+   */
+  load() {
+    if (!this._modButtonOptions) return;
+    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: /* @__PURE__ */ __name(async () => {
+        await setSubscreen(this._mainMenu);
+      }, "load"),
+      run: /* @__PURE__ */ __name(() => {
+      }, "run"),
+      click: /* @__PURE__ */ __name(() => {
+      }, "click"),
+      exit: /* @__PURE__ */ __name(() => {
+      }, "exit")
+    });
+  }
+};
+
+// src/utilities/data.ts
+var ModStorage = class _ModStorage {
+  static {
+    __name(this, "ModStorage");
+  }
+  /** Singleton instance of ModStorage */
+  static _instance = null;
+  /** The unique mod identifier used as key prefix in storage */
+  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 = {
+          Version: ModSdkManager.ModInfo.version
+        };
+      } 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));
+  }
+  static measureSize(data) {
+    try {
+      if (typeof data !== "string") {
+        data = JSON.stringify(data) || "";
+      }
+      if (typeof data === "string") {
+        return new TextEncoder().encode(data).byteLength;
+      }
+      throw new Error();
+    } catch {
+      return NaN;
+    }
+  }
+};
+
+// src/utilities/elements/helpers.ts
+var domUtil = {
+  /**
+   * Automatically sets the position of the element based on the given position.
+   * The position can be either a [x, y] tuple or a function returning such a tuple.
+   * If both x and y are defined, the element's position is updated accordingly.
+   */
+  autoSetPosition,
+  /**
+   * Automatically sets the size of the element based on the given size.
+   * The size can be either a [width, height] tuple or a function returning such a tuple.
+   * If both width and height are defined, the element's size is updated accordingly.
+   */
+  autoSetSize,
+  /**
+   * Hides the element by setting its CSS display property to 'none'.
+   * If the element cannot be found, the function does nothing.
+   */
+  hide,
+  /**
+   * Unhides the element by clearing its CSS display property (sets it to '').
+   * If the element cannot be found, the function does nothing.
+   */
+  unhide,
+  /**
+   * Checks if the element has overflow content.
+   * Returns an object indicating if there is any overflow,
+   * and specifically if there is vertical or horizontal overflow.
+   * Returns null if the element is not found.
+   */
+  hasOverflow
+};
+function autoSetPosition(_, position) {
+  let xPos = void 0;
+  let yPos = void 0;
+  let anchor = void 0;
+  if (Array.isArray(position)) {
+    xPos = position[0];
+    yPos = position[1];
+    anchor = position[2];
+  } else if (typeof position === "function") {
+    const result = position();
+    xPos = result[0];
+    yPos = result[1];
+    anchor = result[2];
+  }
+  if (xPos !== void 0 && yPos !== void 0) ElementSetPosition(_, xPos, yPos, anchor);
+}
+__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.ts
+var layout = {
+  getSubscreen: elementGetSubscreenDiv,
+  appendToSubscreen: elementAppendToSubscreenDiv,
+  removeSubscreen: elementRemoveSubscreenDiv,
+  getSettingsDiv: elementGetSettingsDiv,
+  appendToSettingsDiv: elementAppendToSettingsDiv,
+  removeSettingsDiv: elementRemoveSettingsDiv,
+  getMiscDiv: elementGetMiscDiv,
+  appendToMiscDiv: elementAppendToMiscDiv,
+  removeMiscDiv: elementRemoveMiscDiv
+};
+function elementGetSubscreenDiv() {
+  const subscreenDiv = ElementWrap("deeplib-subscreen");
+  if (subscreenDiv) {
+    return subscreenDiv;
+  }
+  const div = ElementCreate({
+    tag: "div",
+    classList: ["deeplib-subscreen", "HideOnPopup"],
+    attributes: { id: "deeplib-subscreen" }
+  });
+  return document.body.appendChild(div);
+}
+__name(elementGetSubscreenDiv, "elementGetSubscreenDiv");
+function elementRemoveSubscreenDiv() {
+  return elementGetSubscreenDiv()?.remove();
+}
+__name(elementRemoveSubscreenDiv, "elementRemoveSubscreenDiv");
+function elementAppendToSubscreenDiv(...element) {
+  return elementGetSubscreenDiv()?.append(...element);
+}
+__name(elementAppendToSubscreenDiv, "elementAppendToSubscreenDiv");
+function elementGetSettingsDiv() {
+  const settingsDiv = ElementWrap("deeplib-settings");
+  if (settingsDiv) {
+    return settingsDiv;
+  }
+  const div = ElementCreate({
+    tag: "div",
+    classList: ["deeplib-settings", "scroll-box"],
+    attributes: { id: "deeplib-settings" }
+  });
+  return div;
+}
+__name(elementGetSettingsDiv, "elementGetSettingsDiv");
+function elementAppendToSettingsDiv(...element) {
+  return elementGetSettingsDiv()?.append(...element);
+}
+__name(elementAppendToSettingsDiv, "elementAppendToSettingsDiv");
+function elementRemoveSettingsDiv() {
+  return elementGetSettingsDiv()?.remove();
+}
+__name(elementRemoveSettingsDiv, "elementRemoveSettingsDiv");
+function elementGetMiscDiv() {
+  const miscDiv = ElementWrap("deeplib-misc");
+  if (miscDiv) {
+    return miscDiv;
+  }
+  const div = ElementCreate({
+    tag: "div",
+    classList: ["deeplib-misc"],
+    attributes: { id: "deeplib-misc" }
+  });
+  return div;
+}
+__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 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;
+  /** Registers a mod with the SDK and stores mod information. */
+  constructor(info, options) {
+    _ModSdkManager.SDK = bcModSdk.registerMod(info, options);
+    _ModSdkManager.ModInfo = info;
+  }
+  /** Retrieves or initializes patch data for a given target function. */
+  initPatchableFunction(target) {
+    let result = _ModSdkManager.patchedFunctions.get(target);
+    if (!result) {
+      result = {
+        name: target,
+        hooks: []
+      };
+      _ModSdkManager.patchedFunctions.set(target, result);
+    }
+    return result;
+  }
+  /**
+   * Hooks a function with a callback at a given priority. 
+   * 
+   * Prevents duplicate hooks.
+   */
+  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;
+  }
+  /**
+   * Applies patches to a target function.
+   * 
+   * **This method is DANGEROUS** to use and has high potential to conflict with other mods.
+   */
+  patchFunction(target, patches) {
+    _ModSdkManager.SDK?.patchFunction(target, patches);
+  }
+  /**
+   * Removes all patches from a target function.
+   */
+  unpatchFunction(target) {
+    _ModSdkManager.SDK?.removePatches(target);
+  }
+  /**
+   * Removes all hooks associated with a specific module from a target function.
+   */
+  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;
+  }
+  /**
+   * Removes all hooks associated with a specific module across all patched functions.
+   */
+  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 = {
+  /**
+   * Injects a CSS style block directly into the document head using a <style> tag.
+   * If a style element with the same `styleId` already exists, it won't inject again.
+   */
+  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);
+  },
+  /**
+   * Injects a CSS stylesheet link into the document head using a <link> tag.
+   * If a link element with the same `styleId` already exists, it won't inject again.
+   */
+  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);
+  },
+  /**
+   * Removes a style element from the document head by its ID.
+   * Does nothing if the element is not found.
+   */
+  eject(id) {
+    const style = document.getElementById(id);
+    if (!style) return;
+    style.remove();
+  },
+  /**
+   * Reloads an inline style by removing the existing style element (if any)
+   * and injecting the new styles inline again.
+   */
+  reload(styleId, styleSource) {
+    Style.eject(styleId);
+    Style.injectInline(styleId, styleSource);
+  },
+  /** Fetches the text content of a stylesheet or any resource at the given link. */
+  async fetch(link) {
+    return fetch(link).then((res) => res.text());
+  }
+};
+
+// src/utilities/event_channel.ts
+var EventChannel = class {
+  constructor(channelName) {
+    this.channelName = channelName;
+    ModSdkManager.prototype.hookFunction("ChatRoomMessageProcessHidden", 0, (args, next) => {
+      if (!this.isChannelMessage(args[0])) {
+        return next(args);
+      }
+      const [message, sender] = args;
+      const { type, data } = message.Dictionary[0];
+      const listeners = this.listeners[type];
+      if (listeners) {
+        listeners.forEach((listener) => listener(data, sender));
+      }
+      return next(args);
+    }, `EventChannel-${channelName}`);
+  }
+  static {
+    __name(this, "EventChannel");
+  }
+  listeners = {};
+  unload() {
+    Object.keys(this.listeners).forEach((key) => delete this.listeners[key]);
+    ModSdkManager.prototype.removeHookByModule("ChatRoomMessageProcessHidden", `EventChannel-${this.channelName}`);
+  }
+  sendEvent(type, data, target = null) {
+    const packet = {
+      Type: "Hidden",
+      Content: this.channelName,
+      Sender: Player.MemberNumber,
+      ...target ? { Target: target } : {},
+      Dictionary: [
+        {
+          type,
+          data
+        }
+      ]
+    };
+    ServerSend("ChatRoomChat", packet);
+  }
+  registerListener(event, listener) {
+    const listeners = this.listeners[event] ?? [];
+    listeners.push(listener);
+    this.listeners[event] = listeners;
+    return () => this.unregisterListener(event, listener);
+  }
+  unregisterListener(event, listener) {
+    const listeners = this.listeners[event];
+    if (listeners) {
+      const index = listeners.indexOf(listener);
+      if (index !== -1) {
+        listeners.splice(index, 1);
+      }
+    }
+  }
+  isChannelMessage(message) {
+    return message && message.Type === "Hidden" && message.Content === this.channelName && message.Sender && message.Sender !== Player.MemberNumber && message.Dictionary && !!message.Dictionary[0]?.data && !!message.Dictionary[0]?.type || false;
+  }
+};
+export {
+  BaseMigrator2 as BaseMigrator,
+  BaseModule,
+  BaseSubscreen,
+  EventChannel,
+  GUI,
+  HookPriority,
+  Localization,
+  Logger,
+  ModSdkManager,
+  ModStorage,
+  Modal,
+  Style,
+  advElement,
+  byteToKB,
+  deepLibLogger,
+  deepMerge,
+  domUtil,
+  exportToGlobal,
+  getModule,
+  getText,
+  hasGetter,
+  hasSetter,
+  initMod,
+  layout,
+  logger,
+  modStorage,
+  modules,
+  modulesMap,
+  registerModule,
+  sdk,
+  sendActionMessage,
+  sendLocalMessage,
+  setSubscreen,
+  shuffleArray,
+  unloadMod
+};
+//# sourceMappingURL=deeplib.js.map